From f709158a31f681befb601cf01c1a4a34d7675e65 Mon Sep 17 00:00:00 2001
From: Harry Cordewener <admin@twilightdays.org>
Date: Tue, 22 Sep 2026 11:26:30 -0500
Subject: [PATCH 1/4] A shared vocabulary that every format writes in its own
 dialect

A game says a sound, a picture or a pane once, and each format writes it
its own way or stands something in for it: MXP <SOUND>, Pueblo
<img xch_sound>, HTML <audio>, a terminal nothing; a picture falls back to
its description or address; a pane keeps its text in the main window.

The types are core's (SoundMarkup, ImageMarkup, PaneMarkup, ...) with
MarkupText factories and built-in codecs. The format packages supply the
emitters: WithHtml for a browser, WithAnsi for a terminal's clear and
BBCode's [img], and two new packages, MarkupString.Mxp (held to the
client's <SUPPORT> answer) and MarkupString.Pueblo (names and attributes
from the Pueblo client's source).

Points (IPointMarkup) ride on a carrier that is not text: ToPlainText,
ToString and equality leave it out, and a format with no emitter for a
point writes nothing, not even the styling around it.

The Ansi set emitters now keep foreign layers nested inside the styling
inside it, so a picture inside a command link stays a link.

The changelog's 2.2.0 entries move under their own heading.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 .github/workflows/ci.yml                      |   4 +-
 CHANGELOG.md                                  |  54 ++-
 MarkupString.Ansi/AnsiRegistration.cs         |   9 +-
 .../Emitters/AnsiBBCodeEmitter.cs             |   3 +
 .../Emitters/AnsiEmitterSupport.cs            |  59 +++-
 MarkupString.Ansi/Emitters/AnsiHtmlEmitter.cs |   3 +
 MarkupString.Ansi/Emitters/AnsiSetEmitter.cs  |   3 +
 MarkupString.Ansi/Emitters/ElementEmitters.cs |  47 +++
 .../MarkupString.AotSmoke.csproj              |   4 +
 MarkupString.AotSmoke/Program.cs              |  19 +-
 .../Emitters/ElementHtmlEmitter.cs            | 128 ++++++++
 MarkupString.Html/HtmlRegistration.cs         |  10 +-
 MarkupString.Html/README.md                   |   5 +
 .../Emitters/ElementMxpEmitter.cs             | 228 +++++++++++++
 MarkupString.Mxp/MarkupString.Mxp.csproj      |  27 ++
 MarkupString.Mxp/MxpRegistration.cs           |  39 +++
 MarkupString.Mxp/PublicAPI.Shipped.txt        |   0
 MarkupString.Mxp/PublicAPI.Unshipped.txt      |   4 +
 MarkupString.Mxp/README.md                    |  68 ++++
 .../Emitters/ElementPuebloEmitter.cs          |  98 ++++++
 .../MarkupString.Pueblo.csproj                |  28 ++
 MarkupString.Pueblo/PublicAPI.Shipped.txt     |   0
 MarkupString.Pueblo/PublicAPI.Unshipped.txt   |   3 +
 MarkupString.Pueblo/PuebloRegistration.cs     |  24 ++
 MarkupString.Pueblo/README.md                 |  51 +++
 .../Ansi/AnsiForeignLayerTests.cs             |  34 +-
 MarkupString.Tests/BellTests.cs               |   6 +-
 MarkupString.Tests/Html/HtmlMarkupTests.cs    |   9 +-
 MarkupString.Tests/MarkupString.Tests.csproj  |   2 +
 MarkupString.Tests/SharedVocabularyTests.cs   | 307 ++++++++++++++++++
 ...RendersStably_formatName=html.verified.txt |   2 +-
 ..._RendersStably_formatName=mxp.verified.txt |   2 +-
 ...ndersStably_formatName=pueblo.verified.txt |   2 +-
 MarkupString.slnx                             |   2 +
 MarkupString/BellMarkup.cs                    |   2 +-
 MarkupString/Elements/ElementCodecs.cs        | 135 ++++++++
 MarkupString/Elements/ImageMarkup.cs          |  41 +++
 MarkupString/Elements/PaneMarkup.cs           |  14 +
 MarkupString/Elements/ScreenMarkup.cs         |  65 ++++
 MarkupString/Elements/SoundMarkup.cs          |  52 +++
 MarkupString/Elements/StatusMarkup.cs         |  36 ++
 MarkupString/IPointMarkup.cs                  |  18 +
 MarkupString/MarkupText.Elements.cs           | 152 +++++++++
 MarkupString/MarkupText.cs                    |  53 ++-
 MarkupString/MarkupTextRenderer.cs            |  54 ++-
 MarkupString/MarkupTextSerializer.cs          |  17 +-
 MarkupString/PublicAPI.Unshipped.txt          | 196 +++++++++++
 README.md                                     |  22 +-
 docs/formats.md                               |  59 +++-
 docs/releasing.md                             |   8 +-
 50 files changed, 2131 insertions(+), 77 deletions(-)
 create mode 100644 MarkupString.Ansi/Emitters/ElementEmitters.cs
 create mode 100644 MarkupString.Html/Emitters/ElementHtmlEmitter.cs
 create mode 100644 MarkupString.Mxp/Emitters/ElementMxpEmitter.cs
 create mode 100644 MarkupString.Mxp/MarkupString.Mxp.csproj
 create mode 100644 MarkupString.Mxp/MxpRegistration.cs
 create mode 100644 MarkupString.Mxp/PublicAPI.Shipped.txt
 create mode 100644 MarkupString.Mxp/PublicAPI.Unshipped.txt
 create mode 100644 MarkupString.Mxp/README.md
 create mode 100644 MarkupString.Pueblo/Emitters/ElementPuebloEmitter.cs
 create mode 100644 MarkupString.Pueblo/MarkupString.Pueblo.csproj
 create mode 100644 MarkupString.Pueblo/PublicAPI.Shipped.txt
 create mode 100644 MarkupString.Pueblo/PublicAPI.Unshipped.txt
 create mode 100644 MarkupString.Pueblo/PuebloRegistration.cs
 create mode 100644 MarkupString.Pueblo/README.md
 create mode 100644 MarkupString.Tests/SharedVocabularyTests.cs
 create mode 100644 MarkupString/Elements/ElementCodecs.cs
 create mode 100644 MarkupString/Elements/ImageMarkup.cs
 create mode 100644 MarkupString/Elements/PaneMarkup.cs
 create mode 100644 MarkupString/Elements/ScreenMarkup.cs
 create mode 100644 MarkupString/Elements/SoundMarkup.cs
 create mode 100644 MarkupString/Elements/StatusMarkup.cs
 create mode 100644 MarkupString/IPointMarkup.cs
 create mode 100644 MarkupString/MarkupText.Elements.cs

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index dd57f02..b2943e2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -23,7 +23,7 @@ jobs:
       # SDK (the MSBuild build host crashes). Whitespace rules are syntactic, so nothing is lost.
       - name: Verify formatting
         run: |
-          for dir in MarkupString MarkupString.Ansi MarkupString.Html MarkupString.Tests MarkupString.AotSmoke; do
+          for dir in MarkupString MarkupString.Ansi MarkupString.Html MarkupString.Mxp MarkupString.Pueblo MarkupString.Tests MarkupString.AotSmoke; do
             dotnet format whitespace --folder "$dir" --exclude "**/bin/**" --exclude "**/obj/**" --verify-no-changes
           done
 
@@ -70,7 +70,7 @@ jobs:
         with:
           dotnet-version: 10.0.x
 
-      # The packages promise IsAotCompatible. Publishing the smoke app with all three assemblies
+      # The packages promise IsAotCompatible. Publishing the smoke app with every package assembly
       # rooted analyses every public entry point, so a trim- or AOT-hostile addition fails here
       # instead of in a consumer's app. Any IL2xxx/IL3xxx warning is an error.
       - name: Publish natively and fail on any trim/AOT warning
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 221d4fb..580dc0b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,7 @@
 # Changelog
 
-All notable changes to `MarkupString`, `MarkupString.Ansi` and `MarkupString.Html`. The three
-packages share one version and are released together.
+All notable changes to `MarkupString`, `MarkupString.Ansi`, `MarkupString.Html`, `MarkupString.Mxp`
+and `MarkupString.Pueblo`. The packages share one version and are released together.
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project
 follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
@@ -10,13 +10,55 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **A shared vocabulary.** A game puts a thing in its text once and every format writes it in its own
+  dialect, or stands something else in for it. The types are core's and say what a thing is; each
+  format's package says how it is written:
+
+  | Factory | MXP | Pueblo | HTML | ANSI / Plain / BBCode |
+  |---|---|---|---|---|
+  | `MarkupText.Sound`, `Music` | `<SOUND>`, `<MUSIC>` | `<img xch_sound="play"\|"loop">` | `<audio>` | nothing |
+  | `MarkupText.StopSound` | `<SOUND Off>`, `<MUSIC Off>` | `<img xch_sound="stop">` | `ms-sound-stop` | nothing |
+  | `MarkupText.Image` | `<IMAGE>` | `<img>` | `<img>` | its description, or its address; BBCode `[img]` |
+  | `MarkupText.Pane` | `<FRAME>` + `<DEST>` | `<xch_pane action="redirect">` and back | `ms-pane` | its text |
+  | `MarkupText.ClearScreen` | nothing | `<xch_page clear="text">` | `ms-clear` | ANSI `ESC[H ESC[2J` |
+  | `MarkupText.Prefetch` | nothing | `<xch_prefetch>` | `<link rel="prefetch">` | nothing |
+  | `MarkupText.ExpireLinks` | `<EXPIRE>` | nothing | `ms-expire` | nothing |
+  | `MarkupText.Variable`, `Gauge`, `Status` | `<VAR>`, `<GAUGE>`, `<STAT>` | their text | `ms-variable`, `ms-gauge`, `ms-status` | their text |
+  | `MarkupText.Relocate`, `LoginPrompt` | `<RELOCATE>`, `<USER>`, `<PASSWORD>` | nothing | nothing | nothing |
+
+  A link is already this kind of thing (`AnsiMarkup` with a `LinkKind`), so a picture inside a link is
+  a picture that is a link in every dialect. The vocabulary serialises as built-in kinds, so storing it
+  needs no package registered.
+- **Points.** `IPointMarkup` is a markup that stands at a point rather than marking text — a sound, a
+  bell, a clear. It rides on `MarkupText.PointCarrier` (a zero-width space; the bell keeps its own
+  U+0007), and `MarkupText.Point(markup)` builds one of your own. A format with no emitter for a point
+  writes nothing at all — not the carrier, and not the layers around it.
+- **`MarkupString.Mxp`**, a new package. `WithMxp()` writes the vocabulary as MXP's secure elements.
+  `WithMxp(supports)` holds each element to what the client answered to `<SUPPORT>`: one it refused is
+  written as a format without MXP writes it — nothing for a sound, the description for a picture, the
+  text in the main window for a pane. `MxpRegistration.Elements` lists the names to ask about.
+- **`MarkupString.Pueblo`**, a new package. `WithPueblo()` writes the vocabulary in the Pueblo
+  client's own extensions, with the names and attributes its source reads.
 - **A bell.** `MarkupText.Bell()` marks a point in the text where the client is asked to get someone's
   attention: U+0007 for a terminal, Pueblo or MXP client, and an empty `<span class="ms-bell"
   role="alert">` for HTML, where the page decides what a bell means. Plain and BBCode leave nothing
-  behind. It rides on the single U+0007 it marks, which measures zero display cells, so it survives
-  slicing, concatenation and padding as a point in the string without moving anything laid out around
-  it — and it is the only way to get a control character into rendered output, since the encodings
-  drop them from ordinary text.
+  behind. It is a point riding on the U+0007 it marks, which measures zero display cells, so it survives
+  slicing, concatenation and padding without moving anything laid out around it — and it is the only
+  way to get a control character into rendered output, since the encodings drop them from ordinary
+  text.
+
+### Changed
+
+- **`ToPlainText()`, `ToString()` and equality leave out point carriers.** A sound or a bell is not
+  text a reader or a pattern sees: `Concat(Sound(...), Plain("hi"))` equals `Plain("hi")`. `Text`
+  still holds the carriers, so positions, slicing and padding are unchanged.
+- **A layer from another package nested inside ANSI styling now renders inside it.** The Ansi
+  package's set emitters used to wrap every layer they do not own around their own output, whatever
+  the nesting: `Wrap(red, Wrap(HtmlMarkup "b", "x"))` gave `<b><span style="color: …">x</span></b>`.
+  It now gives `<span style="color: …"><b>x</b></span>`, and a picture inside a command link stays
+  inside the link rather than replacing it. Layers outside the styling still wrap it.
+
+## 2.2.0 — 2026-09-19
 
 ### Added
 
diff --git a/MarkupString.Ansi/AnsiRegistration.cs b/MarkupString.Ansi/AnsiRegistration.cs
index 29e17f3..2542f8d 100644
--- a/MarkupString.Ansi/AnsiRegistration.cs
+++ b/MarkupString.Ansi/AnsiRegistration.cs
@@ -5,7 +5,9 @@ public static class AnsiRegistration
 {
 	/// <summary>
 	/// Returns a registry that renders <see cref="AnsiMarkup"/> in all six formats and serialises
-	/// it under kind <c>"ansi"</c>. Plain needs nothing: the body passes through.
+	/// it under kind <c>"ansi"</c>. Plain needs nothing: the body passes through. It also writes the
+	/// bell, a <see cref="ClearScreenMarkup"/> for a terminal, and an <see cref="ImageMarkup"/> as
+	/// BBCode's <c>[img]</c>.
 	/// </summary>
 	/// <remarks>
 	/// The five emitters are <see cref="IMarkupSetEmitter"/>s — one per format, claiming the whole
@@ -30,6 +32,9 @@ public static MarkupRegistry WithAnsi(this MarkupRegistry registry)
 			.With(new BellEmitter(MarkupFormat.Ansi))
 			.With(new BellEmitter(MarkupFormat.Pueblo))
 			.With(new BellEmitter(MarkupFormat.Mxp))
-			.With(new BellEmitter(MarkupFormat.Html));
+			.With(new BellEmitter(MarkupFormat.Html))
+			// From the shared vocabulary, what a terminal and BBCode can express.
+			.With(new ClearScreenAnsiEmitter())
+			.With(new ImageBBCodeEmitter());
 	}
 }
diff --git a/MarkupString.Ansi/Emitters/AnsiBBCodeEmitter.cs b/MarkupString.Ansi/Emitters/AnsiBBCodeEmitter.cs
index 5f41bc8..270aec2 100644
--- a/MarkupString.Ansi/Emitters/AnsiBBCodeEmitter.cs
+++ b/MarkupString.Ansi/Emitters/AnsiBBCodeEmitter.cs
@@ -17,6 +17,9 @@ public bool TryEmit(MarkupSet set, ReadOnlySpan<char> body, in EmitContext conte
 		ArgumentNullException.ThrowIfNull(set);
 		ArgumentNullException.ThrowIfNull(output);
 
+		using var inner = AnsiEmitterSupport.WriteInner(set, body, context);
+		if (inner is not null) body = inner.WrittenSpan;
+
 		var style = AnsiEmitterSupport.Fold(set, context.Format);
 
 		// Reverse video has no BBCode form either, so the colour that would show as the text colour
diff --git a/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs b/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs
index 56423fa..e0b3d02 100644
--- a/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs
+++ b/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs
@@ -52,11 +52,60 @@ internal static AnsiStyle Fold(MarkupSet? set, MarkupFormat format)
 		return effective;
 	}
 
+	/// <summary>
+	/// The layers this package does not own that sit inside every layer it does — a picture inside a
+	/// link — applied to <paramref name="body"/> before any styling is, so they stay inside it. Null when
+	/// there are none, and the body is used as it is.
+	/// </summary>
+	internal static PooledCharWriter? WriteInner(MarkupSet set, ReadOnlySpan<char> body, in EmitContext context)
+	{
+		var boundary = FirstClaimed(set, context.Format);
+		PooledCharWriter? front = null;
+		PooledCharWriter? back = null;
+		try
+		{
+			for (var i = 0; i < boundary; i++)
+			{
+				var emitter = context.Registry.FindEmitter(set[i].GetType(), context.Format);
+				if (emitter is null) continue;
+
+				if (front is null)
+				{
+					front = new PooledCharWriter(body.Length + 16);
+					front.Write(body);
+				}
+
+				back ??= new PooledCharWriter(front.WrittenCount + 16);
+				back.Clear();
+				emitter.Emit(set[i], front.WrittenSpan, context, back);
+				(front, back) = (back, front);
+			}
+
+			var written = front;
+			front = null;
+			return written;
+		}
+		finally
+		{
+			front?.Dispose();
+			back?.Dispose();
+		}
+	}
+
+	/// <summary>The index of the innermost layer this package folds, or the set's size when it folds none.</summary>
+	private static int FirstClaimed(MarkupSet set, MarkupFormat format)
+	{
+		for (var i = 0; i < set.Count; i++)
+			if (ClaimsStyle(set[i], format, out _)) return i;
+		return set.Count;
+	}
+
 	/// <summary>
 	/// Writes <paramref name="core"/> — the run as this package rendered it — wrapped by the layers
-	/// this package does not own in <see cref="EmitContext.Format"/>, innermost first, each through
-	/// its own emitter for that format. A layer with no emitter registered for the format wraps in
-	/// nothing: its body passes through.
+	/// this package does not own in <see cref="EmitContext.Format"/> that sit outside the innermost one
+	/// it does (<see cref="WriteInner"/> took those inside), innermost first, each through its own
+	/// emitter for that format. A layer with no emitter registered for the format wraps in nothing: its
+	/// body passes through.
 	/// </summary>
 	internal static void WriteWrapped(
 		MarkupSet set,
@@ -68,7 +117,7 @@ internal static void WriteWrapped(
 		PooledCharWriter? back = null;
 		try
 		{
-			for (var i = 0; i < set.Count; i++)
+			for (var i = FirstClaimed(set, context.Format); i < set.Count; i++)
 			{
 				var layer = set[i];
 				if (ClaimsStyle(layer, context.Format, out _)) continue;
@@ -133,6 +182,8 @@ internal static void EmitTagged(
 		TagFlavour flavour)
 	{
 		var style = Fold(set, context.Format);
+		using var inner = WriteInner(set, body, context);
+		if (inner is not null) body = inner.WrittenSpan;
 
 		using var core = new PooledCharWriter(body.Length + 64);
 		SgrWriter.Transition(AnsiStyle.None, style, core);
diff --git a/MarkupString.Ansi/Emitters/AnsiHtmlEmitter.cs b/MarkupString.Ansi/Emitters/AnsiHtmlEmitter.cs
index 87d6fef..54152e4 100644
--- a/MarkupString.Ansi/Emitters/AnsiHtmlEmitter.cs
+++ b/MarkupString.Ansi/Emitters/AnsiHtmlEmitter.cs
@@ -19,6 +19,9 @@ public bool TryEmit(MarkupSet set, ReadOnlySpan<char> body, in EmitContext conte
 		ArgumentNullException.ThrowIfNull(set);
 		ArgumentNullException.ThrowIfNull(output);
 
+		using var inner = AnsiEmitterSupport.WriteInner(set, body, context);
+		if (inner is not null) body = inner.WrittenSpan;
+
 		var style = AnsiEmitterSupport.Fold(set, context.Format);
 
 		// Reverse video swaps the two colours rather than asking the browser to.
diff --git a/MarkupString.Ansi/Emitters/AnsiSetEmitter.cs b/MarkupString.Ansi/Emitters/AnsiSetEmitter.cs
index 8c156ed..ed58d01 100644
--- a/MarkupString.Ansi/Emitters/AnsiSetEmitter.cs
+++ b/MarkupString.Ansi/Emitters/AnsiSetEmitter.cs
@@ -18,6 +18,9 @@ public bool TryEmit(MarkupSet set, ReadOnlySpan<char> body, in EmitContext conte
 		ArgumentNullException.ThrowIfNull(set);
 		ArgumentNullException.ThrowIfNull(output);
 
+		using var inner = AnsiEmitterSupport.WriteInner(set, body, context);
+		if (inner is not null) body = inner.WrittenSpan;
+
 		var effective = AnsiEmitterSupport.Fold(set, context.Format);
 		var previous = AnsiEmitterSupport.Fold(context.Previous, context.Format);
 
diff --git a/MarkupString.Ansi/Emitters/ElementEmitters.cs b/MarkupString.Ansi/Emitters/ElementEmitters.cs
new file mode 100644
index 0000000..bdafcf9
--- /dev/null
+++ b/MarkupString.Ansi/Emitters/ElementEmitters.cs
@@ -0,0 +1,47 @@
+using System.Buffers;
+namespace MarkupString.Ansi;
+
+/// <summary>
+/// Clears a terminal's screen. The rest of the shared vocabulary is left to the core rule for a
+/// terminal: a point writes nothing, and a markup wrapping text writes the text.
+/// </summary>
+internal sealed class ClearScreenAnsiEmitter : IMarkupEmitter
+{
+	/// <summary>Home the cursor, then erase the display.</summary>
+	internal const string Sequence = "\u001b[H\u001b[2J";
+
+	public Type MarkupType => typeof(ClearScreenMarkup);
+
+	public MarkupFormat Format => MarkupFormat.Ansi;
+
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(output);
+		output.Write(Sequence);
+	}
+}
+
+/// <summary>A picture as BBCode's <c>[img]</c>, in place of the text a terminal is shown.</summary>
+internal sealed class ImageBBCodeEmitter : IMarkupEmitter
+{
+	public Type MarkupType => typeof(ImageMarkup);
+
+	public MarkupFormat Format => MarkupFormat.BBCode;
+
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(output);
+
+		// A bracket would close the tag early, and BBCode has no way to escape one.
+		var source = ((ImageMarkup)markup).Source;
+		if (source.AsSpan().IndexOfAny('[', ']') >= 0)
+		{
+			output.Write(body);
+			return;
+		}
+
+		output.Write("[img]");
+		output.Write(source);
+		output.Write("[/img]");
+	}
+}
diff --git a/MarkupString.AotSmoke/MarkupString.AotSmoke.csproj b/MarkupString.AotSmoke/MarkupString.AotSmoke.csproj
index f0928af..820fcfb 100644
--- a/MarkupString.AotSmoke/MarkupString.AotSmoke.csproj
+++ b/MarkupString.AotSmoke/MarkupString.AotSmoke.csproj
@@ -18,11 +18,15 @@
     <TrimmerRootAssembly Include="MarkupString" />
     <TrimmerRootAssembly Include="MarkupString.Ansi" />
     <TrimmerRootAssembly Include="MarkupString.Html" />
+    <TrimmerRootAssembly Include="MarkupString.Mxp" />
+    <TrimmerRootAssembly Include="MarkupString.Pueblo" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\MarkupString\MarkupString.csproj" />
     <ProjectReference Include="..\MarkupString.Ansi\MarkupString.Ansi.csproj" />
     <ProjectReference Include="..\MarkupString.Html\MarkupString.Html.csproj" />
+    <ProjectReference Include="..\MarkupString.Mxp\MarkupString.Mxp.csproj" />
+    <ProjectReference Include="..\MarkupString.Pueblo\MarkupString.Pueblo.csproj" />
   </ItemGroup>
 </Project>
diff --git a/MarkupString.AotSmoke/Program.cs b/MarkupString.AotSmoke/Program.cs
index 4c87612..bf0167a 100644
--- a/MarkupString.AotSmoke/Program.cs
+++ b/MarkupString.AotSmoke/Program.cs
@@ -2,13 +2,15 @@
 using MarkupString;
 using MarkupString.Ansi;
 using MarkupString.Html;
+using MarkupString.Mxp;
+using MarkupString.Pueblo;
 
 // Native-AOT smoke test. It is published with PublishAot and run in CI: the publish must produce no
 // IL2xxx/IL3xxx warning, and the binary must exit 0. What it exercises is the whole pipeline that a
 // consumer touches — registry composition, nested markup, every built-in format, and the JSON
 // round trip — because those are where reflection or dynamic code would have crept in.
 
-MarkupRegistry.Default = MarkupRegistry.Empty.WithAnsi().WithHtml();
+MarkupRegistry.Default = MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp().WithPueblo();
 
 // Bold red on its own, so the plain SGR sequence appears un-merged with anything else.
 var red = MarkupText.Wrap(AnsiCodeParser.Parse("hr"), "red");
@@ -35,7 +37,14 @@
 	AnsiMarkup.Create(linkUrl: "look", linkKind: LinkKind.Command),
 	"look");
 
-var text = MarkupText.Concat([red, wide, nested, MarkupText.Space, link, MarkupText.Space, command]);
+// The shared vocabulary: a point (a sound), a markup that stands text in for itself (a picture), and one
+// that carries its text somewhere else (a pane) — each written differently by every format.
+var shared = MarkupText.Concat([
+	MarkupText.Sound("door.wav"),
+	MarkupText.Image("map.png", "A map"),
+	MarkupText.Pane(MarkupText.Plain("gate"), "map")]);
+
+var text = MarkupText.Concat([red, wide, nested, MarkupText.Space, link, MarkupText.Space, command, shared]);
 
 MarkupFormat[] formats =
 [
@@ -87,6 +96,12 @@
 Expect(rendered["pueblo"], "<A XCH_CMD=\"look\"", "pueblo");
 Expect(rendered["mxp"], "<SEND HREF=\"look\"", "mxp");
 Expect(rendered["bbcode"], "[color=#ff5555]", "bbcode");
+Expect(rendered["mxp"], "<SOUND door.wav>", "mxp");
+Expect(rendered["mxp"], "<DEST map>gate</DEST>", "mxp");
+Expect(rendered["pueblo"], "<img xch_sound=\"play\" href=\"door.wav\">", "pueblo");
+Expect(rendered["html"], "<audio class=\"ms-sound\"", "html");
+Expect(rendered["bbcode"], "[img]map.png[/img]", "bbcode");
+Expect(rendered["ansi"], "A mapgate", "ansi");
 
 var graphemeSource = MarkupText.Wrap(HtmlMarkup.Create("b"),
 	MarkupText.Wrap(AnsiMarkup.Create(underlined: true), "界e\u0301😀"));
diff --git a/MarkupString.Html/Emitters/ElementHtmlEmitter.cs b/MarkupString.Html/Emitters/ElementHtmlEmitter.cs
new file mode 100644
index 0000000..4cc3a3f
--- /dev/null
+++ b/MarkupString.Html/Emitters/ElementHtmlEmitter.cs
@@ -0,0 +1,128 @@
+using System.Buffers;
+using System.Globalization;
+namespace MarkupString.Html;
+
+/// <summary>
+/// Writes the shared vocabulary for a browser: the elements HTML has — <c>&lt;audio&gt;</c>,
+/// <c>&lt;img&gt;</c>, <c>&lt;link rel="prefetch"&gt;</c> — and, for what it has no element for, an
+/// empty or wrapping element whose class and <c>data-</c> attributes the page acts on: <c>ms-clear</c>,
+/// <c>ms-pane</c>, <c>ms-gauge</c>.
+/// </summary>
+/// <remarks>
+/// Addresses are written as given. Whether a page fetches, plays or shows them — and whether a
+/// relative file name means anything to it — is the page's decision, made with a
+/// <c>Content-Security-Policy</c> or by handling the element itself.
+/// </remarks>
+internal sealed class ElementHtmlEmitter(Type markupType) : IMarkupEmitter
+{
+	/// <summary>The markup types this emitter writes.</summary>
+	internal static readonly Type[] Types =
+	[
+		typeof(SoundMarkup), typeof(SoundStopMarkup), typeof(ClearScreenMarkup), typeof(ExpireLinksMarkup),
+		typeof(PrefetchMarkup), typeof(ImageMarkup), typeof(PaneMarkup), typeof(VariableMarkup),
+		typeof(GaugeMarkup), typeof(StatusMarkup),
+	];
+
+	public Type MarkupType { get; } = markupType;
+
+	public MarkupFormat Format => MarkupFormat.Html;
+
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(markup);
+		ArgumentNullException.ThrowIfNull(output);
+
+		switch (markup)
+		{
+			case SoundMarkup sound:
+				output.Write("<audio class=\"ms-sound\"");
+				Attribute(output, "data-channel", sound.Channel == SoundChannel.Music ? "music" : "effects");
+				Attribute(output, "src", sound.Source);
+				Attribute(output, "preload", "none");
+				if (sound.Loops) output.Write(" loop");
+				Attribute(output, "data-volume", sound.Volume);
+				if (!sound.Loops) Attribute(output, "data-repeats", sound.Repeats);
+				if (sound.Continues) Attribute(output, "data-continues", "true");
+				output.Write("></audio>");
+				break;
+
+			case SoundStopMarkup stop:
+				output.Write("<span class=\"ms-sound-stop\"");
+				if (stop.Channel is { } channel) Attribute(output, "data-channel", channel == SoundChannel.Music ? "music" : "effects");
+				output.Write("></span>");
+				break;
+
+			case ClearScreenMarkup:
+				output.Write("<span class=\"ms-clear\"></span>");
+				break;
+
+			case ExpireLinksMarkup expire:
+				output.Write("<span class=\"ms-expire\"");
+				Attribute(output, "data-group", expire.Group);
+				output.Write("></span>");
+				break;
+
+			case PrefetchMarkup prefetch:
+				output.Write("<link rel=\"prefetch\"");
+				Attribute(output, "href", prefetch.Source);
+				output.Write(">");
+				break;
+
+			case ImageMarkup image:
+				output.Write("<img class=\"ms-image\"");
+				Attribute(output, "src", image.Source);
+				Attribute(output, "alt", image.Description ?? string.Empty);
+				Attribute(output, "width", image.Width);
+				Attribute(output, "height", image.Height);
+				if (image.Align is { } align) Attribute(output, "data-align", align.ToString().ToLowerInvariant());
+				output.Write(">");
+				break;
+
+			case PaneMarkup pane:
+				Wrapping(output, "ms-pane", body, ("data-pane", pane.Name), ("data-title", pane.Title));
+				break;
+
+			case VariableMarkup variable:
+				Wrapping(output, "ms-variable", body, ("data-name", variable.Name));
+				break;
+
+			case GaugeMarkup gauge:
+				Wrapping(output, "ms-gauge", body,
+					("data-variable", gauge.Variable), ("data-maximum", gauge.Maximum),
+					("data-caption", gauge.Caption), ("data-color", gauge.Color));
+				break;
+
+			case StatusMarkup status:
+				Wrapping(output, "ms-status", body,
+					("data-variable", status.Variable), ("data-maximum", status.Maximum), ("data-caption", status.Caption));
+				break;
+
+			default:
+				output.Write(body);
+				break;
+		}
+	}
+
+	private static void Wrapping(IBufferWriter<char> output, string className, ReadOnlySpan<char> body, params ReadOnlySpan<(string Name, string? Value)> attributes)
+	{
+		output.Write("<span class=\"");
+		output.Write(className);
+		output.Write("\"");
+		foreach (var (name, value) in attributes) Attribute(output, name, value);
+		output.Write(">");
+		output.Write(body);
+		output.Write("</span>");
+	}
+
+	private static void Attribute(IBufferWriter<char> output, string name, int? value)
+	{
+		if (value is { } number) Attribute(output, name, number.ToString(CultureInfo.InvariantCulture));
+	}
+
+	private static void Attribute(IBufferWriter<char> output, string name, string? value)
+	{
+		if (value is null) return;
+		output.Write(" ");
+		output.Write(new HtmlAttribute(name, value).ToString());
+	}
+}
diff --git a/MarkupString.Html/HtmlRegistration.cs b/MarkupString.Html/HtmlRegistration.cs
index ea62750..73776ad 100644
--- a/MarkupString.Html/HtmlRegistration.cs
+++ b/MarkupString.Html/HtmlRegistration.cs
@@ -11,15 +11,23 @@ public static class HtmlRegistration
 	/// Ansi package's fold via <see cref="HtmlMarkup.TryGetAnsiStyle"/>, which requires
 	/// <c>WithAnsi()</c> to already be applied.
 	/// </summary>
+	/// <remarks>
+	/// It also writes the shared vocabulary for a browser: a sound as <c>&lt;audio&gt;</c>, a picture as
+	/// <c>&lt;img&gt;</c>, and what HTML has no element for — a pane, a gauge, a clear — as an element
+	/// with an <c>ms-</c> class for the page to act on.
+	/// </remarks>
 	public static MarkupRegistry WithHtml(this MarkupRegistry registry)
 	{
 		ArgumentNullException.ThrowIfNull(registry);
 
-		return registry
+		registry = registry
 			.With(new HtmlTagEmitter(MarkupFormat.Html))
 			.With(new HtmlTagEmitter(MarkupFormat.Pueblo))
 			.With(new HtmlTagEmitter(MarkupFormat.Mxp))
 			.With(new HtmlMarkupCodec());
+
+		foreach (var type in ElementHtmlEmitter.Types) registry = registry.With(new ElementHtmlEmitter(type));
+		return registry;
 	}
 
 	/// <summary>
diff --git a/MarkupString.Html/README.md b/MarkupString.Html/README.md
index 6c547be..808d946 100644
--- a/MarkupString.Html/README.md
+++ b/MarkupString.Html/README.md
@@ -14,6 +14,11 @@ Where a tag has no meaning — a terminal — it does not vanish silently: `b`,
 [`MarkupString.Ansi`](https://www.nuget.org/packages/MarkupString.Ansi), and any other tag leaves
 its body untouched.
 
+`WithHtml()` also writes core's shared vocabulary for a browser: a sound as `<audio>`, a picture as
+`<img>`, and what HTML has no element for — a pane, a gauge, clearing the screen — as an element with
+an `ms-` class for the page to act on. See
+[the shared vocabulary](https://github.com/SharpMUSH/MarkupString/blob/main/docs/formats.md#the-shared-vocabulary).
+
 ```sh
 dotnet add package MarkupString.Html
 ```
diff --git a/MarkupString.Mxp/Emitters/ElementMxpEmitter.cs b/MarkupString.Mxp/Emitters/ElementMxpEmitter.cs
new file mode 100644
index 0000000..7c81f15
--- /dev/null
+++ b/MarkupString.Mxp/Emitters/ElementMxpEmitter.cs
@@ -0,0 +1,228 @@
+using System.Buffers;
+using System.Globalization;
+namespace MarkupString.Mxp;
+
+/// <summary>
+/// Writes the shared vocabulary as MXP tags, holding each to what the client said it supports.
+/// </summary>
+/// <remarks>
+/// An element the client refused is written as a format without MXP writes it: nothing for a point,
+/// and the wrapped text for the rest — so a picture the client will not show still leaves its
+/// description, and a pane it cannot open still leaves its text in the main window.
+/// </remarks>
+internal sealed class ElementMxpEmitter(Type markupType, Func<string, bool>? supports) : IMarkupEmitter
+{
+	/// <summary>The markup types this emitter writes.</summary>
+	internal static readonly Type[] Types =
+	[
+		typeof(SoundMarkup), typeof(SoundStopMarkup), typeof(ImageMarkup), typeof(PaneMarkup),
+		typeof(ExpireLinksMarkup), typeof(RelocateMarkup), typeof(LoginPromptMarkup),
+		typeof(VariableMarkup), typeof(GaugeMarkup), typeof(StatusMarkup),
+	];
+
+	public Type MarkupType { get; } = markupType;
+
+	public MarkupFormat Format => MarkupFormat.Mxp;
+
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(markup);
+		ArgumentNullException.ThrowIfNull(output);
+
+		var tag = new MxpTag(output);
+		switch (markup)
+		{
+			case SoundMarkup sound:
+				{
+					var name = sound.Channel == SoundChannel.Music ? "MUSIC" : "SOUND";
+					if (!Supports(name)) return;
+
+					var (file, directory) = Split(sound.Source);
+					tag.Open(name).Positional(file)
+						.Named("V", sound.Volume)
+						.Named("L", sound.Repeats)
+						.Named("C", sound.Channel == SoundChannel.Music && sound.Continues ? "1" : null)
+						.Named("U", directory)
+						.Close();
+					return;
+				}
+
+			case SoundStopMarkup stop:
+				if (stop.Channel is not SoundChannel.Music && Supports("SOUND")) tag.Open("SOUND").Positional("Off").Close();
+				if (stop.Channel is not SoundChannel.Effects && Supports("MUSIC")) tag.Open("MUSIC").Positional("Off").Close();
+				return;
+
+			case ImageMarkup image:
+				{
+					if (!Supports("IMAGE"))
+					{
+						output.Write(body);
+						return;
+					}
+
+					var (file, directory) = Split(image.Source);
+					tag.Open("IMAGE").Positional(file)
+						.Named("URL", directory)
+						.Named("W", image.Width)
+						.Named("H", image.Height)
+						.Named("ALIGN", image.Align?.ToString().ToUpperInvariant())
+						.Close();
+					return;
+				}
+
+			case PaneMarkup pane:
+				if (!Supports("FRAME") || !Supports("DEST"))
+				{
+					output.Write(body);
+					return;
+				}
+
+				tag.Open("FRAME").Positional(pane.Name).Named("TITLE", pane.Title).Close();
+				tag.Open("DEST").Positional(pane.Name).Close();
+				output.Write(body);
+				output.Write("</DEST>");
+				return;
+
+			case ExpireLinksMarkup expire:
+				if (Supports("EXPIRE")) tag.Open("EXPIRE").Positional(expire.Group).Close();
+				return;
+
+			case RelocateMarkup relocate:
+				if (!Supports("RELOCATE")) return;
+				tag.Open("RELOCATE").Positional(relocate.Host)
+					.Positional(relocate.Port.ToString(CultureInfo.InvariantCulture))
+					.Flag("QUIET", relocate.Quiet)
+					.Close();
+				return;
+
+			case LoginPromptMarkup login:
+				{
+					var name = login.Field == LoginField.Password ? "PASSWORD" : "USER";
+					if (Supports(name)) tag.Open(name).Close();
+					return;
+				}
+
+			case VariableMarkup variable:
+				if (!Supports("VAR"))
+				{
+					output.Write(body);
+					return;
+				}
+
+				tag.Open("VAR").Positional(variable.Name).Close();
+				output.Write(body);
+				output.Write("</VAR>");
+				return;
+
+			case GaugeMarkup gauge:
+				if (!Supports("GAUGE"))
+				{
+					output.Write(body);
+					return;
+				}
+
+				tag.Open("GAUGE").Positional(gauge.Variable)
+					.Named("MAX", gauge.Maximum)
+					.Named("CAPTION", gauge.Caption)
+					.Named("COLOR", gauge.Color)
+					.Close();
+				return;
+
+			case StatusMarkup status:
+				if (!Supports("STAT"))
+				{
+					output.Write(body);
+					return;
+				}
+
+				tag.Open("STAT").Positional(status.Variable)
+					.Named("MAX", status.Maximum)
+					.Named("CAPTION", status.Caption)
+					.Close();
+				return;
+
+			default:
+				output.Write(body);
+				return;
+		}
+	}
+
+	private bool Supports(string element) => supports?.Invoke(element) ?? true;
+
+	/// <summary>
+	/// MXP names a file and, separately, the address of the directory to fetch it from when the client
+	/// does not have it. An absolute address is split at its last slash; anything else is a file name.
+	/// </summary>
+	internal static (string File, string? Directory) Split(string source)
+	{
+		if (!Uri.TryCreate(source, UriKind.Absolute, out var uri) || (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps))
+			return (source, null);
+
+		var slash = source.LastIndexOf('/');
+		return slash < 0 || slash == source.Length - 1 || slash < uri.Scheme.Length + 3
+			? (source, null)
+			: (source[(slash + 1)..], source[..(slash + 1)]);
+	}
+}
+
+/// <summary>Writes one MXP tag: its name, then its arguments, each quoted when it has to be.</summary>
+internal readonly ref struct MxpTag(IBufferWriter<char> output)
+{
+	private readonly IBufferWriter<char> _output = output;
+
+	public MxpTag Open(string name)
+	{
+		_output.Write("<");
+		_output.Write(name);
+		return this;
+	}
+
+	public MxpTag Positional(string? value)
+	{
+		if (value is null) return this;
+		_output.Write(" ");
+		WriteValue(value);
+		return this;
+	}
+
+	public MxpTag Named(string name, int? value) =>
+		value is { } number ? Named(name, number.ToString(CultureInfo.InvariantCulture)) : this;
+
+	public MxpTag Named(string name, string? value)
+	{
+		if (value is null) return this;
+		_output.Write(" ");
+		_output.Write(name);
+		_output.Write("=");
+		WriteValue(value);
+		return this;
+	}
+
+	public MxpTag Flag(string name, bool set)
+	{
+		if (!set) return this;
+		_output.Write(" ");
+		_output.Write(name);
+		return this;
+	}
+
+	public void Close() => _output.Write(">");
+
+	/// <summary>
+	/// MXP separates arguments with whitespace and reads a quoted value as one, so a value carrying
+	/// whitespace, a quote or a bracket is quoted, and the characters that are markup inside it written as
+	/// entities.
+	/// </summary>
+	private void WriteValue(string value)
+	{
+		if (value.Length > 0 && value.AsSpan().IndexOfAny(" \t\r\n\"'<>&") < 0)
+		{
+			_output.Write(value);
+			return;
+		}
+
+		_output.Write("\"");
+		_output.Write(value.Replace("&", "&amp;").Replace("\"", "&quot;").Replace("<", "&lt;").Replace(">", "&gt;"));
+		_output.Write("\"");
+	}
+}
diff --git a/MarkupString.Mxp/MarkupString.Mxp.csproj b/MarkupString.Mxp/MarkupString.Mxp.csproj
new file mode 100644
index 0000000..1f7a631
--- /dev/null
+++ b/MarkupString.Mxp/MarkupString.Mxp.csproj
@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AssemblyName>MarkupString.Mxp</AssemblyName>
+    <RootNamespace>MarkupString.Mxp</RootNamespace>
+    <PackageId>MarkupString.Mxp</PackageId>
+    <Title>MarkupString.Mxp</Title>
+    <IsAotCompatible>true</IsAotCompatible>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <NoWarn>CS1591</NoWarn>
+    <!-- No baseline until the first release is out; add PackageValidationBaselineVersion then. -->
+    <EnablePackageValidation>true</EnablePackageValidation>
+    <Description>MXP for MarkupString: writes the shared vocabulary — sounds, music, pictures, panes, gauges, status, variables, link expiry, relocation, login prompts — as MXP tags, holding each to what the client said it supports.</Description>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MinVer" Version="8.0.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" Version="5.6.0" PrivateAssets="all" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="README.md" Pack="true" PackagePath="/" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MarkupString\MarkupString.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/MarkupString.Mxp/MxpRegistration.cs b/MarkupString.Mxp/MxpRegistration.cs
new file mode 100644
index 0000000..0c8c2c0
--- /dev/null
+++ b/MarkupString.Mxp/MxpRegistration.cs
@@ -0,0 +1,39 @@
+namespace MarkupString.Mxp;
+
+/// <summary>Installs this package's emitters into a <see cref="MarkupRegistry"/>.</summary>
+public static class MxpRegistration
+{
+	/// <summary>
+	/// The MXP elements this package writes, as MXP names them — the list to ask a client about with
+	/// <c>&lt;SUPPORT&gt;</c>.
+	/// </summary>
+	public static IReadOnlyList<string> Elements { get; } =
+	[
+		"SOUND", "MUSIC", "IMAGE", "FRAME", "DEST", "EXPIRE", "RELOCATE", "USER", "PASSWORD", "VAR", "GAUGE", "STAT",
+	];
+
+	/// <summary>
+	/// Returns a registry that writes the shared vocabulary as MXP tags in <see cref="MarkupFormat.Mxp"/>:
+	/// a sound as <c>&lt;SOUND&gt;</c>, a picture as <c>&lt;IMAGE&gt;</c>, a pane as a <c>&lt;FRAME&gt;</c>
+	/// and a <c>&lt;DEST&gt;</c>, and so on through <see cref="Elements"/>.
+	/// </summary>
+	/// <remarks>
+	/// <para>These are MXP's secure elements, which a client acts on only on a line in secure mode; pair
+	/// this with <c>WithMxpSecureLines()</c>, or frame the lines yourself.</para>
+	/// <para>MXP lets a client say what it can render, and <paramref name="supports"/> is where that
+	/// answer comes in: it is asked with an element's name from <see cref="Elements"/>, upper case, and an
+	/// element it refuses is written as a format without MXP writes it — nothing for a sound, the
+	/// description for a picture, the text in the main window for a pane. The answer belongs to one
+	/// connection, so a server builds a registry per answer. With no predicate, every element is written,
+	/// which is right for a client that was never asked.</para>
+	/// </remarks>
+	/// <param name="registry">The registry to add to.</param>
+	/// <param name="supports">Whether the client supports an element, by its MXP name; every element when null.</param>
+	public static MarkupRegistry WithMxp(this MarkupRegistry registry, Func<string, bool>? supports = null)
+	{
+		ArgumentNullException.ThrowIfNull(registry);
+
+		foreach (var type in ElementMxpEmitter.Types) registry = registry.With(new ElementMxpEmitter(type, supports));
+		return registry;
+	}
+}
diff --git a/MarkupString.Mxp/PublicAPI.Shipped.txt b/MarkupString.Mxp/PublicAPI.Shipped.txt
new file mode 100644
index 0000000..e69de29
diff --git a/MarkupString.Mxp/PublicAPI.Unshipped.txt b/MarkupString.Mxp/PublicAPI.Unshipped.txt
new file mode 100644
index 0000000..9a14dcf
--- /dev/null
+++ b/MarkupString.Mxp/PublicAPI.Unshipped.txt
@@ -0,0 +1,4 @@
+#nullable enable
+MarkupString.Mxp.MxpRegistration
+static MarkupString.Mxp.MxpRegistration.Elements.get -> System.Collections.Generic.IReadOnlyList<string!>!
+static MarkupString.Mxp.MxpRegistration.WithMxp(this MarkupString.MarkupRegistry! registry, System.Func<string!, bool>? supports = null) -> MarkupString.MarkupRegistry!
diff --git a/MarkupString.Mxp/README.md b/MarkupString.Mxp/README.md
new file mode 100644
index 0000000..d62a3f1
--- /dev/null
+++ b/MarkupString.Mxp/README.md
@@ -0,0 +1,68 @@
+# MarkupString.Mxp
+
+MXP for [`MarkupString`](https://www.nuget.org/packages/MarkupString): writes core's shared
+vocabulary — sounds, music, pictures, panes, gauges, status, variables, link expiry, relocation and
+login prompts — as MXP's own elements, and holds each to what the client said it supports.
+
+You say a thing once; this package is how an MXP client hears it. The same text goes to a Pueblo
+client through `MarkupString.Pueblo`, to a browser through `MarkupString.Html`, and to a terminal,
+which gets a picture's description, a pane's text, and nothing for a sound.
+
+```sh
+dotnet add package MarkupString.Mxp
+```
+
+## Usage
+
+```csharp
+using MarkupString;
+using MarkupString.Ansi;
+using MarkupString.Html;
+using MarkupString.Mxp;
+
+var registry = MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp().WithMxpSecureLines();
+
+var line = MarkupText.Concat([
+  MarkupText.Sound("https://example.test/sounds/door.wav", volume: 80),
+  MarkupText.Pane(MarkupText.Plain("North: the gate"), "map", "The Map")]);
+
+line.Render(MarkupFormat.Mxp, registry);
+// ESC[1z<SOUND door.wav V=80 U=https://example.test/sounds/><FRAME map TITLE="The Map"><DEST map>North: the gate</DEST>
+```
+
+These are MXP's secure elements, which a client acts on only on a line opened in secure mode, so render
+through a registry with `WithMxpSecureLines()`.
+
+## What the client supports
+
+MXP lets a server ask which elements a client renders (`<SUPPORT>`), and a client that answered
+`-image` should not be sent one. Pass the answer as a predicate over the names in
+`MxpRegistration.Elements`:
+
+```csharp
+var answered = new HashSet<string>(["SOUND", "MUSIC", "VAR"], StringComparer.OrdinalIgnoreCase);
+var registry = MarkupRegistry.Empty.WithAnsi().WithMxp(answered.Contains).WithMxpSecureLines();
+```
+
+An element the client refused is written as a format without MXP writes it: nothing for a sound, the
+description for a picture, the text in the main window for a pane. With no predicate every element is
+written. Asking belongs to the telnet layer, and the answer to one connection.
+
+## Elements
+
+| Factory | Written as |
+|---|---|
+| `MarkupText.Sound(source, volume, repeats)` | `<SOUND file V= L= U=>` |
+| `MarkupText.Music(source, volume, repeats, continues)` | `<MUSIC file V= L= C=1 U=>` |
+| `MarkupText.StopSound(channel)` | `<SOUND Off>`, `<MUSIC Off>` |
+| `MarkupText.Image(source, description, width, height, align)` | `<IMAGE file URL= W= H= ALIGN=>` |
+| `MarkupText.Pane(content, name, title)` | `<FRAME name TITLE=><DEST name>content</DEST>` |
+| `MarkupText.ExpireLinks(group)` | `<EXPIRE group>` |
+| `MarkupText.Relocate(host, port, quiet)` | `<RELOCATE host port QUIET>` |
+| `MarkupText.LoginPrompt(field)` | `<USER>`, `<PASSWORD>` |
+| `MarkupText.Variable(content, name)` | `<VAR name>content</VAR>` |
+| `MarkupText.Gauge(content, variable, maximum, caption, color)` | `<GAUGE variable MAX= CAPTION= COLOR=>` |
+| `MarkupText.Status(content, variable, maximum, caption)` | `<STAT variable MAX= CAPTION=>` |
+
+An absolute address is split into the file and the directory MXP downloads it from (`U=`, `URL=`).
+Syntax is from the [MXP specification](https://www.zuggsoft.com/zmud/mxp.htm).
diff --git a/MarkupString.Pueblo/Emitters/ElementPuebloEmitter.cs b/MarkupString.Pueblo/Emitters/ElementPuebloEmitter.cs
new file mode 100644
index 0000000..d6511ce
--- /dev/null
+++ b/MarkupString.Pueblo/Emitters/ElementPuebloEmitter.cs
@@ -0,0 +1,98 @@
+using System.Buffers;
+using System.Globalization;
+using MarkupString.Html;
+namespace MarkupString.Pueblo;
+
+/// <summary>
+/// Writes the shared vocabulary in the Pueblo client's own HTML extensions.
+/// </summary>
+/// <remarks>
+/// Names and attributes are the client's own (<c>api/ChHtmSym.cpp</c>, <c>api/ChPaneTag.cpp</c> and the
+/// sound module in <see href="https://github.com/uecasm/pueblo">uecasm/pueblo</see>). Pueblo has two
+/// players, one for wave files and one for MIDI, and chooses between them by the file; it has no channel
+/// for music as such, and it plays a sound once or loops it, without a count.
+/// </remarks>
+internal sealed class ElementPuebloEmitter(Type markupType) : IMarkupEmitter
+{
+	/// <summary>The markup types this emitter writes.</summary>
+	internal static readonly Type[] Types =
+	[
+		typeof(SoundMarkup), typeof(SoundStopMarkup), typeof(ClearScreenMarkup), typeof(PrefetchMarkup),
+		typeof(ImageMarkup), typeof(PaneMarkup),
+	];
+
+	/// <summary>The pane name Pueblo reads as "back to wherever text was going before".</summary>
+	internal const string PreviousPane = "_previous";
+
+	public Type MarkupType { get; } = markupType;
+
+	public MarkupFormat Format => MarkupFormat.Pueblo;
+
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(markup);
+		ArgumentNullException.ThrowIfNull(output);
+
+		switch (markup)
+		{
+			case SoundMarkup sound:
+				Tag(output, "img",
+					("xch_sound", sound.Loops ? "loop" : "play"),
+					("href", sound.Source),
+					("xch_volume", sound.Volume?.ToString(CultureInfo.InvariantCulture)));
+				return;
+
+			case SoundStopMarkup stop:
+				Tag(output, "img",
+					("xch_sound", "stop"),
+					("xch_device", stop.Channel switch
+					{
+						SoundChannel.Effects => "wave",
+						SoundChannel.Music => "midi",
+						_ => null,
+					}));
+				return;
+
+			case ClearScreenMarkup:
+				Tag(output, "xch_page", ("clear", "text"));
+				return;
+
+			case PrefetchMarkup prefetch:
+				// The client ignores a prefetch with no likelihood of being used.
+				Tag(output, "xch_prefetch", ("href", prefetch.Source), ("xch_prob", "100"));
+				return;
+
+			case ImageMarkup image:
+				Tag(output, "img",
+					("src", image.Source),
+					("alt", image.Description ?? string.Empty),
+					("width", image.Width?.ToString(CultureInfo.InvariantCulture)),
+					("height", image.Height?.ToString(CultureInfo.InvariantCulture)),
+					("align", image.Align?.ToString().ToLowerInvariant()));
+				return;
+
+			case PaneMarkup pane:
+				Tag(output, "xch_pane", ("action", "redirect"), ("name", pane.Name), ("panetitle", pane.Title));
+				output.Write(body);
+				Tag(output, "xch_pane", ("action", "redirect"), ("name", PreviousPane));
+				return;
+
+			default:
+				output.Write(body);
+				return;
+		}
+	}
+
+	private static void Tag(IBufferWriter<char> output, string name, params ReadOnlySpan<(string Name, string? Value)> attributes)
+	{
+		output.Write("<");
+		output.Write(name);
+		foreach (var (attribute, value) in attributes)
+		{
+			if (value is null) continue;
+			output.Write(" ");
+			output.Write(new HtmlAttribute(attribute, value).ToString());
+		}
+		output.Write(">");
+	}
+}
diff --git a/MarkupString.Pueblo/MarkupString.Pueblo.csproj b/MarkupString.Pueblo/MarkupString.Pueblo.csproj
new file mode 100644
index 0000000..164afb6
--- /dev/null
+++ b/MarkupString.Pueblo/MarkupString.Pueblo.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AssemblyName>MarkupString.Pueblo</AssemblyName>
+    <RootNamespace>MarkupString.Pueblo</RootNamespace>
+    <PackageId>MarkupString.Pueblo</PackageId>
+    <Title>MarkupString.Pueblo</Title>
+    <IsAotCompatible>true</IsAotCompatible>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <NoWarn>CS1591</NoWarn>
+    <!-- No baseline until the first release is out; add PackageValidationBaselineVersion then. -->
+    <EnablePackageValidation>true</EnablePackageValidation>
+    <Description>Pueblo for MarkupString: writes the shared vocabulary — sounds, pictures, panes, clearing the screen, prefetching — in the Pueblo client's own HTML extensions.</Description>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MinVer" Version="8.0.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" Version="5.6.0" PrivateAssets="all" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="README.md" Pack="true" PackagePath="/" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MarkupString\MarkupString.csproj" />
+    <ProjectReference Include="..\MarkupString.Html\MarkupString.Html.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/MarkupString.Pueblo/PublicAPI.Shipped.txt b/MarkupString.Pueblo/PublicAPI.Shipped.txt
new file mode 100644
index 0000000..e69de29
diff --git a/MarkupString.Pueblo/PublicAPI.Unshipped.txt b/MarkupString.Pueblo/PublicAPI.Unshipped.txt
new file mode 100644
index 0000000..8c40507
--- /dev/null
+++ b/MarkupString.Pueblo/PublicAPI.Unshipped.txt
@@ -0,0 +1,3 @@
+#nullable enable
+MarkupString.Pueblo.PuebloRegistration
+static MarkupString.Pueblo.PuebloRegistration.WithPueblo(this MarkupString.MarkupRegistry! registry) -> MarkupString.MarkupRegistry!
diff --git a/MarkupString.Pueblo/PuebloRegistration.cs b/MarkupString.Pueblo/PuebloRegistration.cs
new file mode 100644
index 0000000..2153b8c
--- /dev/null
+++ b/MarkupString.Pueblo/PuebloRegistration.cs
@@ -0,0 +1,24 @@
+namespace MarkupString.Pueblo;
+
+/// <summary>Installs this package's emitters into a <see cref="MarkupRegistry"/>.</summary>
+public static class PuebloRegistration
+{
+	/// <summary>
+	/// Returns a registry that writes the shared vocabulary in <see cref="MarkupFormat.Pueblo"/> as the
+	/// Pueblo client reads it: a sound as <c>&lt;img xch_sound&gt;</c>, a pane as
+	/// <c>&lt;xch_pane action="redirect"&gt;</c> and back, clearing the screen as
+	/// <c>&lt;xch_page&gt;</c>, a prefetch as <c>&lt;xch_prefetch&gt;</c>, and a picture as
+	/// <c>&lt;img&gt;</c>.
+	/// </summary>
+	/// <remarks>
+	/// Pueblo has no gauges, status bar or variables; those write their text. Plain HTML tags stay
+	/// <c>WithHtml()</c>'s, and styling and command links <c>WithAnsi()</c>'s.
+	/// </remarks>
+	public static MarkupRegistry WithPueblo(this MarkupRegistry registry)
+	{
+		ArgumentNullException.ThrowIfNull(registry);
+
+		foreach (var type in ElementPuebloEmitter.Types) registry = registry.With(new ElementPuebloEmitter(type));
+		return registry;
+	}
+}
diff --git a/MarkupString.Pueblo/README.md b/MarkupString.Pueblo/README.md
new file mode 100644
index 0000000..03f7af5
--- /dev/null
+++ b/MarkupString.Pueblo/README.md
@@ -0,0 +1,51 @@
+# MarkupString.Pueblo
+
+Pueblo for [`MarkupString`](https://www.nuget.org/packages/MarkupString): writes core's shared
+vocabulary — sounds, pictures, panes, clearing the screen and prefetching — in the Pueblo client's own
+HTML extensions.
+
+You say a thing once; this package is how a Pueblo client hears it. The same text goes to an MXP client
+through `MarkupString.Mxp`, to a browser through `MarkupString.Html`, and to a terminal, which gets a
+picture's description, a pane's text, and nothing for a sound.
+
+```sh
+dotnet add package MarkupString.Pueblo
+```
+
+## Usage
+
+```csharp
+using MarkupString;
+using MarkupString.Ansi;
+using MarkupString.Html;
+using MarkupString.Pueblo;
+
+var registry = MarkupRegistry.Empty.WithAnsi().WithHtml().WithPueblo();
+
+var line = MarkupText.Concat([
+  MarkupText.Sound("door.wav", volume: 80),
+  MarkupText.Pane(MarkupText.Plain("North: the gate"), "map", "The Map")]);
+
+line.Render(MarkupFormat.Pueblo, registry);
+// <img xch_sound="play" href="door.wav" xch_volume="80"><xch_pane action="redirect" name="map" panetitle="The Map">North: the gate<xch_pane action="redirect" name="_previous">
+```
+
+## Elements
+
+| Factory | Written as |
+|---|---|
+| `MarkupText.Sound(source, volume, repeats)`, `Music(...)` | `<img xch_sound="play" href= xch_volume=>`, or `"loop"` for `repeats: SoundMarkup.Forever` |
+| `MarkupText.StopSound(channel)` | `<img xch_sound="stop" xch_device="wave"\|"midi">` |
+| `MarkupText.Image(source, description, width, height, align)` | `<img src= alt= width= height= align=>` |
+| `MarkupText.Pane(content, name, title)` | `<xch_pane action="redirect" name= panetitle=>content<xch_pane action="redirect" name="_previous">` |
+| `MarkupText.ClearScreen()` | `<xch_page clear="text">` |
+| `MarkupText.Prefetch(source)` | `<xch_prefetch href= xch_prob="100">` |
+
+Pueblo has two players, one for wave files and one for MIDI, and picks between them by the file; it
+has no music channel as such, and plays a sound once or loops it, without a count. It has no gauges,
+status bar or variables, and those write their text.
+
+The Pueblo handshake — `PUEBLOCLIENT`, and the sequence that moves a client into HTML — belongs to the
+telnet layer, not to text. Names and attributes are the client's own, from its source
+([uecasm/pueblo](https://github.com/uecasm/pueblo): `ChSound.cpp`, `ChPaneTag.cpp`, `ChHtmlPane.cpp`,
+`ChHeadElement.cpp`).
diff --git a/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs b/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs
index e9276b5..2db54e0 100644
--- a/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs
+++ b/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs
@@ -3,9 +3,10 @@
 
 /// <summary>
 /// The path a run takes when it carries a layer this package does not own. Every set emitter here
-/// claims every run, so <c>AnsiEmitterSupport.WriteWrapped</c> is the only thing standing between a
-/// foreign layer and being dropped: it wraps the folded ANSI output in the foreign layers'
-/// own emitters, innermost first.
+/// claims every run, so <c>AnsiEmitterSupport</c> is the only thing standing between a foreign layer and
+/// being dropped. It keeps the nesting: foreign layers inside every ANSI layer are applied to the text
+/// before the style is (<c>WriteInner</c>), and the rest wrap the styled output (<c>WriteWrapped</c>),
+/// each innermost first.
 /// </summary>
 public class AnsiForeignLayerTests
 {
@@ -68,23 +69,22 @@ public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context
 	// ── Delegation of layers this package does not own ────────────────────────────
 
 	/// <summary>
-	/// Set <c>[Tag("t"), AnsiMarkup(red)]</c>. The ANSI sequence and its reset bracket the body —
-	/// the fold produces them around the run's text — and the foreign layer wraps that whole core.
+	/// Set <c>[Tag("t"), AnsiMarkup(red)]</c>. The tag is inside the colour, so the colour's sequence
+	/// and reset bracket it.
 	/// </summary>
 	[Test]
-	public async Task Ansi_ForeignLayerInsideAnAnsiLayer_WrapsTheSgrCore()
+	public async Task Ansi_ForeignLayerInsideAnAnsiLayer_StaysInsideTheSgr()
 	{
 		var text = MarkupText.Wrap(Red, MarkupText.Wrap(new Tag("t"), "x"));
-		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"<t>{Esc}[31mx{Esc}[0m</t>");
+		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"{Esc}[31m<t>x</t>{Esc}[0m");
 	}
 
 	/// <summary>
-	/// Set <c>[AnsiMarkup(red), Tag("t")]</c> — the same two layers the other way round. The SGR is
-	/// emitted by the fold around the folded body rather than at the layer's own depth, so nesting
-	/// order between an ANSI layer and a foreign one does not move it.
+	/// Set <c>[AnsiMarkup(red), Tag("t")]</c> — the same two layers the other way round, and the tag
+	/// wraps the colour.
 	/// </summary>
 	[Test]
-	public async Task Ansi_ForeignLayerOutsideAnAnsiLayer_RendersTheSame()
+	public async Task Ansi_ForeignLayerOutsideAnAnsiLayer_WrapsTheSgr()
 	{
 		var text = MarkupText.Wrap(new Tag("t"), MarkupText.Wrap(Red, "x"));
 		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"<t>{Esc}[31mx{Esc}[0m</t>");
@@ -95,16 +95,16 @@ public async Task Ansi_ForeignLayerOutsideAnAnsiLayer_RendersTheSame()
 	public async Task Ansi_TwoForeignLayers_NestInOrder()
 	{
 		var text = MarkupText.Wrap(Red, MarkupText.Wrap(new Tag("b"), MarkupText.Wrap(new Tag("a"), "x")));
-		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"<b><a>{Esc}[31mx{Esc}[0m</a></b>");
+		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"{Esc}[31m<b><a>x</a></b>{Esc}[0m");
 	}
 
-	/// <summary>The same set in HTML: the span is the core, and the foreign layers wrap it.</summary>
+	/// <summary>The same set in HTML: both tags are inside the colour, so the span wraps them.</summary>
 	[Test]
-	public async Task Html_TwoForeignLayers_NestAroundTheSpan()
+	public async Task Html_TwoForeignLayers_NestInsideTheSpan()
 	{
 		var text = MarkupText.Wrap(Red, MarkupText.Wrap(new Tag("b"), MarkupText.Wrap(new Tag("a"), "x")));
 		await Assert.That(Render(text, MarkupFormat.Html))
-			.IsEqualTo("<b><a><span style=\"color: #aa0000\">x</span></a></b>");
+			.IsEqualTo("<span style=\"color: #aa0000\"><b><a>x</a></b></span>");
 	}
 
 	/// <summary>A foreign layer alone, with no ANSI layer to fold: only its own emitter runs.</summary>
@@ -166,10 +166,10 @@ public async Task Html_FormatSpecificStyleSource_IsDelegatedToItsOwnEmitter()
 	/// delegated tag, not an <c>ms-bold</c> class.
 	/// </summary>
 	[Test]
-	public async Task Html_FormatSpecificStyleSourceWithAnsiLayer_TagWrapsTheColourSpan()
+	public async Task Html_FormatSpecificStyleSourceWithAnsiLayer_TagSitsInsideTheColourSpan()
 	{
 		var text = MarkupText.Wrap(Red, MarkupText.Wrap(new BoldTag(), "x"));
 		await Assert.That(Render(text, MarkupFormat.Html))
-			.IsEqualTo("<b><span style=\"color: #aa0000\">x</span></b>");
+			.IsEqualTo("<span style=\"color: #aa0000\"><b>x</b></span>");
 	}
 }
diff --git a/MarkupString.Tests/BellTests.cs b/MarkupString.Tests/BellTests.cs
index 61a3bbb..3c2f085 100644
--- a/MarkupString.Tests/BellTests.cs
+++ b/MarkupString.Tests/BellTests.cs
@@ -51,8 +51,10 @@ public async Task ABellMeasuresNothing()
 		var text = MarkupText.Concat(MarkupText.Bell(), MarkupText.Plain("ab"));
 
 		await Assert.That(DisplayWidth.Of(text.Text)).IsEqualTo(2);
-		await Assert.That(text.ToPlainText()).IsEqualTo(Bel + "ab")
-			.Because("the plain text keeps the position; only a render decides what to do with it");
+		await Assert.That(text.Text).IsEqualTo(Bel + "ab")
+			.Because("the text keeps the position, so slicing and padding carry the bell");
+		await Assert.That(text.ToPlainText()).IsEqualTo("ab")
+			.Because("a bell is a point, and a point is not text a reader or a pattern sees");
 	}
 
 	/// <summary>
diff --git a/MarkupString.Tests/Html/HtmlMarkupTests.cs b/MarkupString.Tests/Html/HtmlMarkupTests.cs
index d19bdf8..1fa68ba 100644
--- a/MarkupString.Tests/Html/HtmlMarkupTests.cs
+++ b/MarkupString.Tests/Html/HtmlMarkupTests.cs
@@ -98,12 +98,11 @@ public async Task BoldInsideRed_FoldsIntoOneSgrSequence()
 
 		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"{Esc}[1;31mx{Esc}[0m");
 
-		// Html: "b" does not claim a style there, so it is delegated to HtmlTagEmitter and wraps the
-		// folded <span> from outside — the same nesting AnsiForeignLayerTests establishes for any
-		// layer that answers false for a format (see Html_FormatSpecificStyleSourceWithAnsiLayer_
-		// TagWrapsTheColourSpan, same Wrap(Red, Wrap(<falls-back-tag>, "x")) shape).
+		// Html: "b" does not claim a style there, so it is delegated to HtmlTagEmitter, and it sits
+		// inside the colour's <span> because that is where it was put (see AnsiForeignLayerTests.
+		// Html_FormatSpecificStyleSourceWithAnsiLayer_TagSitsInsideTheColourSpan).
 		await Assert.That(Render(text, MarkupFormat.Html))
-			.IsEqualTo("<b><span style=\"color: #aa0000\">x</span></b>");
+			.IsEqualTo("<span style=\"color: #aa0000\"><b>x</b></span>");
 		await Assert.That(Render(text, MarkupFormat.BBCode)).IsEqualTo("[color=#aa0000][b]x[/b][/color]");
 	}
 
diff --git a/MarkupString.Tests/MarkupString.Tests.csproj b/MarkupString.Tests/MarkupString.Tests.csproj
index 64cb666..5652398 100644
--- a/MarkupString.Tests/MarkupString.Tests.csproj
+++ b/MarkupString.Tests/MarkupString.Tests.csproj
@@ -19,5 +19,7 @@
     <ProjectReference Include="..\MarkupString\MarkupString.csproj" />
     <ProjectReference Include="..\MarkupString.Ansi\MarkupString.Ansi.csproj" />
     <ProjectReference Include="..\MarkupString.Html\MarkupString.Html.csproj" />
+    <ProjectReference Include="..\MarkupString.Mxp\MarkupString.Mxp.csproj" />
+    <ProjectReference Include="..\MarkupString.Pueblo\MarkupString.Pueblo.csproj" />
   </ItemGroup>
 </Project>
diff --git a/MarkupString.Tests/SharedVocabularyTests.cs b/MarkupString.Tests/SharedVocabularyTests.cs
new file mode 100644
index 0000000..47e3d01
--- /dev/null
+++ b/MarkupString.Tests/SharedVocabularyTests.cs
@@ -0,0 +1,307 @@
+using MarkupString.Ansi;
+using MarkupString.Html;
+using MarkupString.Mxp;
+using MarkupString.Pueblo;
+namespace MarkupString.Tests;
+
+/// <summary>
+/// The shared vocabulary: a game puts a sound, a picture or a pane in its text once, and every format
+/// writes it in its own dialect or stands something else in for it.
+/// </summary>
+/// <remarks>
+/// MXP syntax from the <see href="https://www.zuggsoft.com/zmud/mxp.htm">MXP specification</see>; Pueblo's
+/// from its client (<see href="https://github.com/uecasm/pueblo">uecasm/pueblo</see>: <c>ChSound.cpp</c>,
+/// <c>ChPaneTag.cpp</c>, <c>ChHtmlPane.cpp</c>, <c>ChHeadElement.cpp</c>).
+/// </remarks>
+public class SharedVocabularyTests
+{
+	private static readonly MarkupRegistry Registry =
+		MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp().WithPueblo();
+
+	private static string Render(MarkupText text, MarkupFormat format) => text.Render(format, Registry);
+
+	private static readonly MarkupText Creaks = MarkupText.Plain("The door creaks.");
+
+	// ── One object, every format ───────────────────────────────────────────────
+
+	[Test]
+	public async Task ASoundIsWrittenOnceForEveryFormatThatHasSound()
+	{
+		var line = MarkupText.Concat(MarkupText.Sound("door.wav", volume: 80), Creaks);
+
+		await Assert.That(Render(line, MarkupFormat.Mxp)).IsEqualTo("<SOUND door.wav V=80>The door creaks.");
+		await Assert.That(Render(line, MarkupFormat.Pueblo))
+			.IsEqualTo("<img xch_sound=\"play\" href=\"door.wav\" xch_volume=\"80\">The door creaks.");
+		await Assert.That(Render(line, MarkupFormat.Html)).IsEqualTo(
+			"<audio class=\"ms-sound\" data-channel=\"effects\" src=\"door.wav\" preload=\"none\" data-volume=\"80\"></audio>The door creaks.");
+	}
+
+	[Test]
+	[Arguments("ansi")]
+	[Arguments("plain")]
+	[Arguments("bbcode")]
+	public async Task AFormatWithNoSoundWritesNothing_CarrierIncluded(string format)
+	{
+		var line = MarkupText.Concat(MarkupText.Sound("door.wav"), Creaks);
+
+		await Assert.That(Render(line, MarkupFormat.TryParse(format)!)).IsEqualTo("The door creaks.");
+	}
+
+	[Test]
+	public async Task MusicThatLoopsLoopsEverywhere()
+	{
+		var music = MarkupText.Music("theme.mid", repeats: SoundMarkup.Forever, continues: true);
+
+		await Assert.That(Render(music, MarkupFormat.Mxp)).IsEqualTo("<MUSIC theme.mid L=-1 C=1>");
+		await Assert.That(Render(music, MarkupFormat.Pueblo)).IsEqualTo("<img xch_sound=\"loop\" href=\"theme.mid\">");
+		await Assert.That(Render(music, MarkupFormat.Html)).IsEqualTo(
+			"<audio class=\"ms-sound\" data-channel=\"music\" src=\"theme.mid\" preload=\"none\" loop data-continues=\"true\"></audio>");
+	}
+
+	/// <summary>MXP names the file and, separately, where to download it from.</summary>
+	[Test]
+	public async Task MxpSplitsAnAddressIntoAFileAndWhereToFetchIt()
+	{
+		await Assert.That(Render(MarkupText.Sound("https://example.test/sounds/door.wav"), MarkupFormat.Mxp))
+			.IsEqualTo("<SOUND door.wav U=https://example.test/sounds/>");
+		await Assert.That(Render(MarkupText.Image("https://example.test/map.png"), MarkupFormat.Mxp))
+			.IsEqualTo("<IMAGE map.png URL=https://example.test/>");
+	}
+
+	[Test]
+	public async Task StoppingASoundNamesTheChannel()
+	{
+		await Assert.That(Render(MarkupText.StopSound(SoundChannel.Music), MarkupFormat.Mxp)).IsEqualTo("<MUSIC Off>");
+		await Assert.That(Render(MarkupText.StopSound(), MarkupFormat.Mxp)).IsEqualTo("<SOUND Off><MUSIC Off>");
+		await Assert.That(Render(MarkupText.StopSound(SoundChannel.Effects), MarkupFormat.Pueblo))
+			.IsEqualTo("<img xch_sound=\"stop\" xch_device=\"wave\">");
+		await Assert.That(Render(MarkupText.StopSound(), MarkupFormat.Pueblo)).IsEqualTo("<img xch_sound=\"stop\">");
+		await Assert.That(Render(MarkupText.StopSound(SoundChannel.Music), MarkupFormat.Html))
+			.IsEqualTo("<span class=\"ms-sound-stop\" data-channel=\"music\"></span>");
+	}
+
+	// ── A picture degrades to words ─────────────────────────────────────────────
+
+	[Test]
+	public async Task APictureIsShownWhereItCanBe_AndDescribedWhereItCannot()
+	{
+		var map = MarkupText.Image("map.png", "A map of the city", width: 200);
+
+		await Assert.That(Render(map, MarkupFormat.Mxp)).IsEqualTo("<IMAGE map.png W=200>");
+		await Assert.That(Render(map, MarkupFormat.Pueblo)).IsEqualTo("<img src=\"map.png\" alt=\"A map of the city\" width=\"200\">");
+		await Assert.That(Render(map, MarkupFormat.Html))
+			.IsEqualTo("<img class=\"ms-image\" src=\"map.png\" alt=\"A map of the city\" width=\"200\">");
+		await Assert.That(Render(map, MarkupFormat.BBCode)).IsEqualTo("[img]map.png[/img]");
+		await Assert.That(Render(map, MarkupFormat.Ansi)).IsEqualTo("A map of the city");
+		await Assert.That(Render(map, MarkupFormat.Plain)).IsEqualTo("A map of the city");
+	}
+
+	[Test]
+	public async Task APictureWithNoDescriptionLeavesItsAddress()
+	{
+		var map = MarkupText.Image("https://example.test/map.png");
+
+		await Assert.That(Render(map, MarkupFormat.Ansi)).IsEqualTo("https://example.test/map.png");
+		await Assert.That(map.ToPlainText()).IsEqualTo("https://example.test/map.png");
+	}
+
+	/// <summary>A link is its own markup, so a picture inside one is a picture that is a link, in every dialect.</summary>
+	[Test]
+	public async Task APictureInsideALinkIsALink()
+	{
+		var map = MarkupText.Wrap(
+			AnsiMarkup.Create(linkUrl: "look map", linkKind: LinkKind.Command),
+			MarkupText.Image("map.png", "A map"));
+
+		await Assert.That(Render(map, MarkupFormat.Pueblo)).IsEqualTo("<A XCH_CMD=\"look map\"><img src=\"map.png\" alt=\"A map\"></A>");
+		await Assert.That(Render(map, MarkupFormat.Mxp)).IsEqualTo("<SEND HREF=\"look map\"><IMAGE map.png></SEND>");
+	}
+
+	// ── A pane keeps its text ────────────────────────────────────────────────────
+
+	[Test]
+	public async Task APaneTakesItsTextToThePane_OrLeavesItWhereItIs()
+	{
+		var pane = MarkupText.Pane(MarkupText.Plain("North: the gate"), "map", "The Map");
+
+		await Assert.That(Render(pane, MarkupFormat.Mxp))
+			.IsEqualTo("<FRAME map TITLE=\"The Map\"><DEST map>North: the gate</DEST>");
+		await Assert.That(Render(pane, MarkupFormat.Pueblo)).IsEqualTo(
+			"<xch_pane action=\"redirect\" name=\"map\" panetitle=\"The Map\">North: the gate<xch_pane action=\"redirect\" name=\"_previous\">");
+		await Assert.That(Render(pane, MarkupFormat.Html))
+			.IsEqualTo("<span class=\"ms-pane\" data-pane=\"map\" data-title=\"The Map\">North: the gate</span>");
+		await Assert.That(Render(pane, MarkupFormat.Ansi)).IsEqualTo("North: the gate");
+	}
+
+	// ── What only some formats have ─────────────────────────────────────────────
+
+	[Test]
+	public async Task ClearingTheScreenIsEachFormatsOwnInstruction()
+	{
+		var clear = MarkupText.ClearScreen();
+
+		await Assert.That(Render(clear, MarkupFormat.Ansi)).IsEqualTo("\e[H\e[2J");
+		await Assert.That(Render(clear, MarkupFormat.Pueblo)).IsEqualTo("<xch_page clear=\"text\">");
+		await Assert.That(Render(clear, MarkupFormat.Html)).IsEqualTo("<span class=\"ms-clear\"></span>");
+		await Assert.That(Render(clear, MarkupFormat.Mxp)).IsEqualTo(string.Empty).Because("MXP has no such instruction");
+		await Assert.That(Render(clear, MarkupFormat.Plain)).IsEqualTo(string.Empty);
+	}
+
+	/// <summary>Pueblo ignores a prefetch that carries no likelihood of being used.</summary>
+	[Test]
+	public async Task APrefetchIsWrittenWhereAClientCanFetchAhead()
+	{
+		var prefetch = MarkupText.Prefetch("https://example.test/map.png");
+
+		await Assert.That(Render(prefetch, MarkupFormat.Pueblo))
+			.IsEqualTo("<xch_prefetch href=\"https://example.test/map.png\" xch_prob=\"100\">");
+		await Assert.That(Render(prefetch, MarkupFormat.Html)).IsEqualTo("<link rel=\"prefetch\" href=\"https://example.test/map.png\">");
+		await Assert.That(Render(prefetch, MarkupFormat.Mxp)).IsEqualTo(string.Empty);
+	}
+
+	[Test]
+	public async Task WhatOnlyMxpHasIsWrittenForMxpAndNothingElse()
+	{
+		var points = MarkupText.Concat([
+			MarkupText.ExpireLinks("exits"),
+			MarkupText.Relocate("other.example", 4201, quiet: true),
+			MarkupText.LoginPrompt(LoginField.User),
+			MarkupText.LoginPrompt(LoginField.Password)]);
+
+		await Assert.That(Render(points, MarkupFormat.Mxp))
+			.IsEqualTo("<EXPIRE exits><RELOCATE other.example 4201 QUIET><USER><PASSWORD>");
+		await Assert.That(Render(points, MarkupFormat.Pueblo)).IsEqualTo(string.Empty);
+		await Assert.That(Render(points, MarkupFormat.Ansi)).IsEqualTo(string.Empty);
+		await Assert.That(Render(points, MarkupFormat.Html)).IsEqualTo("<span class=\"ms-expire\" data-group=\"exits\"></span>");
+	}
+
+	[Test]
+	public async Task VariablesAndGaugesLeaveTheirTextWhereTheyAreNotUnderstood()
+	{
+		var hp = MarkupText.Variable(MarkupText.Plain("42"), "hp");
+		var gauge = MarkupText.Gauge(MarkupText.Plain("HP 42/50"), "hp", "maxhp", "Hit Points", "red");
+		var status = MarkupText.Status(MarkupText.Plain("Mana 7"), "mana", caption: "Mana");
+
+		await Assert.That(Render(hp, MarkupFormat.Mxp)).IsEqualTo("<VAR hp>42</VAR>");
+		await Assert.That(Render(gauge, MarkupFormat.Mxp)).IsEqualTo("<GAUGE hp MAX=maxhp CAPTION=\"Hit Points\" COLOR=red>");
+		await Assert.That(Render(status, MarkupFormat.Mxp)).IsEqualTo("<STAT mana CAPTION=Mana>");
+		await Assert.That(Render(gauge, MarkupFormat.Html)).IsEqualTo(
+			"<span class=\"ms-gauge\" data-variable=\"hp\" data-maximum=\"maxhp\" data-caption=\"Hit Points\" data-color=\"red\">HP 42/50</span>");
+
+		foreach (var format in new[] { MarkupFormat.Ansi, MarkupFormat.Pueblo, MarkupFormat.Plain })
+		{
+			await Assert.That(Render(MarkupText.Concat([hp, gauge, status]), format)).IsEqualTo("42HP 42/50Mana 7");
+		}
+	}
+
+	// ── MXP holds each element to the client's answer ────────────────────────────
+
+	[Test]
+	public async Task MxpWritesWhatTheClientRefusedAsIfItHadNoMxp()
+	{
+		var refusing = MarkupRegistry.Empty.WithAnsi().WithHtml()
+			.WithMxp(element => element is not ("IMAGE" or "SOUND" or "FRAME"));
+
+		var line = MarkupText.Concat([
+			MarkupText.Sound("door.wav"),
+			MarkupText.Image("map.png", "A map"),
+			MarkupText.Pane(MarkupText.Plain(" to the north"), "map"),
+			MarkupText.Music("theme.mid")]);
+
+		await Assert.That(line.Render(MarkupFormat.Mxp, refusing)).IsEqualTo("A map to the north<MUSIC theme.mid>");
+	}
+
+	[Test]
+	public async Task TheElementsToAskAboutAreTheOnesWritten()
+	{
+		await Assert.That(MxpRegistration.Elements).Contains("IMAGE");
+		await Assert.That(MxpRegistration.Elements).Contains("DEST");
+	}
+
+	// ── A point is not text ─────────────────────────────────────────────────────
+
+	[Test]
+	public async Task APointIsLeftOutOfThePlainText_AndOutOfEquality()
+	{
+		var line = MarkupText.Concat([MarkupText.Sound("door.wav"), Creaks, MarkupText.ClearScreen()]);
+
+		await Assert.That(line.ToPlainText()).IsEqualTo("The door creaks.");
+		await Assert.That(line.ToString()).IsEqualTo("The door creaks.");
+		await Assert.That(line).IsEqualTo(Creaks);
+		await Assert.That(line.GetHashCode()).IsEqualTo(Creaks.GetHashCode());
+		await Assert.That(DisplayWidth.Of(line.Text)).IsEqualTo(16);
+	}
+
+	[Test]
+	public async Task APointInsideStylingLeavesNoStyledNothingBehind()
+	{
+		var line = MarkupText.Concat([
+			MarkupText.Wrap(AnsiMarkup.Create(bold: true), MarkupText.Sound("door.wav")),
+			MarkupText.Plain("x")]);
+
+		await Assert.That(Render(line, MarkupFormat.Ansi)).IsEqualTo("x");
+		await Assert.That(Render(line, MarkupFormat.Mxp)).Contains("<SOUND door.wav>");
+	}
+
+	[Test]
+	public async Task TwoOfTheSamePointSideBySideAreTwoPoints()
+	{
+		var twice = MarkupText.Concat(MarkupText.Sound("door.wav"), MarkupText.Sound("door.wav"));
+
+		await Assert.That(twice.Runs.Length).IsEqualTo(1).Because("equal markup side by side coalesces");
+		await Assert.That(Render(twice, MarkupFormat.Mxp)).IsEqualTo("<SOUND door.wav><SOUND door.wav>");
+	}
+
+	[Test]
+	public async Task AValueIsQuotedWhenMxpWouldOtherwiseSplitIt()
+	{
+		var status = MarkupText.Status(MarkupText.Plain("x"), "hp", caption: "He said \"hi\" <loudly>");
+
+		await Assert.That(Render(status, MarkupFormat.Mxp)).IsEqualTo("<STAT hp CAPTION=\"He said &quot;hi&quot; &lt;loudly&gt;\">");
+	}
+
+	// ── Storage ──────────────────────────────────────────────────────────────────
+
+	/// <summary>The vocabulary is core's, so text carrying it round-trips with no package registered at all.</summary>
+	[Test]
+	public async Task TheVocabularyRoundTripsWithNoPackageRegistered()
+	{
+		var line = MarkupText.Concat([
+			MarkupText.Sound("door.wav", 80, 2),
+			MarkupText.Music("theme.mid", repeats: SoundMarkup.Forever, continues: true),
+			MarkupText.StopSound(SoundChannel.Effects),
+			MarkupText.Image("map.png", "A map", 200, 100, ImageAlign.Left),
+			MarkupText.Pane(MarkupText.Plain("p"), "map", "The Map"),
+			MarkupText.ClearScreen(),
+			MarkupText.ExpireLinks("exits"),
+			MarkupText.Prefetch("x.png"),
+			MarkupText.LoginPrompt(LoginField.Password),
+			MarkupText.Relocate("other.example", 4201, true),
+			MarkupText.Variable(MarkupText.Plain("42"), "hp"),
+			MarkupText.Gauge(MarkupText.Plain("g"), "hp", "maxhp", "HP", "red"),
+			MarkupText.Status(MarkupText.Plain("s"), "mana", "maxmana", "Mana"),
+			MarkupText.Bell()]);
+
+		var back = MarkupTextSerializer.Deserialize(
+			MarkupTextSerializer.Serialize(line, MarkupRegistry.Empty), MarkupRegistry.Empty);
+
+		await Assert.That(back.Runs.SequenceEqual(line.Runs)).IsTrue();
+		foreach (var format in new[] { MarkupFormat.Mxp, MarkupFormat.Pueblo, MarkupFormat.Html, MarkupFormat.Ansi })
+		{
+			await Assert.That(Render(back, format)).IsEqualTo(Render(line, format));
+		}
+	}
+
+	// ── Arguments ────────────────────────────────────────────────────────────────
+
+	[Test]
+	public async Task OutOfRangeArgumentsAreRefused()
+	{
+		await Assert.That(() => MarkupText.Sound("")).Throws<ArgumentException>();
+		await Assert.That(() => MarkupText.Sound("a.wav", volume: 101)).Throws<ArgumentOutOfRangeException>();
+		await Assert.That(() => MarkupText.Sound("a.wav", repeats: 0)).Throws<ArgumentOutOfRangeException>();
+		await Assert.That(() => MarkupText.Image("a.png", width: 0)).Throws<ArgumentOutOfRangeException>();
+		await Assert.That(() => MarkupText.Relocate("h", 70000)).Throws<ArgumentOutOfRangeException>();
+		await Assert.That(() => MarkupText.Pane(MarkupText.Plain("x"), "")).Throws<ArgumentException>();
+	}
+}
diff --git a/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=html.verified.txt b/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=html.verified.txt
index 51a76a0..63358ed 100644
--- a/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=html.verified.txt
+++ b/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=html.verified.txt
@@ -22,7 +22,7 @@
 22 nested-three-deep  | <span style="color: #aa0000" class="ms-bold ms-underline">deep</span>
 23 adjacent-runs      | <span style="color: #aa0000">red</span>-<span style="color: #00aa00" class="ms-bold">bold green</span><span class="ms-underline">under</span>
 24 html-send          | <send href="north" hint="Go north">north</send>
-25 html-b-in-colour   | <b><span style="color: #00aa00">bold green</span></b>
+25 html-b-in-colour   | <span style="color: #00aa00"><b>bold green</b></span>
 26 unicode            | <span style="color: #aa0000">日本語 😀 café</span>
 27 needs-encoding     | <span class="ms-bold">&lt;a href="x"&gt; &amp; 'y' &lt;/a&gt;</span>
 28 clear-after-colour | <span style="color: #aa0000">red</span>cleared
diff --git a/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=mxp.verified.txt b/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=mxp.verified.txt
index 1f17334..b9cf146 100644
--- a/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=mxp.verified.txt
+++ b/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=mxp.verified.txt
@@ -22,7 +22,7 @@
 22 nested-three-deep  | <ESC>[1;4;31mdeep<ESC>[0m
 23 adjacent-runs      | <ESC>[31mred<ESC>[0m-<ESC>[1;32mbold green<ESC>[0m<ESC>[4munder<ESC>[0m
 24 html-send          | <send href="north" hint="Go north">north</send>
-25 html-b-in-colour   | <b><ESC>[32mbold green<ESC>[0m</b>
+25 html-b-in-colour   | <ESC>[32m<b>bold green</b><ESC>[0m
 26 unicode            | <ESC>[31m日本語 😀 café<ESC>[0m
 27 needs-encoding     | <ESC>[1m&lt;a href="x"&gt; &amp; 'y' &lt;/a&gt;<ESC>[0m
 28 clear-after-colour | <ESC>[31mred<ESC>[0m<ESC>[0mcleared
diff --git a/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=pueblo.verified.txt b/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=pueblo.verified.txt
index 76aaab6..c57f792 100644
--- a/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=pueblo.verified.txt
+++ b/MarkupString.Tests/Snapshots/FormatSnapshotTests.EveryFixture_RendersStably_formatName=pueblo.verified.txt
@@ -22,7 +22,7 @@
 22 nested-three-deep  | <ESC>[1;4;31mdeep<ESC>[0m
 23 adjacent-runs      | <ESC>[31mred<ESC>[0m-<ESC>[1;32mbold green<ESC>[0m<ESC>[4munder<ESC>[0m
 24 html-send          | <send href="north" hint="Go north">north</send>
-25 html-b-in-colour   | <b><ESC>[32mbold green<ESC>[0m</b>
+25 html-b-in-colour   | <ESC>[32m<b>bold green</b><ESC>[0m
 26 unicode            | <ESC>[31m日本語 😀 café<ESC>[0m
 27 needs-encoding     | <ESC>[1m&lt;a href="x"&gt; &amp; 'y' &lt;/a&gt;<ESC>[0m
 28 clear-after-colour | <ESC>[31mred<ESC>[0m<ESC>[0mcleared
diff --git a/MarkupString.slnx b/MarkupString.slnx
index f5a6ed7..5ea97db 100644
--- a/MarkupString.slnx
+++ b/MarkupString.slnx
@@ -2,6 +2,8 @@
   <Project Path="MarkupString.Ansi/MarkupString.Ansi.csproj" />
   <Project Path="MarkupString.AotSmoke/MarkupString.AotSmoke.csproj" />
   <Project Path="MarkupString.Html/MarkupString.Html.csproj" />
+  <Project Path="MarkupString.Mxp/MarkupString.Mxp.csproj" />
+  <Project Path="MarkupString.Pueblo/MarkupString.Pueblo.csproj" />
   <Project Path="MarkupString.Tests/MarkupString.Tests.csproj" />
   <Project Path="MarkupString/MarkupString.csproj" />
 </Solution>
diff --git a/MarkupString/BellMarkup.cs b/MarkupString/BellMarkup.cs
index a2d4d39..0431646 100644
--- a/MarkupString/BellMarkup.cs
+++ b/MarkupString/BellMarkup.cs
@@ -11,7 +11,7 @@ namespace MarkupString;
 /// point in the string without moving anything that is laid out around it. A format with no bell drops
 /// the character with every other control, and nothing is left behind.
 /// </remarks>
-public sealed class BellMarkup : IMarkup
+public sealed class BellMarkup : IPointMarkup
 {
 	/// <summary>The character a bell is carried on.</summary>
 	public const string Character = "\u0007";
diff --git a/MarkupString/Elements/ElementCodecs.cs b/MarkupString/Elements/ElementCodecs.cs
new file mode 100644
index 0000000..514423d
--- /dev/null
+++ b/MarkupString/Elements/ElementCodecs.cs
@@ -0,0 +1,135 @@
+using System.Text.Json;
+namespace MarkupString;
+
+/// <summary>
+/// The codecs for the shared vocabulary, which is core's and so needs no registration. The serializer
+/// asks here before it asks a registry.
+/// </summary>
+internal static class ElementCodecs
+{
+	private static readonly IMarkupCodec[] All =
+	[
+		new Codec<BellMarkup>("bell", static (_, _) => { }, static _ => BellMarkup.Instance),
+		new Codec<ClearScreenMarkup>("clear", static (_, _) => { }, static _ => ClearScreenMarkup.Instance),
+		new Codec<SoundMarkup>("sound",
+			static (w, m) =>
+			{
+				w.WriteString("s", m.Source);
+				if (m.Channel == SoundChannel.Music) w.WriteString("c", "music");
+				if (m.Volume is { } volume) w.WriteNumber("v", volume);
+				if (m.Repeats is { } repeats) w.WriteNumber("r", repeats);
+				if (m.Continues) w.WriteBoolean("co", true);
+			},
+			static e => new SoundMarkup(
+				String(e, "s") ?? string.Empty,
+				Channel(e) ?? SoundChannel.Effects,
+				Int(e, "v"),
+				Int(e, "r"),
+				e.TryGetProperty("co", out var c) && c.ValueKind == JsonValueKind.True)),
+		new Codec<SoundStopMarkup>("sound-stop",
+			static (w, m) =>
+			{
+				if (m.Channel is { } channel) w.WriteString("c", channel == SoundChannel.Music ? "music" : "effects");
+			},
+			static e => new SoundStopMarkup(Channel(e))),
+		new Codec<ImageMarkup>("image",
+			static (w, m) =>
+			{
+				w.WriteString("s", m.Source);
+				if (m.Description is not null) w.WriteString("d", m.Description);
+				if (m.Width is { } width) w.WriteNumber("w", width);
+				if (m.Height is { } height) w.WriteNumber("h", height);
+				if (m.Align is { } align) w.WriteString("a", align.ToString().ToLowerInvariant());
+			},
+			static e => new ImageMarkup(
+				String(e, "s") ?? string.Empty,
+				String(e, "d"),
+				Int(e, "w"),
+				Int(e, "h"),
+				Enum.TryParse<ImageAlign>(String(e, "a"), ignoreCase: true, out var align) ? align : null)),
+		new Codec<PaneMarkup>("pane",
+			static (w, m) =>
+			{
+				w.WriteString("n", m.Name);
+				if (m.Title is not null) w.WriteString("ti", m.Title);
+			},
+			static e => new PaneMarkup(String(e, "n") ?? string.Empty, String(e, "ti"))),
+		new Codec<ExpireLinksMarkup>("expire",
+			static (w, m) =>
+			{
+				if (m.Group is not null) w.WriteString("g", m.Group);
+			},
+			static e => new ExpireLinksMarkup(String(e, "g"))),
+		new Codec<PrefetchMarkup>("prefetch",
+			static (w, m) => w.WriteString("s", m.Source),
+			static e => new PrefetchMarkup(String(e, "s") ?? string.Empty)),
+		new Codec<LoginPromptMarkup>("login",
+			static (w, m) => w.WriteString("f", m.Field == LoginField.Password ? "password" : "user"),
+			static e => new LoginPromptMarkup(String(e, "f") == "password" ? LoginField.Password : LoginField.User)),
+		new Codec<RelocateMarkup>("relocate",
+			static (w, m) =>
+			{
+				w.WriteString("ho", m.Host);
+				w.WriteNumber("po", m.Port);
+				if (m.Quiet) w.WriteBoolean("q", true);
+			},
+			static e => new RelocateMarkup(
+				String(e, "ho") ?? string.Empty,
+				Int(e, "po") ?? 0,
+				e.TryGetProperty("q", out var q) && q.ValueKind == JsonValueKind.True)),
+		new Codec<VariableMarkup>("var",
+			static (w, m) => w.WriteString("n", m.Name),
+			static e => new VariableMarkup(String(e, "n") ?? string.Empty)),
+		new Codec<GaugeMarkup>("gauge",
+			static (w, m) =>
+			{
+				w.WriteString("n", m.Variable);
+				w.WriteString("m", m.Maximum);
+				if (m.Caption is not null) w.WriteString("ca", m.Caption);
+				if (m.Color is not null) w.WriteString("co", m.Color);
+			},
+			static e => new GaugeMarkup(String(e, "n") ?? string.Empty, String(e, "m") ?? string.Empty, String(e, "ca"), String(e, "co"))),
+		new Codec<StatusMarkup>("status",
+			static (w, m) =>
+			{
+				w.WriteString("n", m.Variable);
+				if (m.Maximum is not null) w.WriteString("m", m.Maximum);
+				if (m.Caption is not null) w.WriteString("ca", m.Caption);
+			},
+			static e => new StatusMarkup(String(e, "n") ?? string.Empty, String(e, "m"), String(e, "ca"))),
+	];
+
+	private static readonly Dictionary<Type, IMarkupCodec> ByType = All.ToDictionary(c => c.MarkupType);
+	private static readonly Dictionary<string, IMarkupCodec> ByKind = All.ToDictionary(c => c.Kind, StringComparer.Ordinal);
+
+	public static IMarkupCodec? Find(Type markupType) => ByType.GetValueOrDefault(markupType);
+
+	public static IMarkupCodec? Find(string kind) => ByKind.GetValueOrDefault(kind);
+
+	private static string? String(JsonElement element, string name) =>
+		element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String ? value.GetString() : null;
+
+	private static int? Int(JsonElement element, string name) =>
+		element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.Number && value.TryGetInt32(out var number)
+			? number
+			: null;
+
+	private static SoundChannel? Channel(JsonElement element) => String(element, "c") switch
+	{
+		"music" => SoundChannel.Music,
+		"effects" => SoundChannel.Effects,
+		_ => null,
+	};
+
+	private sealed class Codec<T>(string kind, Action<Utf8JsonWriter, T> write, Func<JsonElement, T> read) : IMarkupCodec
+		where T : IMarkup
+	{
+		public string Kind => kind;
+
+		public Type MarkupType => typeof(T);
+
+		public void Write(Utf8JsonWriter writer, IMarkup markup) => write(writer, (T)markup);
+
+		public IMarkup Read(JsonElement element) => read(element);
+	}
+}
diff --git a/MarkupString/Elements/ImageMarkup.cs b/MarkupString/Elements/ImageMarkup.cs
new file mode 100644
index 0000000..78dff30
--- /dev/null
+++ b/MarkupString/Elements/ImageMarkup.cs
@@ -0,0 +1,41 @@
+namespace MarkupString;
+
+/// <summary>How an image sits against the text around it.</summary>
+public enum ImageAlign
+{
+	/// <summary>Floated to the left, text flowing round it.</summary>
+	Left,
+
+	/// <summary>Floated to the right, text flowing round it.</summary>
+	Right,
+
+	/// <summary>In the line, its top level with the text's.</summary>
+	Top,
+
+	/// <summary>In the line, its middle level with the text's.</summary>
+	Middle,
+
+	/// <summary>In the line, sitting on the text's baseline.</summary>
+	Bottom,
+}
+
+/// <summary>
+/// A picture. It wraps the text a client with no pictures shows instead — its description, or the
+/// address when there is none. <see cref="MarkupText.Image"/> builds one.
+/// </summary>
+/// <remarks>
+/// MXP writes <c>&lt;IMAGE&gt;</c>, Pueblo and HTML <c>&lt;img&gt;</c>, and BBCode <c>[img]</c>. Every
+/// other format writes the wrapped text, so a terminal still learns there was a picture and where it is.
+/// Put it inside a link to make it one.
+/// </remarks>
+/// <param name="Source">The picture: a file name the client resolves against the game's own image directory, or an absolute address.</param>
+/// <param name="Description">What the picture shows, for a reader who cannot see it.</param>
+/// <param name="Width">Its width in pixels, or the picture's own when null.</param>
+/// <param name="Height">Its height in pixels, or the picture's own when null.</param>
+/// <param name="Align">How it sits against the text, or the client's default when null.</param>
+public sealed record ImageMarkup(
+	string Source,
+	string? Description = null,
+	int? Width = null,
+	int? Height = null,
+	ImageAlign? Align = null) : IMarkup;
diff --git a/MarkupString/Elements/PaneMarkup.cs b/MarkupString/Elements/PaneMarkup.cs
new file mode 100644
index 0000000..6876ba1
--- /dev/null
+++ b/MarkupString/Elements/PaneMarkup.cs
@@ -0,0 +1,14 @@
+namespace MarkupString;
+
+/// <summary>
+/// Sends the text it wraps to a named pane — a window or region of its own — rather than to the main
+/// output, opening the pane if it is not already open. <see cref="MarkupText.Pane"/> builds one.
+/// </summary>
+/// <remarks>
+/// MXP writes a <c>&lt;FRAME&gt;</c> and a <c>&lt;DEST&gt;</c> around the text, Pueblo redirects it with
+/// <c>&lt;xch_pane&gt;</c> and back again, and HTML marks it for the page to place. A client with no
+/// panes shows the text where it is, which is why the text travels inside the markup rather than after it.
+/// </remarks>
+/// <param name="Name">The pane's name; text sent to the same name goes to the same pane.</param>
+/// <param name="Title">The title the pane is shown with, or its name when null.</param>
+public sealed record PaneMarkup(string Name, string? Title = null) : IMarkup;
diff --git a/MarkupString/Elements/ScreenMarkup.cs b/MarkupString/Elements/ScreenMarkup.cs
new file mode 100644
index 0000000..b5c6b02
--- /dev/null
+++ b/MarkupString/Elements/ScreenMarkup.cs
@@ -0,0 +1,65 @@
+namespace MarkupString;
+
+/// <summary>
+/// Clears what the player has been shown. <see cref="MarkupText.ClearScreen"/> builds one.
+/// </summary>
+/// <remarks>
+/// A terminal gets <c>ESC[H ESC[2J</c>, Pueblo <c>&lt;xch_page clear="text"&gt;</c>, and an HTML page an
+/// empty <c>ms-clear</c> element to act on. MXP has no such instruction and is sent nothing.
+/// </remarks>
+public sealed class ClearScreenMarkup : IPointMarkup
+{
+	/// <summary>The one instance; clearing carries no state.</summary>
+	public static readonly ClearScreenMarkup Instance = new();
+
+	private ClearScreenMarkup()
+	{
+	}
+}
+
+/// <summary>
+/// Makes links already shown stop working: every one, or those in a named group.
+/// <see cref="MarkupText.ExpireLinks"/> builds one.
+/// </summary>
+/// <remarks>
+/// MXP writes <c>&lt;EXPIRE&gt;</c>; an HTML page gets an empty <c>ms-expire</c> element to act on.
+/// Clients without the idea are sent nothing, and their old links go on working.
+/// </remarks>
+/// <param name="Group">The group of links to expire; every link when null.</param>
+public sealed record ExpireLinksMarkup(string? Group = null) : IPointMarkup;
+
+/// <summary>
+/// Asks the client to fetch something now that it will want soon — a picture, a sound — so that it is
+/// already there when it is used. <see cref="MarkupText.Prefetch"/> builds one.
+/// </summary>
+/// <remarks>Pueblo writes <c>&lt;xch_prefetch&gt;</c>, and HTML a <c>&lt;link rel="prefetch"&gt;</c>.</remarks>
+/// <param name="Source">The address to fetch.</param>
+public sealed record PrefetchMarkup(string Source) : IPointMarkup;
+
+/// <summary>Which login prompt a <see cref="LoginPromptMarkup"/> marks.</summary>
+public enum LoginField
+{
+	/// <summary>The prompt that asks for a name.</summary>
+	User,
+
+	/// <summary>The prompt that asks for a password.</summary>
+	Password,
+}
+
+/// <summary>
+/// Marks a login prompt, so a client that stores a player's name and password knows which to send.
+/// <see cref="MarkupText.LoginPrompt"/> builds one.
+/// </summary>
+/// <remarks>MXP writes <c>&lt;USER&gt;</c> or <c>&lt;PASSWORD&gt;</c>; nothing else has the idea.</remarks>
+/// <param name="Field">Which prompt this is.</param>
+public sealed record LoginPromptMarkup(LoginField Field) : IPointMarkup;
+
+/// <summary>
+/// Asks the client to disconnect and connect to another address. <see cref="MarkupText.Relocate"/>
+/// builds one.
+/// </summary>
+/// <remarks>MXP writes <c>&lt;RELOCATE&gt;</c>; nothing else has the idea.</remarks>
+/// <param name="Host">The host to connect to.</param>
+/// <param name="Port">The port to connect to.</param>
+/// <param name="Quiet">Whether the client reconnects without telling the player.</param>
+public sealed record RelocateMarkup(string Host, int Port, bool Quiet = false) : IPointMarkup;
diff --git a/MarkupString/Elements/SoundMarkup.cs b/MarkupString/Elements/SoundMarkup.cs
new file mode 100644
index 0000000..619cbf7
--- /dev/null
+++ b/MarkupString/Elements/SoundMarkup.cs
@@ -0,0 +1,52 @@
+namespace MarkupString;
+
+/// <summary>Which player a sound goes to.</summary>
+public enum SoundChannel
+{
+	/// <summary>Effects: a door, a footstep. Several can overlap.</summary>
+	Effects,
+
+	/// <summary>Background music: one piece at a time, replacing whatever was playing.</summary>
+	Music,
+}
+
+/// <summary>
+/// Plays a sound. <see cref="MarkupText.Sound"/> and <see cref="MarkupText.Music"/> build one.
+/// </summary>
+/// <remarks>
+/// MXP writes <c>&lt;SOUND&gt;</c> or <c>&lt;MUSIC&gt;</c>, Pueblo <c>&lt;img xch_sound&gt;</c>, and HTML an
+/// <c>&lt;audio&gt;</c> element that the page decides whether to play. A terminal is sent nothing.
+/// </remarks>
+/// <param name="Source">
+/// The sound: a file name the client resolves against the game's own sound directory, or an absolute
+/// address.
+/// </param>
+/// <param name="Channel">Effects or music.</param>
+/// <param name="Volume">From 0 to 100; the client's own level when null.</param>
+/// <param name="Repeats">
+/// How many times to play it, or <see cref="Forever"/>; once when null. A client that cannot count
+/// plays it once, or loops it for <see cref="Forever"/>.
+/// </param>
+/// <param name="Continues">
+/// For music: carry on, rather than restart, when this piece is already playing.
+/// </param>
+public sealed record SoundMarkup(
+	string Source,
+	SoundChannel Channel = SoundChannel.Effects,
+	int? Volume = null,
+	int? Repeats = null,
+	bool Continues = false) : IPointMarkup
+{
+	/// <summary>The <see cref="Repeats"/> value that loops a sound until it is stopped.</summary>
+	public const int Forever = -1;
+
+	/// <summary>Whether this sound loops until it is stopped.</summary>
+	public bool Loops => Repeats == Forever;
+}
+
+/// <summary>
+/// Stops what is playing on one channel, or on both when <see cref="Channel"/> is null.
+/// <see cref="MarkupText.StopSound"/> builds one.
+/// </summary>
+/// <param name="Channel">The channel to silence; both when null.</param>
+public sealed record SoundStopMarkup(SoundChannel? Channel = null) : IPointMarkup;
diff --git a/MarkupString/Elements/StatusMarkup.cs b/MarkupString/Elements/StatusMarkup.cs
new file mode 100644
index 0000000..2a92761
--- /dev/null
+++ b/MarkupString/Elements/StatusMarkup.cs
@@ -0,0 +1,36 @@
+namespace MarkupString;
+
+/// <summary>
+/// Names the value the text it wraps is, so a client can keep it — MXP's variables, which a client can
+/// show in a status bar or a gauge. <see cref="MarkupText.Variable"/> builds one.
+/// </summary>
+/// <remarks>
+/// MXP writes <c>&lt;VAR&gt;</c> around the text, and HTML marks it for the page. Every client shows
+/// the text itself.
+/// </remarks>
+/// <param name="Name">The variable's name.</param>
+public sealed record VariableMarkup(string Name) : IMarkup;
+
+/// <summary>
+/// A gauge showing one variable against another — hit points against their maximum. It wraps the
+/// text a client with no gauges shows instead. <see cref="MarkupText.Gauge"/> builds one.
+/// </summary>
+/// <remarks>
+/// MXP writes <c>&lt;GAUGE&gt;</c>, which follows the two variables as they change; HTML marks the text
+/// for the page to draw. Every other format writes the text.
+/// </remarks>
+/// <param name="Variable">The variable the gauge shows.</param>
+/// <param name="Maximum">The variable holding its maximum.</param>
+/// <param name="Caption">The gauge's label.</param>
+/// <param name="Color">Its colour, as a name or <c>#rrggbb</c>, or the client's own when null.</param>
+public sealed record GaugeMarkup(string Variable, string Maximum, string? Caption = null, string? Color = null) : IMarkup;
+
+/// <summary>
+/// A variable shown in the client's status bar, optionally against a maximum. It wraps the text a
+/// client with no status bar shows instead. <see cref="MarkupText.Status"/> builds one.
+/// </summary>
+/// <remarks>MXP writes <c>&lt;STAT&gt;</c>; HTML marks the text for the page. Every other format writes the text.</remarks>
+/// <param name="Variable">The variable shown.</param>
+/// <param name="Maximum">The variable holding its maximum, if it has one.</param>
+/// <param name="Caption">The label shown with it.</param>
+public sealed record StatusMarkup(string Variable, string? Maximum = null, string? Caption = null) : IMarkup;
diff --git a/MarkupString/IPointMarkup.cs b/MarkupString/IPointMarkup.cs
new file mode 100644
index 0000000..870f890
--- /dev/null
+++ b/MarkupString/IPointMarkup.cs
@@ -0,0 +1,18 @@
+namespace MarkupString;
+
+/// <summary>
+/// A markup that stands at a point in the text rather than marking any of it: a sound, a bell, an
+/// instruction to clear the screen.
+/// </summary>
+/// <remarks>
+/// <para>A point rides on a carrier character — <see cref="MarkupText.PointCarrier"/>, or the bell's own
+/// U+0007 — so that it has a position which survives slicing and concatenation. The carrier is not
+/// text: <see cref="MarkupText.ToPlainText"/> leaves it out, it measures no display cells, and the
+/// renderer never writes it.</para>
+/// <para>A format with an emitter for the point writes what the emitter writes, once per carrier. A format
+/// with none writes nothing at all, so the same text can go to every client and each one gets only what
+/// it can use.</para>
+/// </remarks>
+public interface IPointMarkup : IMarkup
+{
+}
diff --git a/MarkupString/MarkupText.Elements.cs b/MarkupString/MarkupText.Elements.cs
new file mode 100644
index 0000000..de5be27
--- /dev/null
+++ b/MarkupString/MarkupText.Elements.cs
@@ -0,0 +1,152 @@
+namespace MarkupString;
+
+/// <summary>
+/// The shared vocabulary: things a game puts in its text once — a sound, a picture, a pane — and that
+/// each format writes in its own dialect, or leaves out, or stands something else in for.
+/// </summary>
+/// <remarks>
+/// The types live here and say what a thing is; the packages for each format say how it is written
+/// (<c>WithAnsi()</c>, <c>WithHtml()</c>, <c>WithMxp()</c>, <c>WithPueblo()</c>). A format with no
+/// emitter for a thing does what it always does with markup it does not know: a point
+/// (<see cref="IPointMarkup"/>) writes nothing, and a markup wrapping text writes the text.
+/// </remarks>
+public sealed partial class MarkupText
+{
+	/// <summary>
+	/// The character a point rides on: a zero-width space. It measures nothing, is left out of
+	/// <see cref="ToPlainText"/>, and is never written — a format either writes the point or writes
+	/// nothing.
+	/// </summary>
+	public const string PointCarrier = "\u200b";
+
+	/// <summary>A point in the text, riding on <see cref="PointCarrier"/>.</summary>
+	public static MarkupText Point(IPointMarkup markup)
+	{
+		ArgumentNullException.ThrowIfNull(markup);
+		return Wrap(markup, PointCarrier);
+	}
+
+	/// <summary>Plays a sound effect. See <see cref="SoundMarkup"/>.</summary>
+	/// <param name="source">A file name in the game's sound directory, or an absolute address.</param>
+	/// <param name="volume">From 0 to 100; the client's own level when null.</param>
+	/// <param name="repeats">How many times to play it, or <see cref="SoundMarkup.Forever"/>; once when null.</param>
+	/// <exception cref="ArgumentException"><paramref name="source"/> is empty.</exception>
+	/// <exception cref="ArgumentOutOfRangeException"><paramref name="volume"/> or <paramref name="repeats"/> is out of range.</exception>
+	public static MarkupText Sound(string source, int? volume = null, int? repeats = null) =>
+		Point(Checked(new SoundMarkup(source, SoundChannel.Effects, volume, repeats)));
+
+	/// <summary>Plays background music, replacing what was playing. See <see cref="SoundMarkup"/>.</summary>
+	/// <param name="source">A file name in the game's sound directory, or an absolute address.</param>
+	/// <param name="volume">From 0 to 100; the client's own level when null.</param>
+	/// <param name="repeats">How many times to play it, or <see cref="SoundMarkup.Forever"/>; once when null.</param>
+	/// <param name="continues">Carry on, rather than restart, when this piece is already playing.</param>
+	/// <exception cref="ArgumentException"><paramref name="source"/> is empty.</exception>
+	/// <exception cref="ArgumentOutOfRangeException"><paramref name="volume"/> or <paramref name="repeats"/> is out of range.</exception>
+	public static MarkupText Music(string source, int? volume = null, int? repeats = null, bool continues = false) =>
+		Point(Checked(new SoundMarkup(source, SoundChannel.Music, volume, repeats, continues)));
+
+	/// <summary>Stops what is playing on <paramref name="channel"/>, or on both when null. See <see cref="SoundStopMarkup"/>.</summary>
+	public static MarkupText StopSound(SoundChannel? channel = null) => Point(new SoundStopMarkup(channel));
+
+	/// <summary>
+	/// A picture, standing in <paramref name="description"/> — or the address, when there is none — for
+	/// a client that shows no pictures. See <see cref="ImageMarkup"/>.
+	/// </summary>
+	/// <exception cref="ArgumentException"><paramref name="source"/> is empty.</exception>
+	/// <exception cref="ArgumentOutOfRangeException"><paramref name="width"/> or <paramref name="height"/> is not positive.</exception>
+	public static MarkupText Image(
+		string source,
+		string? description = null,
+		int? width = null,
+		int? height = null,
+		ImageAlign? align = null)
+	{
+		ArgumentException.ThrowIfNullOrEmpty(source);
+		if (width is { } w) ArgumentOutOfRangeException.ThrowIfNegativeOrZero(w, nameof(width));
+		if (height is { } h) ArgumentOutOfRangeException.ThrowIfNegativeOrZero(h, nameof(height));
+
+		var shown = string.IsNullOrEmpty(description) ? source : description;
+		return Wrap(new ImageMarkup(source, description, width, height, align), Plain(shown));
+	}
+
+	/// <summary>Sends <paramref name="content"/> to the pane named <paramref name="name"/>. See <see cref="PaneMarkup"/>.</summary>
+	/// <exception cref="ArgumentException"><paramref name="name"/> is empty.</exception>
+	public static MarkupText Pane(MarkupText content, string name, string? title = null)
+	{
+		ArgumentNullException.ThrowIfNull(content);
+		ArgumentException.ThrowIfNullOrEmpty(name);
+		return Wrap(new PaneMarkup(name, title), content);
+	}
+
+	/// <summary>Clears what the player has been shown. See <see cref="ClearScreenMarkup"/>.</summary>
+	public static MarkupText ClearScreen() => Point(ClearScreenMarkup.Instance);
+
+	/// <summary>Makes the links in <paramref name="group"/>, or every link, stop working. See <see cref="ExpireLinksMarkup"/>.</summary>
+	public static MarkupText ExpireLinks(string? group = null) => Point(new ExpireLinksMarkup(group));
+
+	/// <summary>Asks the client to fetch <paramref name="source"/> ahead of time. See <see cref="PrefetchMarkup"/>.</summary>
+	/// <exception cref="ArgumentException"><paramref name="source"/> is empty.</exception>
+	public static MarkupText Prefetch(string source)
+	{
+		ArgumentException.ThrowIfNullOrEmpty(source);
+		return Point(new PrefetchMarkup(source));
+	}
+
+	/// <summary>Marks the prompt that follows as the login's <paramref name="field"/>. See <see cref="LoginPromptMarkup"/>.</summary>
+	public static MarkupText LoginPrompt(LoginField field) => Point(new LoginPromptMarkup(field));
+
+	/// <summary>Asks the client to reconnect to <paramref name="host"/>:<paramref name="port"/>. See <see cref="RelocateMarkup"/>.</summary>
+	/// <exception cref="ArgumentException"><paramref name="host"/> is empty.</exception>
+	/// <exception cref="ArgumentOutOfRangeException"><paramref name="port"/> is not a port.</exception>
+	public static MarkupText Relocate(string host, int port, bool quiet = false)
+	{
+		ArgumentException.ThrowIfNullOrEmpty(host);
+		ArgumentOutOfRangeException.ThrowIfNegativeOrZero(port);
+		ArgumentOutOfRangeException.ThrowIfGreaterThan(port, 65535);
+		return Point(new RelocateMarkup(host, port, quiet));
+	}
+
+	/// <summary>Names <paramref name="content"/> as the variable <paramref name="name"/>. See <see cref="VariableMarkup"/>.</summary>
+	/// <exception cref="ArgumentException"><paramref name="name"/> is empty.</exception>
+	public static MarkupText Variable(MarkupText content, string name)
+	{
+		ArgumentNullException.ThrowIfNull(content);
+		ArgumentException.ThrowIfNullOrEmpty(name);
+		return Wrap(new VariableMarkup(name), content);
+	}
+
+	/// <summary>
+	/// A gauge of <paramref name="variable"/> against <paramref name="maximum"/>, standing in
+	/// <paramref name="content"/> for a client with no gauges. See <see cref="GaugeMarkup"/>.
+	/// </summary>
+	/// <exception cref="ArgumentException"><paramref name="variable"/> or <paramref name="maximum"/> is empty.</exception>
+	public static MarkupText Gauge(MarkupText content, string variable, string maximum, string? caption = null, string? color = null)
+	{
+		ArgumentNullException.ThrowIfNull(content);
+		ArgumentException.ThrowIfNullOrEmpty(variable);
+		ArgumentException.ThrowIfNullOrEmpty(maximum);
+		return Wrap(new GaugeMarkup(variable, maximum, caption, color), content);
+	}
+
+	/// <summary>
+	/// <paramref name="variable"/> in the client's status bar, standing in <paramref name="content"/>
+	/// for a client with none. See <see cref="StatusMarkup"/>.
+	/// </summary>
+	/// <exception cref="ArgumentException"><paramref name="variable"/> is empty.</exception>
+	public static MarkupText Status(MarkupText content, string variable, string? maximum = null, string? caption = null)
+	{
+		ArgumentNullException.ThrowIfNull(content);
+		ArgumentException.ThrowIfNullOrEmpty(variable);
+		return Wrap(new StatusMarkup(variable, maximum, caption), content);
+	}
+
+	private static SoundMarkup Checked(SoundMarkup sound)
+	{
+		ArgumentException.ThrowIfNullOrEmpty(sound.Source, "source");
+		if (sound.Volume is { } volume && volume is < 0 or > 100)
+			throw new ArgumentOutOfRangeException("volume", volume, "A volume is from 0 to 100.");
+		if (sound.Repeats is { } repeats && repeats is 0 or < SoundMarkup.Forever)
+			throw new ArgumentOutOfRangeException("repeats", repeats, "A sound plays at least once, or forever.");
+		return sound;
+	}
+}
diff --git a/MarkupString/MarkupText.cs b/MarkupString/MarkupText.cs
index a7c83c5..4863079 100644
--- a/MarkupString/MarkupText.cs
+++ b/MarkupString/MarkupText.cs
@@ -4,8 +4,8 @@ namespace MarkupString;
 /// <summary>
 /// Immutable text with zero or more styled-span <see cref="Run"/>s layered over it. Gaps
 /// between runs are plain text. Equality (<see cref="Equals(MarkupText?)"/>, <c>==</c>,
-/// <see cref="GetHashCode"/>) is ordinal comparison of <see cref="Text"/> only — markup never
-/// participates.
+/// <see cref="GetHashCode"/>) is ordinal comparison of <see cref="ToPlainText"/> only — markup never
+/// participates, and neither do the carriers points ride on.
 /// </summary>
 public sealed partial class MarkupText : IEquatable<MarkupText>
 {
@@ -123,12 +123,51 @@ public static MarkupText Join(Func<int, MarkupText> separator, IEnumerable<Marku
 		return Concat(list.ToArray().AsSpan());
 	}
 
-	public string ToPlainText() => Text;
-	public override string ToString() => Text;
-	public bool Equals(MarkupText? other) => other is not null && string.Equals(Text, other.Text, StringComparison.Ordinal);
-	public bool TextEquals(string? text) => string.Equals(Text, text, StringComparison.Ordinal);
+	/// <summary>
+	/// The text as a reader sees it: <see cref="Text"/> without the carriers points ride on
+	/// (<see cref="IPointMarkup"/>), which are positions rather than characters.
+	/// </summary>
+	public string ToPlainText() => _plainText ??= WithoutPoints();
+
+	/// <summary>The same as <see cref="ToPlainText"/>.</summary>
+	public override string ToString() => ToPlainText();
+	public bool Equals(MarkupText? other) => other is not null && string.Equals(ToPlainText(), other.ToPlainText(), StringComparison.Ordinal);
+	public bool TextEquals(string? text) => string.Equals(ToPlainText(), text, StringComparison.Ordinal);
 	public override bool Equals(object? obj) => obj is MarkupText other && Equals(other);
-	public override int GetHashCode() => string.GetHashCode(Text, StringComparison.Ordinal);
+	public override int GetHashCode() => string.GetHashCode(ToPlainText(), StringComparison.Ordinal);
+
+	private string? _plainText;
+
+	private string WithoutPoints()
+	{
+		var hasPoint = false;
+		foreach (var run in Runs)
+		{
+			if (IsPoint(run))
+			{
+				hasPoint = true;
+				break;
+			}
+		}
+		if (!hasPoint) return Text;
+
+		var plain = new System.Text.StringBuilder(Text.Length);
+		var position = 0;
+		foreach (var run in Runs)
+		{
+			if (!IsPoint(run)) continue;
+			plain.Append(Text, position, run.Start - position);
+			position = run.End;
+		}
+		return plain.Append(Text, position, Text.Length - position).ToString();
+	}
+
+	private static bool IsPoint(Run run)
+	{
+		foreach (var markup in run.Markups)
+			if (markup is IPointMarkup) return true;
+		return false;
+	}
 	public static bool operator ==(MarkupText? a, MarkupText? b) => a is null ? b is null : a.Equals(b);
 	public static bool operator !=(MarkupText? a, MarkupText? b) => !(a == b);
 
diff --git a/MarkupString/MarkupTextRenderer.cs b/MarkupString/MarkupTextRenderer.cs
index 614c8fc..f797999 100644
--- a/MarkupString/MarkupTextRenderer.cs
+++ b/MarkupString/MarkupTextRenderer.cs
@@ -169,17 +169,42 @@ private static bool RenderRun(
 		in EmitContext context,
 		IBufferWriter<char> output)
 	{
+		var markups = run.Markups;
+		var point = FindPoint(markups);
+		IMarkupEmitter? pointEmitter = null;
+		if (point is not null)
+		{
+			// A point's carrier is not text. With no emitter for this format the point writes nothing —
+			// not the carrier, and not the layers around it, which would wrap an empty body.
+			pointEmitter = registry.FindEmitter(point.GetType(), format);
+			if (pointEmitter is null) return false;
+			markups = Without(markups, point);
+		}
+
 		var front = new PooledCharWriter(body.Length + 16);
 		PooledCharWriter? back = null;
 		try
 		{
-			EncodeText(body, format.Encoding, front);
+			if (pointEmitter is not null)
+			{
+				// Equal points side by side coalesce into one run; each carrier is still one point.
+				for (var i = 0; i < body.Length; i++) pointEmitter.Emit(point!, body.Slice(i, 1), context, front);
+				if (markups is null)
+				{
+					output.Write(front.WrittenSpan);
+					return true;
+				}
+			}
+			else
+			{
+				EncodeText(body, format.Encoding, front);
+			}
 
 			var setEmitter = registry.FindSetEmitter(format);
 			if (setEmitter is not null)
 			{
 				back = new PooledCharWriter(front.WrittenCount + 16);
-				if (setEmitter.TryEmit(run.Markups, front.WrittenSpan, context, back))
+				if (setEmitter.TryEmit(markups!, front.WrittenSpan, context, back))
 				{
 					output.Write(back.WrittenSpan);
 					return true;
@@ -187,10 +212,10 @@ private static bool RenderRun(
 				back.Clear();
 			}
 
-			var emitted = false;
-			for (var i = 0; i < run.Markups.Count; i++)
+			var emitted = pointEmitter is not null;
+			for (var i = 0; i < markups!.Count; i++)
 			{
-				var markup = run.Markups[i];
+				var markup = markups[i];
 				var emitter = registry.FindEmitter(markup.GetType(), format);
 				if (emitter is null) continue;
 				emitted = true;
@@ -209,4 +234,23 @@ private static bool RenderRun(
 			back?.Dispose();
 		}
 	}
+
+	/// <summary>The point a run carries, if any.</summary>
+	private static IPointMarkup? FindPoint(MarkupSet markups)
+	{
+		foreach (var markup in markups)
+			if (markup is IPointMarkup point) return point;
+		return null;
+	}
+
+	/// <summary>The run's other layers, or null when the point was its only one.</summary>
+	private static MarkupSet? Without(MarkupSet markups, IPointMarkup point)
+	{
+		if (markups.Count == 1) return null;
+
+		var rest = new List<IMarkup>(markups.Count - 1);
+		foreach (var markup in markups)
+			if (!ReferenceEquals(markup, point)) rest.Add(markup);
+		return MarkupSet.Of(rest);
+	}
 }
diff --git a/MarkupString/MarkupTextSerializer.cs b/MarkupString/MarkupTextSerializer.cs
index d605731..1bf4a5e 100644
--- a/MarkupString/MarkupTextSerializer.cs
+++ b/MarkupString/MarkupTextSerializer.cs
@@ -28,7 +28,8 @@ namespace MarkupString;
 /// <para>
 /// Each markup object carries a <c>"k"</c> kind discriminator, written first by this class; a
 /// registered <see cref="IMarkupCodec"/> writes and reads only its own properties. <c>"neutral"</c>
-/// is built in and needs no codec. Objects written before <c>"k"</c> existed are still read: <c>"h"</c>
+/// and the shared vocabulary (<see cref="SoundMarkup"/>, <see cref="ImageMarkup"/>, …) are built in and
+/// need no codec. Objects written before <c>"k"</c> existed are still read: <c>"h"</c>
 /// present means html, <c>"n"</c> present means neutral, and anything else is ansi. A kind no codec
 /// claims becomes an <see cref="UnknownMarkup"/> holding the raw object, which is written back
 /// verbatim, so a reader missing a package neither loses nor corrupts its markup.
@@ -44,9 +45,6 @@ public static class MarkupTextSerializer
 	/// <summary>The kind written for, and read back as, <see cref="NeutralMarkup.Instance"/>.</summary>
 	private const string NeutralKind = "neutral";
 
-	/// <summary>The kind written for, and read back as, <see cref="BellMarkup.Instance"/>.</summary>
-	private const string BellKind = "bell";
-
 	/// <summary>
 	/// Leaves non-ASCII text as literal UTF-8 rather than <c>\uXXXX</c> escapes. The default encoder
 	/// triples the cost of CJK and Cyrillic text, which several games are written in. "Unsafe" here
@@ -197,13 +195,10 @@ private static void WriteMarkup(Utf8JsonWriter writer, IMarkup markup, MarkupReg
 		{
 			writer.WriteString("k", NeutralKind);
 		}
-		else if (markup is BellMarkup)
-		{
-			writer.WriteString("k", BellKind);
-		}
 		else
 		{
-			var codec = (registry ?? MarkupRegistry.Default).FindCodec(markup.GetType())
+			var codec = ElementCodecs.Find(markup.GetType())
+				?? (registry ?? MarkupRegistry.Default).FindCodec(markup.GetType())
 				?? throw new InvalidOperationException(
 					$"No markup codec is registered for {markup.GetType()}. Add one with MarkupRegistry.With(IMarkupCodec).");
 			writer.WriteString("k", codec.Kind);
@@ -350,9 +345,7 @@ private static IMarkup ReadMarkup(JsonElement element, MarkupRegistry? registry)
 			: "ansi";
 
 		if (kind == NeutralKind) return NeutralMarkup.Instance;
-		if (kind == BellKind) return BellMarkup.Instance;
-
-		var codec = (registry ?? MarkupRegistry.Default).FindCodec(kind);
+		var codec = ElementCodecs.Find(kind) ?? (registry ?? MarkupRegistry.Default).FindCodec(kind);
 		return codec is null ? new UnknownMarkup(kind, element.GetRawText()) : codec.Read(element);
 	}
 }
diff --git a/MarkupString/PublicAPI.Unshipped.txt b/MarkupString/PublicAPI.Unshipped.txt
index 2d75242..64146e4 100644
--- a/MarkupString/PublicAPI.Unshipped.txt
+++ b/MarkupString/PublicAPI.Unshipped.txt
@@ -14,3 +14,199 @@ const MarkupString.BellMarkup.Character = "\a" -> string!
 MarkupString.BellMarkup
 static MarkupString.MarkupText.Bell() -> MarkupString.MarkupText!
 static readonly MarkupString.BellMarkup.Instance -> MarkupString.BellMarkup!
+const MarkupString.SoundMarkup.Forever = -1 -> int
+MarkupString.ClearScreenMarkup
+MarkupString.ExpireLinksMarkup
+MarkupString.ExpireLinksMarkup.<Clone>$() -> MarkupString.ExpireLinksMarkup!
+MarkupString.ExpireLinksMarkup.Deconstruct(out string? Group) -> void
+MarkupString.ExpireLinksMarkup.Equals(MarkupString.ExpireLinksMarkup? other) -> bool
+MarkupString.ExpireLinksMarkup.ExpireLinksMarkup(string? Group = null) -> void
+MarkupString.ExpireLinksMarkup.Group.get -> string?
+MarkupString.ExpireLinksMarkup.Group.init -> void
+MarkupString.GaugeMarkup
+MarkupString.GaugeMarkup.Caption.get -> string?
+MarkupString.GaugeMarkup.Caption.init -> void
+MarkupString.GaugeMarkup.<Clone>$() -> MarkupString.GaugeMarkup!
+MarkupString.GaugeMarkup.Color.get -> string?
+MarkupString.GaugeMarkup.Color.init -> void
+MarkupString.GaugeMarkup.Deconstruct(out string! Variable, out string! Maximum, out string? Caption, out string? Color) -> void
+MarkupString.GaugeMarkup.Equals(MarkupString.GaugeMarkup? other) -> bool
+MarkupString.GaugeMarkup.GaugeMarkup(string! Variable, string! Maximum, string? Caption = null, string? Color = null) -> void
+MarkupString.GaugeMarkup.Maximum.get -> string!
+MarkupString.GaugeMarkup.Maximum.init -> void
+MarkupString.GaugeMarkup.Variable.get -> string!
+MarkupString.GaugeMarkup.Variable.init -> void
+MarkupString.ImageAlign
+MarkupString.ImageAlign.Bottom = 4 -> MarkupString.ImageAlign
+MarkupString.ImageAlign.Left = 0 -> MarkupString.ImageAlign
+MarkupString.ImageAlign.Middle = 3 -> MarkupString.ImageAlign
+MarkupString.ImageAlign.Right = 1 -> MarkupString.ImageAlign
+MarkupString.ImageAlign.Top = 2 -> MarkupString.ImageAlign
+MarkupString.ImageMarkup
+MarkupString.ImageMarkup.Align.get -> MarkupString.ImageAlign?
+MarkupString.ImageMarkup.Align.init -> void
+MarkupString.ImageMarkup.<Clone>$() -> MarkupString.ImageMarkup!
+MarkupString.ImageMarkup.Deconstruct(out string! Source, out string? Description, out int? Width, out int? Height, out MarkupString.ImageAlign? Align) -> void
+MarkupString.ImageMarkup.Description.get -> string?
+MarkupString.ImageMarkup.Description.init -> void
+MarkupString.ImageMarkup.Equals(MarkupString.ImageMarkup? other) -> bool
+MarkupString.ImageMarkup.Height.get -> int?
+MarkupString.ImageMarkup.Height.init -> void
+MarkupString.ImageMarkup.ImageMarkup(string! Source, string? Description = null, int? Width = null, int? Height = null, MarkupString.ImageAlign? Align = null) -> void
+MarkupString.ImageMarkup.Source.get -> string!
+MarkupString.ImageMarkup.Source.init -> void
+MarkupString.ImageMarkup.Width.get -> int?
+MarkupString.ImageMarkup.Width.init -> void
+MarkupString.IPointMarkup
+MarkupString.LoginField
+MarkupString.LoginField.Password = 1 -> MarkupString.LoginField
+MarkupString.LoginField.User = 0 -> MarkupString.LoginField
+MarkupString.LoginPromptMarkup
+MarkupString.LoginPromptMarkup.<Clone>$() -> MarkupString.LoginPromptMarkup!
+MarkupString.LoginPromptMarkup.Deconstruct(out MarkupString.LoginField Field) -> void
+MarkupString.LoginPromptMarkup.Equals(MarkupString.LoginPromptMarkup? other) -> bool
+MarkupString.LoginPromptMarkup.Field.get -> MarkupString.LoginField
+MarkupString.LoginPromptMarkup.Field.init -> void
+MarkupString.LoginPromptMarkup.LoginPromptMarkup(MarkupString.LoginField Field) -> void
+MarkupString.PaneMarkup
+MarkupString.PaneMarkup.<Clone>$() -> MarkupString.PaneMarkup!
+MarkupString.PaneMarkup.Deconstruct(out string! Name, out string? Title) -> void
+MarkupString.PaneMarkup.Equals(MarkupString.PaneMarkup? other) -> bool
+MarkupString.PaneMarkup.Name.get -> string!
+MarkupString.PaneMarkup.Name.init -> void
+MarkupString.PaneMarkup.PaneMarkup(string! Name, string? Title = null) -> void
+MarkupString.PaneMarkup.Title.get -> string?
+MarkupString.PaneMarkup.Title.init -> void
+MarkupString.PrefetchMarkup
+MarkupString.PrefetchMarkup.<Clone>$() -> MarkupString.PrefetchMarkup!
+MarkupString.PrefetchMarkup.Deconstruct(out string! Source) -> void
+MarkupString.PrefetchMarkup.Equals(MarkupString.PrefetchMarkup? other) -> bool
+MarkupString.PrefetchMarkup.PrefetchMarkup(string! Source) -> void
+MarkupString.PrefetchMarkup.Source.get -> string!
+MarkupString.PrefetchMarkup.Source.init -> void
+MarkupString.RelocateMarkup
+MarkupString.RelocateMarkup.<Clone>$() -> MarkupString.RelocateMarkup!
+MarkupString.RelocateMarkup.Deconstruct(out string! Host, out int Port, out bool Quiet) -> void
+MarkupString.RelocateMarkup.Equals(MarkupString.RelocateMarkup? other) -> bool
+MarkupString.RelocateMarkup.Host.get -> string!
+MarkupString.RelocateMarkup.Host.init -> void
+MarkupString.RelocateMarkup.Port.get -> int
+MarkupString.RelocateMarkup.Port.init -> void
+MarkupString.RelocateMarkup.Quiet.get -> bool
+MarkupString.RelocateMarkup.Quiet.init -> void
+MarkupString.RelocateMarkup.RelocateMarkup(string! Host, int Port, bool Quiet = false) -> void
+MarkupString.SoundChannel
+MarkupString.SoundChannel.Effects = 0 -> MarkupString.SoundChannel
+MarkupString.SoundChannel.Music = 1 -> MarkupString.SoundChannel
+MarkupString.SoundMarkup
+MarkupString.SoundMarkup.Channel.get -> MarkupString.SoundChannel
+MarkupString.SoundMarkup.Channel.init -> void
+MarkupString.SoundMarkup.<Clone>$() -> MarkupString.SoundMarkup!
+MarkupString.SoundMarkup.Continues.get -> bool
+MarkupString.SoundMarkup.Continues.init -> void
+MarkupString.SoundMarkup.Deconstruct(out string! Source, out MarkupString.SoundChannel Channel, out int? Volume, out int? Repeats, out bool Continues) -> void
+MarkupString.SoundMarkup.Equals(MarkupString.SoundMarkup? other) -> bool
+MarkupString.SoundMarkup.Loops.get -> bool
+MarkupString.SoundMarkup.Repeats.get -> int?
+MarkupString.SoundMarkup.Repeats.init -> void
+MarkupString.SoundMarkup.SoundMarkup(string! Source, MarkupString.SoundChannel Channel = MarkupString.SoundChannel.Effects, int? Volume = null, int? Repeats = null, bool Continues = false) -> void
+MarkupString.SoundMarkup.Source.get -> string!
+MarkupString.SoundMarkup.Source.init -> void
+MarkupString.SoundMarkup.Volume.get -> int?
+MarkupString.SoundMarkup.Volume.init -> void
+MarkupString.SoundStopMarkup
+MarkupString.SoundStopMarkup.Channel.get -> MarkupString.SoundChannel?
+MarkupString.SoundStopMarkup.Channel.init -> void
+MarkupString.SoundStopMarkup.<Clone>$() -> MarkupString.SoundStopMarkup!
+MarkupString.SoundStopMarkup.Deconstruct(out MarkupString.SoundChannel? Channel) -> void
+MarkupString.SoundStopMarkup.Equals(MarkupString.SoundStopMarkup? other) -> bool
+MarkupString.SoundStopMarkup.SoundStopMarkup(MarkupString.SoundChannel? Channel = null) -> void
+MarkupString.StatusMarkup
+MarkupString.StatusMarkup.Caption.get -> string?
+MarkupString.StatusMarkup.Caption.init -> void
+MarkupString.StatusMarkup.<Clone>$() -> MarkupString.StatusMarkup!
+MarkupString.StatusMarkup.Deconstruct(out string! Variable, out string? Maximum, out string? Caption) -> void
+MarkupString.StatusMarkup.Equals(MarkupString.StatusMarkup? other) -> bool
+MarkupString.StatusMarkup.Maximum.get -> string?
+MarkupString.StatusMarkup.Maximum.init -> void
+MarkupString.StatusMarkup.StatusMarkup(string! Variable, string? Maximum = null, string? Caption = null) -> void
+MarkupString.StatusMarkup.Variable.get -> string!
+MarkupString.StatusMarkup.Variable.init -> void
+MarkupString.VariableMarkup
+MarkupString.VariableMarkup.<Clone>$() -> MarkupString.VariableMarkup!
+MarkupString.VariableMarkup.Deconstruct(out string! Name) -> void
+MarkupString.VariableMarkup.Equals(MarkupString.VariableMarkup? other) -> bool
+MarkupString.VariableMarkup.Name.get -> string!
+MarkupString.VariableMarkup.Name.init -> void
+MarkupString.VariableMarkup.VariableMarkup(string! Name) -> void
+override MarkupString.ExpireLinksMarkup.Equals(object? obj) -> bool
+override MarkupString.ExpireLinksMarkup.GetHashCode() -> int
+override MarkupString.ExpireLinksMarkup.ToString() -> string!
+override MarkupString.GaugeMarkup.Equals(object? obj) -> bool
+override MarkupString.GaugeMarkup.GetHashCode() -> int
+override MarkupString.GaugeMarkup.ToString() -> string!
+override MarkupString.ImageMarkup.Equals(object? obj) -> bool
+override MarkupString.ImageMarkup.GetHashCode() -> int
+override MarkupString.ImageMarkup.ToString() -> string!
+override MarkupString.LoginPromptMarkup.Equals(object? obj) -> bool
+override MarkupString.LoginPromptMarkup.GetHashCode() -> int
+override MarkupString.LoginPromptMarkup.ToString() -> string!
+override MarkupString.PaneMarkup.Equals(object? obj) -> bool
+override MarkupString.PaneMarkup.GetHashCode() -> int
+override MarkupString.PaneMarkup.ToString() -> string!
+override MarkupString.PrefetchMarkup.Equals(object? obj) -> bool
+override MarkupString.PrefetchMarkup.GetHashCode() -> int
+override MarkupString.PrefetchMarkup.ToString() -> string!
+override MarkupString.RelocateMarkup.Equals(object? obj) -> bool
+override MarkupString.RelocateMarkup.GetHashCode() -> int
+override MarkupString.RelocateMarkup.ToString() -> string!
+override MarkupString.SoundMarkup.Equals(object? obj) -> bool
+override MarkupString.SoundMarkup.GetHashCode() -> int
+override MarkupString.SoundMarkup.ToString() -> string!
+override MarkupString.SoundStopMarkup.Equals(object? obj) -> bool
+override MarkupString.SoundStopMarkup.GetHashCode() -> int
+override MarkupString.SoundStopMarkup.ToString() -> string!
+override MarkupString.StatusMarkup.Equals(object? obj) -> bool
+override MarkupString.StatusMarkup.GetHashCode() -> int
+override MarkupString.StatusMarkup.ToString() -> string!
+override MarkupString.VariableMarkup.Equals(object? obj) -> bool
+override MarkupString.VariableMarkup.GetHashCode() -> int
+override MarkupString.VariableMarkup.ToString() -> string!
+static MarkupString.ExpireLinksMarkup.operator !=(MarkupString.ExpireLinksMarkup? left, MarkupString.ExpireLinksMarkup? right) -> bool
+static MarkupString.ExpireLinksMarkup.operator ==(MarkupString.ExpireLinksMarkup? left, MarkupString.ExpireLinksMarkup? right) -> bool
+static MarkupString.GaugeMarkup.operator !=(MarkupString.GaugeMarkup? left, MarkupString.GaugeMarkup? right) -> bool
+static MarkupString.GaugeMarkup.operator ==(MarkupString.GaugeMarkup? left, MarkupString.GaugeMarkup? right) -> bool
+static MarkupString.ImageMarkup.operator !=(MarkupString.ImageMarkup? left, MarkupString.ImageMarkup? right) -> bool
+static MarkupString.ImageMarkup.operator ==(MarkupString.ImageMarkup? left, MarkupString.ImageMarkup? right) -> bool
+static MarkupString.LoginPromptMarkup.operator !=(MarkupString.LoginPromptMarkup? left, MarkupString.LoginPromptMarkup? right) -> bool
+static MarkupString.LoginPromptMarkup.operator ==(MarkupString.LoginPromptMarkup? left, MarkupString.LoginPromptMarkup? right) -> bool
+static MarkupString.MarkupText.ClearScreen() -> MarkupString.MarkupText!
+static MarkupString.MarkupText.ExpireLinks(string? group = null) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.Gauge(MarkupString.MarkupText! content, string! variable, string! maximum, string? caption = null, string? color = null) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.Image(string! source, string? description = null, int? width = null, int? height = null, MarkupString.ImageAlign? align = null) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.LoginPrompt(MarkupString.LoginField field) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.Music(string! source, int? volume = null, int? repeats = null, bool continues = false) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.Pane(MarkupString.MarkupText! content, string! name, string? title = null) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.Point(MarkupString.IPointMarkup! markup) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.Prefetch(string! source) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.Relocate(string! host, int port, bool quiet = false) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.Sound(string! source, int? volume = null, int? repeats = null) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.Status(MarkupString.MarkupText! content, string! variable, string? maximum = null, string? caption = null) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.StopSound(MarkupString.SoundChannel? channel = null) -> MarkupString.MarkupText!
+static MarkupString.MarkupText.Variable(MarkupString.MarkupText! content, string! name) -> MarkupString.MarkupText!
+static MarkupString.PaneMarkup.operator !=(MarkupString.PaneMarkup? left, MarkupString.PaneMarkup? right) -> bool
+static MarkupString.PaneMarkup.operator ==(MarkupString.PaneMarkup? left, MarkupString.PaneMarkup? right) -> bool
+static MarkupString.PrefetchMarkup.operator !=(MarkupString.PrefetchMarkup? left, MarkupString.PrefetchMarkup? right) -> bool
+static MarkupString.PrefetchMarkup.operator ==(MarkupString.PrefetchMarkup? left, MarkupString.PrefetchMarkup? right) -> bool
+static MarkupString.RelocateMarkup.operator !=(MarkupString.RelocateMarkup? left, MarkupString.RelocateMarkup? right) -> bool
+static MarkupString.RelocateMarkup.operator ==(MarkupString.RelocateMarkup? left, MarkupString.RelocateMarkup? right) -> bool
+static MarkupString.SoundMarkup.operator !=(MarkupString.SoundMarkup? left, MarkupString.SoundMarkup? right) -> bool
+static MarkupString.SoundMarkup.operator ==(MarkupString.SoundMarkup? left, MarkupString.SoundMarkup? right) -> bool
+static MarkupString.SoundStopMarkup.operator !=(MarkupString.SoundStopMarkup? left, MarkupString.SoundStopMarkup? right) -> bool
+static MarkupString.SoundStopMarkup.operator ==(MarkupString.SoundStopMarkup? left, MarkupString.SoundStopMarkup? right) -> bool
+static MarkupString.StatusMarkup.operator !=(MarkupString.StatusMarkup? left, MarkupString.StatusMarkup? right) -> bool
+static MarkupString.StatusMarkup.operator ==(MarkupString.StatusMarkup? left, MarkupString.StatusMarkup? right) -> bool
+static MarkupString.VariableMarkup.operator !=(MarkupString.VariableMarkup? left, MarkupString.VariableMarkup? right) -> bool
+static MarkupString.VariableMarkup.operator ==(MarkupString.VariableMarkup? left, MarkupString.VariableMarkup? right) -> bool
+static readonly MarkupString.ClearScreenMarkup.Instance -> MarkupString.ClearScreenMarkup!
+const MarkupString.MarkupText.PointCarrier = "​" -> string!
diff --git a/README.md b/README.md
index ca911d8..7bd1cb5 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,8 @@
 [![MarkupString](https://img.shields.io/nuget/v/MarkupString?label=MarkupString)](https://www.nuget.org/packages/MarkupString)
 [![MarkupString.Ansi](https://img.shields.io/nuget/v/MarkupString.Ansi?label=MarkupString.Ansi)](https://www.nuget.org/packages/MarkupString.Ansi)
 [![MarkupString.Html](https://img.shields.io/nuget/v/MarkupString.Html?label=MarkupString.Html)](https://www.nuget.org/packages/MarkupString.Html)
+[![MarkupString.Mxp](https://img.shields.io/nuget/v/MarkupString.Mxp?label=MarkupString.Mxp)](https://www.nuget.org/packages/MarkupString.Mxp)
+[![MarkupString.Pueblo](https://img.shields.io/nuget/v/MarkupString.Pueblo?label=MarkupString.Pueblo)](https://www.nuget.org/packages/MarkupString.Pueblo)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 
 **Immutable styled text for terminals and the web.** One value — a plain string plus layered
@@ -31,13 +33,17 @@ layout engine: wrap, justify, fill, and assemble columns into aligned rows.
 dotnet add package MarkupString
 dotnet add package MarkupString.Ansi
 dotnet add package MarkupString.Html
+dotnet add package MarkupString.Mxp
+dotnet add package MarkupString.Pueblo
 ```
 
 | Package | What it gives you |
 |---|---|
-| [`MarkupString`](https://www.nuget.org/packages/MarkupString) | The `MarkupText` type, runs, formats, the registry, the emitter/codec contracts, the JSON serializer, grapheme and display-width helpers. No rendering opinions. |
+| [`MarkupString`](https://www.nuget.org/packages/MarkupString) | The `MarkupText` type, runs, formats, the registry, the emitter/codec contracts, the JSON serializer, grapheme and display-width helpers, and the shared vocabulary — sounds, pictures, panes, gauges — that the format packages write. No rendering opinions. |
 | [`MarkupString.Ansi`](https://www.nuget.org/packages/MarkupString.Ansi) | Terminal styling: colours (16 / xterm-256 / truecolor), attributes, links; an `ansi()` code parser and an escape-sequence parser; emitters for ANSI, HTML, Pueblo, MXP and BBCode; and `AnsiCss`, the stylesheet for the `ms-*` classes the HTML emitters write. |
-| [`MarkupString.Html`](https://www.nuget.org/packages/MarkupString.Html) | Raw HTML tag markup — an anchor, a `<pre>`, a `<span class>` — with checked construction and tag policies for untrusted input. |
+| [`MarkupString.Html`](https://www.nuget.org/packages/MarkupString.Html) | Raw HTML tag markup — an anchor, a `<pre>`, a `<span class>` — with checked construction and tag policies for untrusted input; the shared vocabulary for a browser. |
+| [`MarkupString.Mxp`](https://www.nuget.org/packages/MarkupString.Mxp) | The shared vocabulary as MXP's elements, held to what the client said it supports. |
+| [`MarkupString.Pueblo`](https://www.nuget.org/packages/MarkupString.Pueblo) | The shared vocabulary in the Pueblo client's own extensions. |
 
 The core package renders nothing on its own: emitters live in the kind packages, so a consumer
 that only needs one of them pays for one of them, and a kind of your own is a first-class peer
@@ -49,9 +55,11 @@ rather than a fork.
 using MarkupString;
 using MarkupString.Ansi;
 using MarkupString.Html;
+using MarkupString.Mxp;
+using MarkupString.Pueblo;
 
 // Once, at startup. Set-once: a second, different registry throws.
-MarkupRegistry.Default = MarkupRegistry.Empty.WithAnsi().WithHtml();
+MarkupRegistry.Default = MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp().WithPueblo();
 
 // A command link: each format writes it in its own dialect — <A XCH_CMD> for Pueblo,
 // <SEND HREF> for MXP, a clickable anchor for HTML — and a terminal shows the text.
@@ -60,6 +68,12 @@ var prompt = MarkupText.Wrap(
   MarkupText.Wrap(AnsiCodeParser.Parse("hc"), "Go north"));
 
 Console.WriteLine(prompt.Render(MarkupFormat.Ansi));
+
+// A sound and a picture, said once. MXP gets <SOUND> and <IMAGE>, Pueblo its xch_ tags, a browser
+// <audio> and <img>, and a terminal the picture's description.
+var entrance = MarkupText.Concat([
+  MarkupText.Sound("door.wav"),
+  MarkupText.Image("gate.png", "An iron gate")]);
 ```
 
 Columns, wrapping and justification come from the same value:
@@ -85,7 +99,7 @@ TextLayout.Rows(
 | [Getting started](docs/getting-started.md) | Install, wire up the registry, build and render your first styled text. |
 | [Text operations](docs/text-operations.md) | Slicing, padding, alignment, splitting, splicing — and the grapheme and display-width rules they obey. |
 | [Layout](docs/layout.md) | Wrapping, justification, fills as patterns, and assembling columns into rows. |
-| [Formats and rendering](docs/formats.md) | The six built-in formats, what each emits, how Pueblo and MXP differ, framers and line framers, untrusted tags, custom formats. |
+| [Formats and rendering](docs/formats.md) | The six built-in formats, what each emits, the shared vocabulary, how Pueblo and MXP differ, framers and line framers, untrusted tags, custom formats. |
 | [Custom markup kinds](docs/custom-markup.md) | Write your own `IMarkup`, emitters and codec; compose with the kinds already registered. |
 | [Serialization](docs/serialization.md) | The JSON wire format, forward compatibility, `UnknownMarkup`. |
 | [Releasing](docs/releasing.md) | How a version is cut and published (maintainers). |
diff --git a/docs/formats.md b/docs/formats.md
index 1ee5094..3099519 100644
--- a/docs/formats.md
+++ b/docs/formats.md
@@ -37,7 +37,8 @@ link.Render(MarkupFormat.Plain);   // north
 ```
 
 A format nothing knows how to write is not an error: the layer is skipped and its body still comes
-out. Text never disappears because a kind had no emitter.
+out. Text never disappears because a kind had no emitter. The one exception is a point
+([below](#points)), which is not text and so leaves nothing.
 
 ## A bell
 
@@ -57,6 +58,60 @@ concatenation carry it without shifting a column. The text encodings drop contro
 is the only way one reaches rendered output; what the HTML element means — a sound, a flash, a title
 change, nothing — is the page's to decide.
 
+## The shared vocabulary
+
+Sounds, pictures, panes and the rest are things a game says once. Their types are core's and say what
+a thing is; each format's package says how that format writes it — or what it stands in for it.
+
+```csharp
+MarkupRegistry.Default = MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp().WithPueblo();
+
+var line = MarkupText.Concat([
+  MarkupText.Sound("door.wav"),
+  MarkupText.Image("map.png", "A map of the city"),
+  MarkupText.Plain(" The door creaks.")]);
+
+line.Render(MarkupFormat.Mxp);     // <SOUND door.wav><IMAGE map.png> The door creaks.
+line.Render(MarkupFormat.Pueblo);  // <img xch_sound="play" href="door.wav"><img src="map.png" alt="A map of the city"> The door creaks.
+line.Render(MarkupFormat.Html);    // <audio class="ms-sound" …></audio><img class="ms-image" src="map.png" alt="A map of the city"> The door creaks.
+line.Render(MarkupFormat.Ansi);    // A map of the city The door creaks.
+```
+
+| Factory | MXP (`WithMxp`) | Pueblo (`WithPueblo`) | HTML (`WithHtml`) | ANSI / BBCode (`WithAnsi`) and Plain |
+|---|---|---|---|---|
+| `Sound`, `Music` | `<SOUND>`, `<MUSIC>` | `<img xch_sound="play">`, or `"loop"` | `<audio preload="none">` | nothing |
+| `StopSound` | `<SOUND Off>` / `<MUSIC Off>` | `<img xch_sound="stop" xch_device>` | `ms-sound-stop` | nothing |
+| `Image` | `<IMAGE>` | `<img>` | `<img>` | the description, or the address; BBCode `[img]` |
+| `Pane` | `<FRAME name><DEST name>…</DEST>` | `<xch_pane action="redirect">…` and back to `_previous` | `ms-pane` around the text | the text |
+| `ClearScreen` | nothing | `<xch_page clear="text">` | `ms-clear` | ANSI `ESC[H ESC[2J` |
+| `Prefetch` | nothing | `<xch_prefetch href xch_prob>` | `<link rel="prefetch">` | nothing |
+| `ExpireLinks` | `<EXPIRE>` | nothing | `ms-expire` | nothing |
+| `Variable`, `Gauge`, `Status` | `<VAR>`, `<GAUGE>`, `<STAT>` | the text | `ms-variable`, `ms-gauge`, `ms-status` around the text | the text |
+| `Relocate`, `LoginPrompt` | `<RELOCATE>`, `<USER>` / `<PASSWORD>` | nothing | nothing | nothing |
+| `Bell` | U+0007 | U+0007 | `ms-bell` | ANSI U+0007 |
+
+An `ms-` element is a hook: the page decides what a clear, a pane or a gauge looks like. Addresses are
+written as given — whether a page fetches or plays one is its own policy, not this library's.
+
+A link is already part of this vocabulary: `AnsiMarkup` with a `LinkKind` is written as each dialect
+spells a link, so a picture inside a link is a clickable picture everywhere.
+
+### Points
+
+A sound, a bell or a clear stands at a point rather than marking text. It implements `IPointMarkup` and
+rides on a carrier — `MarkupText.PointCarrier`, a zero-width space, or the bell's own U+0007 — so it
+keeps its position through slicing, concatenation and padding and measures nothing. The carrier is not
+text: `ToPlainText()`, `ToString()` and equality leave it out, and the renderer never writes it. A
+format with an emitter for the point writes the point; a format with none writes nothing, not even the
+styling around it. `MarkupText.Point(markup)` makes a point of your own.
+
+### What an MXP client said it supports
+
+MXP asks a client which elements it can render with `<SUPPORT>`, and a client that answered `-image`
+should not be sent one. `WithMxp(supports)` takes the answer as a predicate over the element names in
+`MxpRegistration.Elements`; an element it refuses is written as if the format had no MXP. Asking is the
+telnet layer's job, and the answer belongs to one connection, so build a registry per answer.
+
 ## Pueblo and MXP
 
 Pueblo and MXP are two different dialects, not one extending the other. Most formatting tags are
@@ -72,6 +127,8 @@ So:
 
 - Build a link with `AnsiMarkup.Create(linkUrl: ..., linkKind: ...)`, never with an `HtmlMarkup`
   that spells one dialect's tag. The Ansi package writes the link each format's own way.
+- Build a sound, a picture or a pane from [the shared vocabulary](#the-shared-vocabulary), never from
+  one dialect's tag.
 - Keep `HtmlMarkup` for tags the formats spell alike — `b`, `i`, `pre`, `font`, `a href`. It is
   written unchanged in `Html`, `Pueblo` and `Mxp`.
 - Render MXP for a live connection through a registry with `WithMxpSecureLines()`, so every line
diff --git a/docs/releasing.md b/docs/releasing.md
index 43325e1..d7026da 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -78,12 +78,14 @@ policy names *this* repository — a policy for another repository will not do:
    actually presents — check the owner, repository and workflow filename before anything else.
 
 Package IDs `MarkupString`, `MarkupString.Ansi` and `MarkupString.Html` were unregistered when this
-repository was set up; the first successful push claims them.
+repository was set up; the first successful push claims them. `MarkupString.Mxp` and
+`MarkupString.Pueblo` are claimed the same way by the first release that carries them, under the same
+policy.
 
 ## Checklist
 
 - [ ] `CHANGELOG.md` updated and merged to `main`
-- [ ] `PublicAPI.Unshipped.txt` promoted to `PublicAPI.Shipped.txt` in all three packages
+- [ ] `PublicAPI.Unshipped.txt` promoted to `PublicAPI.Shipped.txt` in every package
 - [ ] Trusted publishing policy exists on nuget.org for `SharpMUSH/MarkupString` (first release only)
 - [ ] Tag pushed, `Release` workflow green
-- [ ] `PackageValidationBaselineVersion` raised to the version just published
+- [ ] `PackageValidationBaselineVersion` raised to the version just published (and added to a package on its first release)

From 90942d2f1e618f22c484df7585d2be937c89057a Mon Sep 17 00:00:00 2001
From: Harry Cordewener <admin@twilightdays.org>
Date: Tue, 22 Sep 2026 11:26:53 -0500
Subject: [PATCH 2/4] Finish the 2.2.0 release checklist: promote its API to
 Shipped, validate against it

2.2.0 is on nuget.org, but its public API was still listed as unshipped and
package validation still diffed against 2.1.0.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 MarkupString.Ansi/MarkupString.Ansi.csproj |  2 +-
 MarkupString.Html/MarkupString.Html.csproj |  2 +-
 MarkupString.Html/PublicAPI.Shipped.txt    | 45 ++++++++++++++++++++++
 MarkupString.Html/PublicAPI.Unshipped.txt  | 45 ----------------------
 MarkupString/MarkupString.csproj           |  2 +-
 MarkupString/PublicAPI.Shipped.txt         | 11 ++++++
 MarkupString/PublicAPI.Unshipped.txt       | 11 ------
 7 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/MarkupString.Ansi/MarkupString.Ansi.csproj b/MarkupString.Ansi/MarkupString.Ansi.csproj
index af3aef4..15a5678 100644
--- a/MarkupString.Ansi/MarkupString.Ansi.csproj
+++ b/MarkupString.Ansi/MarkupString.Ansi.csproj
@@ -12,7 +12,7 @@
          each time one goes out; drop it for a release that removes public API on purpose, and put
          it back straight after. -->
     <EnablePackageValidation>true</EnablePackageValidation>
-    <PackageValidationBaselineVersion>2.1.0</PackageValidationBaselineVersion>
+    <PackageValidationBaselineVersion>2.2.0</PackageValidationBaselineVersion>
     <Description>Terminal styling for MarkupString: colours (16, 256 and truecolor), text attributes and links, an ansi() code parser, and emitters that fold a run's layers into one SGR sequence, HTML span, Pueblo/MXP tag or BBCode tag.</Description>
   </PropertyGroup>
 
diff --git a/MarkupString.Html/MarkupString.Html.csproj b/MarkupString.Html/MarkupString.Html.csproj
index 2d89c0a..b43f0b4 100644
--- a/MarkupString.Html/MarkupString.Html.csproj
+++ b/MarkupString.Html/MarkupString.Html.csproj
@@ -12,7 +12,7 @@
          each time one goes out; drop it for a release that removes public API on purpose, and put
          it back straight after. -->
     <EnablePackageValidation>true</EnablePackageValidation>
-    <PackageValidationBaselineVersion>2.1.0</PackageValidationBaselineVersion>
+    <PackageValidationBaselineVersion>2.2.0</PackageValidationBaselineVersion>
     <Description>Raw HTML tag markup for MarkupString — an anchor, a pre, a span — rendered as itself in the HTML, Pueblo and MXP formats and folded into terminal styling elsewhere, with checked construction and tag policies for untrusted input.</Description>
   </PropertyGroup>
 
diff --git a/MarkupString.Html/PublicAPI.Shipped.txt b/MarkupString.Html/PublicAPI.Shipped.txt
index ed3d6db..56e9c3e 100644
--- a/MarkupString.Html/PublicAPI.Shipped.txt
+++ b/MarkupString.Html/PublicAPI.Shipped.txt
@@ -1,4 +1,16 @@
 #nullable enable
+MarkupString.Html.HtmlAttribute
+MarkupString.Html.HtmlAttribute.Deconstruct(out string! Name, out string! Value) -> void
+MarkupString.Html.HtmlAttribute.Equals(MarkupString.Html.HtmlAttribute other) -> bool
+MarkupString.Html.HtmlAttribute.HtmlAttribute() -> void
+MarkupString.Html.HtmlAttribute.HtmlAttribute(string! Name, string! Value) -> void
+MarkupString.Html.HtmlAttribute.Name.get -> string!
+MarkupString.Html.HtmlAttribute.Name.init -> void
+MarkupString.Html.HtmlAttribute.Value.get -> string!
+MarkupString.Html.HtmlAttribute.Value.init -> void
+MarkupString.Html.HtmlAttributeViolation
+MarkupString.Html.HtmlAttributeViolation.DropAllAttributes = 1 -> MarkupString.Html.HtmlAttributeViolation
+MarkupString.Html.HtmlAttributeViolation.DropAttribute = 0 -> MarkupString.Html.HtmlAttributeViolation
 MarkupString.Html.HtmlMarkup
 MarkupString.Html.HtmlMarkup.<Clone>$() -> MarkupString.Html.HtmlMarkup!
 MarkupString.Html.HtmlMarkup.Attributes.get -> string?
@@ -20,11 +32,44 @@ MarkupString.Html.HtmlTagEmitter
 MarkupString.Html.HtmlTagEmitter.Emit(MarkupString.IMarkup! markup, System.ReadOnlySpan<char> body, in MarkupString.EmitContext context, System.Buffers.IBufferWriter<char>! output) -> void
 MarkupString.Html.HtmlTagEmitter.Format.get -> MarkupString.MarkupFormat!
 MarkupString.Html.HtmlTagEmitter.HtmlTagEmitter(MarkupString.MarkupFormat! format) -> void
+MarkupString.Html.HtmlTagEmitter.HtmlTagEmitter(MarkupString.MarkupFormat! format, MarkupString.Html.HtmlTagPolicy? policy) -> void
 MarkupString.Html.HtmlTagEmitter.MarkupType.get -> System.Type!
+MarkupString.Html.HtmlTagEmitter.Policy.get -> MarkupString.Html.HtmlTagPolicy?
+MarkupString.Html.HtmlTagPolicy
+MarkupString.Html.HtmlTagPolicy.<Clone>$() -> MarkupString.Html.HtmlTagPolicy!
+MarkupString.Html.HtmlTagPolicy.AllowedAttributes.get -> System.Collections.Generic.IReadOnlySet<string!>?
+MarkupString.Html.HtmlTagPolicy.AllowedAttributes.init -> void
+MarkupString.Html.HtmlTagPolicy.AllowedTags.get -> System.Collections.Generic.IReadOnlySet<string!>?
+MarkupString.Html.HtmlTagPolicy.AllowedTags.init -> void
+MarkupString.Html.HtmlTagPolicy.Apply(MarkupString.Html.HtmlMarkup! markup) -> MarkupString.Html.HtmlMarkup?
+MarkupString.Html.HtmlTagPolicy.Equals(MarkupString.Html.HtmlTagPolicy? other) -> bool
+MarkupString.Html.HtmlTagPolicy.HtmlTagPolicy() -> void
+MarkupString.Html.HtmlTagPolicy.OnViolation.get -> MarkupString.Html.HtmlAttributeViolation
+MarkupString.Html.HtmlTagPolicy.OnViolation.init -> void
+MarkupString.Html.HtmlTagPolicy.TryCreate(string! tagName, string? attributes, out MarkupString.Html.HtmlMarkup? markup) -> bool
+MarkupString.Html.HtmlTagPolicy.UrlAttributes.get -> System.Collections.Generic.IReadOnlySet<string!>!
+MarkupString.Html.HtmlTagPolicy.UrlAttributes.init -> void
+override MarkupString.Html.HtmlAttribute.GetHashCode() -> int
+override MarkupString.Html.HtmlAttribute.ToString() -> string!
 override MarkupString.Html.HtmlMarkup.Equals(object? obj) -> bool
 override MarkupString.Html.HtmlMarkup.GetHashCode() -> int
 override MarkupString.Html.HtmlMarkup.ToString() -> string!
+override MarkupString.Html.HtmlTagPolicy.Equals(object? obj) -> bool
+override MarkupString.Html.HtmlTagPolicy.GetHashCode() -> int
+override MarkupString.Html.HtmlTagPolicy.ToString() -> string!
+static MarkupString.Html.HtmlAttribute.operator !=(MarkupString.Html.HtmlAttribute left, MarkupString.Html.HtmlAttribute right) -> bool
+static MarkupString.Html.HtmlAttribute.operator ==(MarkupString.Html.HtmlAttribute left, MarkupString.Html.HtmlAttribute right) -> bool
 static MarkupString.Html.HtmlMarkup.Create(string! tagName, string? attributes = null) -> MarkupString.Html.HtmlMarkup!
+static MarkupString.Html.HtmlMarkup.IsValidAttributeName(System.ReadOnlySpan<char> name) -> bool
+static MarkupString.Html.HtmlMarkup.IsValidTagName(System.ReadOnlySpan<char> name) -> bool
+static MarkupString.Html.HtmlMarkup.Tag(string! tagName, params System.ReadOnlySpan<MarkupString.Html.HtmlAttribute> attributes) -> MarkupString.Html.HtmlMarkup!
+static MarkupString.Html.HtmlMarkup.TryParseAttributes(string? attributes, out System.Collections.Generic.IReadOnlyList<MarkupString.Html.HtmlAttribute>! parsed) -> bool
 static MarkupString.Html.HtmlMarkup.operator !=(MarkupString.Html.HtmlMarkup? left, MarkupString.Html.HtmlMarkup? right) -> bool
 static MarkupString.Html.HtmlMarkup.operator ==(MarkupString.Html.HtmlMarkup? left, MarkupString.Html.HtmlMarkup? right) -> bool
 static MarkupString.Html.HtmlRegistration.WithHtml(this MarkupString.MarkupRegistry! registry) -> MarkupString.MarkupRegistry!
+static MarkupString.Html.HtmlRegistration.WithHtml(this MarkupString.MarkupRegistry! registry, MarkupString.Html.HtmlTagPolicy! htmlPolicy) -> MarkupString.MarkupRegistry!
+static MarkupString.Html.HtmlTagPolicy.AddressAttributes.get -> System.Collections.Generic.IReadOnlySet<string!>!
+static MarkupString.Html.HtmlTagPolicy.WellFormed.get -> MarkupString.Html.HtmlTagPolicy!
+static MarkupString.Html.HtmlTagPolicy.operator !=(MarkupString.Html.HtmlTagPolicy? left, MarkupString.Html.HtmlTagPolicy? right) -> bool
+static MarkupString.Html.HtmlTagPolicy.operator ==(MarkupString.Html.HtmlTagPolicy? left, MarkupString.Html.HtmlTagPolicy? right) -> bool
+~override MarkupString.Html.HtmlAttribute.Equals(object obj) -> bool
diff --git a/MarkupString.Html/PublicAPI.Unshipped.txt b/MarkupString.Html/PublicAPI.Unshipped.txt
index 7ec7cbd..7dc5c58 100644
--- a/MarkupString.Html/PublicAPI.Unshipped.txt
+++ b/MarkupString.Html/PublicAPI.Unshipped.txt
@@ -1,46 +1 @@
 #nullable enable
-MarkupString.Html.HtmlAttribute
-MarkupString.Html.HtmlAttribute.Deconstruct(out string! Name, out string! Value) -> void
-MarkupString.Html.HtmlAttribute.Equals(MarkupString.Html.HtmlAttribute other) -> bool
-MarkupString.Html.HtmlAttribute.HtmlAttribute(string! Name, string! Value) -> void
-MarkupString.Html.HtmlAttribute.HtmlAttribute() -> void
-MarkupString.Html.HtmlAttribute.Name.get -> string!
-MarkupString.Html.HtmlAttribute.Name.init -> void
-MarkupString.Html.HtmlAttribute.Value.get -> string!
-MarkupString.Html.HtmlAttribute.Value.init -> void
-MarkupString.Html.HtmlAttributeViolation
-MarkupString.Html.HtmlAttributeViolation.DropAllAttributes = 1 -> MarkupString.Html.HtmlAttributeViolation
-MarkupString.Html.HtmlAttributeViolation.DropAttribute = 0 -> MarkupString.Html.HtmlAttributeViolation
-MarkupString.Html.HtmlTagEmitter.HtmlTagEmitter(MarkupString.MarkupFormat! format, MarkupString.Html.HtmlTagPolicy? policy) -> void
-MarkupString.Html.HtmlTagEmitter.Policy.get -> MarkupString.Html.HtmlTagPolicy?
-MarkupString.Html.HtmlTagPolicy
-MarkupString.Html.HtmlTagPolicy.AllowedAttributes.get -> System.Collections.Generic.IReadOnlySet<string!>?
-MarkupString.Html.HtmlTagPolicy.AllowedAttributes.init -> void
-MarkupString.Html.HtmlTagPolicy.AllowedTags.get -> System.Collections.Generic.IReadOnlySet<string!>?
-MarkupString.Html.HtmlTagPolicy.AllowedTags.init -> void
-MarkupString.Html.HtmlTagPolicy.Apply(MarkupString.Html.HtmlMarkup! markup) -> MarkupString.Html.HtmlMarkup?
-MarkupString.Html.HtmlTagPolicy.<Clone>$() -> MarkupString.Html.HtmlTagPolicy!
-MarkupString.Html.HtmlTagPolicy.Equals(MarkupString.Html.HtmlTagPolicy? other) -> bool
-MarkupString.Html.HtmlTagPolicy.HtmlTagPolicy() -> void
-MarkupString.Html.HtmlTagPolicy.OnViolation.get -> MarkupString.Html.HtmlAttributeViolation
-MarkupString.Html.HtmlTagPolicy.OnViolation.init -> void
-MarkupString.Html.HtmlTagPolicy.TryCreate(string! tagName, string? attributes, out MarkupString.Html.HtmlMarkup? markup) -> bool
-MarkupString.Html.HtmlTagPolicy.UrlAttributes.get -> System.Collections.Generic.IReadOnlySet<string!>!
-MarkupString.Html.HtmlTagPolicy.UrlAttributes.init -> void
-~override MarkupString.Html.HtmlAttribute.Equals(object obj) -> bool
-override MarkupString.Html.HtmlAttribute.GetHashCode() -> int
-override MarkupString.Html.HtmlAttribute.ToString() -> string!
-override MarkupString.Html.HtmlTagPolicy.Equals(object? obj) -> bool
-override MarkupString.Html.HtmlTagPolicy.GetHashCode() -> int
-override MarkupString.Html.HtmlTagPolicy.ToString() -> string!
-static MarkupString.Html.HtmlAttribute.operator !=(MarkupString.Html.HtmlAttribute left, MarkupString.Html.HtmlAttribute right) -> bool
-static MarkupString.Html.HtmlAttribute.operator ==(MarkupString.Html.HtmlAttribute left, MarkupString.Html.HtmlAttribute right) -> bool
-static MarkupString.Html.HtmlMarkup.IsValidAttributeName(System.ReadOnlySpan<char> name) -> bool
-static MarkupString.Html.HtmlMarkup.IsValidTagName(System.ReadOnlySpan<char> name) -> bool
-static MarkupString.Html.HtmlMarkup.Tag(string! tagName, params System.ReadOnlySpan<MarkupString.Html.HtmlAttribute> attributes) -> MarkupString.Html.HtmlMarkup!
-static MarkupString.Html.HtmlMarkup.TryParseAttributes(string? attributes, out System.Collections.Generic.IReadOnlyList<MarkupString.Html.HtmlAttribute>! parsed) -> bool
-static MarkupString.Html.HtmlRegistration.WithHtml(this MarkupString.MarkupRegistry! registry, MarkupString.Html.HtmlTagPolicy! htmlPolicy) -> MarkupString.MarkupRegistry!
-static MarkupString.Html.HtmlTagPolicy.AddressAttributes.get -> System.Collections.Generic.IReadOnlySet<string!>!
-static MarkupString.Html.HtmlTagPolicy.operator !=(MarkupString.Html.HtmlTagPolicy? left, MarkupString.Html.HtmlTagPolicy? right) -> bool
-static MarkupString.Html.HtmlTagPolicy.operator ==(MarkupString.Html.HtmlTagPolicy? left, MarkupString.Html.HtmlTagPolicy? right) -> bool
-static MarkupString.Html.HtmlTagPolicy.WellFormed.get -> MarkupString.Html.HtmlTagPolicy!
diff --git a/MarkupString/MarkupString.csproj b/MarkupString/MarkupString.csproj
index ee3f443..296fea3 100644
--- a/MarkupString/MarkupString.csproj
+++ b/MarkupString/MarkupString.csproj
@@ -12,7 +12,7 @@
          each time one goes out; drop it for a release that removes public API on purpose, and put
          it back straight after. -->
     <EnablePackageValidation>true</EnablePackageValidation>
-    <PackageValidationBaselineVersion>2.1.0</PackageValidationBaselineVersion>
+    <PackageValidationBaselineVersion>2.2.0</PackageValidationBaselineVersion>
     <Description>Immutable styled text: a string plus layered markup runs, rendered to ANSI, HTML, Pueblo, MXP, BBCode or plain text through a registry of emitters, and round-tripped through JSON.</Description>
   </PropertyGroup>
 
diff --git a/MarkupString/PublicAPI.Shipped.txt b/MarkupString/PublicAPI.Shipped.txt
index f89c223..864a723 100644
--- a/MarkupString/PublicAPI.Shipped.txt
+++ b/MarkupString/PublicAPI.Shipped.txt
@@ -36,6 +36,9 @@ MarkupString.IFormatFramer
 MarkupString.IFormatFramer.Format.get -> MarkupString.MarkupFormat!
 MarkupString.IFormatFramer.WriteEpilogue(bool anyRunEmitted, System.Buffers.IBufferWriter<char>! output) -> void
 MarkupString.IFormatFramer.WritePreamble(System.Buffers.IBufferWriter<char>! output) -> void
+MarkupString.ILineFramer
+MarkupString.ILineFramer.Format.get -> MarkupString.MarkupFormat!
+MarkupString.ILineFramer.WriteLineStart(System.Buffers.IBufferWriter<char>! output) -> void
 MarkupString.IMarkup
 MarkupString.IMarkupCodec
 MarkupString.IMarkupCodec.Kind.get -> string!
@@ -184,11 +187,14 @@ MarkupString.MarkupRegistry.FindCodec(System.Type! markupType) -> MarkupString.I
 MarkupString.MarkupRegistry.FindCodec(string! kind) -> MarkupString.IMarkupCodec?
 MarkupString.MarkupRegistry.FindEmitter(System.Type! markupType, MarkupString.MarkupFormat! format) -> MarkupString.IMarkupEmitter?
 MarkupString.MarkupRegistry.FindFramer(MarkupString.MarkupFormat! format) -> MarkupString.IFormatFramer?
+MarkupString.MarkupRegistry.FindLineFramer(MarkupString.MarkupFormat! format) -> MarkupString.ILineFramer?
 MarkupString.MarkupRegistry.FindSetEmitter(MarkupString.MarkupFormat! format) -> MarkupString.IMarkupSetEmitter?
 MarkupString.MarkupRegistry.With(MarkupString.IFormatFramer! framer) -> MarkupString.MarkupRegistry!
+MarkupString.MarkupRegistry.With(MarkupString.ILineFramer! framer) -> MarkupString.MarkupRegistry!
 MarkupString.MarkupRegistry.With(MarkupString.IMarkupCodec! codec) -> MarkupString.MarkupRegistry!
 MarkupString.MarkupRegistry.With(MarkupString.IMarkupEmitter! emitter) -> MarkupString.MarkupRegistry!
 MarkupString.MarkupRegistry.With(MarkupString.IMarkupSetEmitter! emitter) -> MarkupString.MarkupRegistry!
+MarkupString.MarkupRegistry.WithMxpSecureLines() -> MarkupString.MarkupRegistry!
 MarkupString.MarkupSet
 MarkupString.MarkupSet.Append(MarkupString.IMarkup! outer) -> MarkupString.MarkupSet!
 MarkupString.MarkupSet.Count.get -> int
@@ -241,6 +247,9 @@ MarkupString.MarkupText.WrapLines(int width) -> MarkupString.MarkupText![]!
 MarkupString.MarkupText.WrapLines(int width, MarkupString.Layout.WrapMode mode) -> MarkupString.MarkupText![]!
 MarkupString.MarkupTextRenderer
 MarkupString.MarkupTextSerializer
+MarkupString.MxpSecureLineFramer
+MarkupString.MxpSecureLineFramer.Format.get -> MarkupString.MarkupFormat!
+MarkupString.MxpSecureLineFramer.WriteLineStart(System.Buffers.IBufferWriter<char>! output) -> void
 MarkupString.NeutralMarkup
 MarkupString.NeutralMarkup.NeutralMarkup() -> void
 MarkupString.PadType
@@ -281,6 +290,7 @@ MarkupString.UnknownMarkup.RawJson.get -> string!
 MarkupString.UnknownMarkup.RawJson.init -> void
 MarkupString.UnknownMarkup.UnknownMarkup(string! Kind, string! RawJson) -> void
 abstract MarkupString.Layout.LayoutCell.<Clone>$() -> MarkupString.Layout.LayoutCell!
+const MarkupString.MxpSecureLineFramer.SecureLine = "\u001b[1z" -> string!
 override MarkupString.Edit.GetHashCode() -> int
 override MarkupString.Layout.ColumnFormat.Equals(object? obj) -> bool
 override MarkupString.Layout.ColumnFormat.GetHashCode() -> int
@@ -388,6 +398,7 @@ static readonly MarkupString.MarkupRegistry.Empty -> MarkupString.MarkupRegistry
 static readonly MarkupString.MarkupText.Empty -> MarkupString.MarkupText!
 static readonly MarkupString.MarkupText.NewLine -> MarkupString.MarkupText!
 static readonly MarkupString.MarkupText.Space -> MarkupString.MarkupText!
+static readonly MarkupString.MxpSecureLineFramer.Instance -> MarkupString.MxpSecureLineFramer!
 static readonly MarkupString.NeutralMarkup.Instance -> MarkupString.NeutralMarkup!
 virtual MarkupString.Layout.LayoutCell.EqualityContract.get -> System.Type!
 virtual MarkupString.Layout.LayoutCell.Equals(MarkupString.Layout.LayoutCell? other) -> bool
diff --git a/MarkupString/PublicAPI.Unshipped.txt b/MarkupString/PublicAPI.Unshipped.txt
index 64146e4..1ffbe6b 100644
--- a/MarkupString/PublicAPI.Unshipped.txt
+++ b/MarkupString/PublicAPI.Unshipped.txt
@@ -1,15 +1,4 @@
 #nullable enable
-MarkupString.ILineFramer
-MarkupString.ILineFramer.Format.get -> MarkupString.MarkupFormat!
-MarkupString.ILineFramer.WriteLineStart(System.Buffers.IBufferWriter<char>! output) -> void
-MarkupString.MarkupRegistry.FindLineFramer(MarkupString.MarkupFormat! format) -> MarkupString.ILineFramer?
-MarkupString.MarkupRegistry.With(MarkupString.ILineFramer! framer) -> MarkupString.MarkupRegistry!
-const MarkupString.MxpSecureLineFramer.SecureLine = "\u001b[1z" -> string!
-MarkupString.MxpSecureLineFramer
-MarkupString.MxpSecureLineFramer.Format.get -> MarkupString.MarkupFormat!
-MarkupString.MxpSecureLineFramer.WriteLineStart(System.Buffers.IBufferWriter<char>! output) -> void
-static readonly MarkupString.MxpSecureLineFramer.Instance -> MarkupString.MxpSecureLineFramer!
-MarkupString.MarkupRegistry.WithMxpSecureLines() -> MarkupString.MarkupRegistry!
 const MarkupString.BellMarkup.Character = "\a" -> string!
 MarkupString.BellMarkup
 static MarkupString.MarkupText.Bell() -> MarkupString.MarkupText!

From f2d6761cb14bd8ed3686f98e1f99464638b81376 Mon Sep 17 00:00:00 2001
From: Harry Cordewener <admin@twilightdays.org>
Date: Tue, 22 Sep 2026 12:49:08 -0500
Subject: [PATCH 3/4] Review: keep nesting between styled layers, hold these
 elements to the HTML policy

- A layer between two folded layers keeps its place: [bold, tag, red] is a bold
  inside a tag inside a red in HTML, Pueblo, MXP and BBCode, rather than one
  folded bold-red inside the tag. A terminal keeps the flat shape it had, where a
  style is state and the sequence is written once around the run.
- WithHtml(policy) now holds the shared vocabulary's own elements to the policy
  too. A refused element leaves what a format that cannot express it leaves:
  nothing for a point, the text for the rest, so a refused picture keeps its
  description.
- A point marks its carrier and nothing else. Wrap refuses a point over other
  text, which would have swallowed it, and Normalise drops a point that a cover
  puts out of place rather than losing the text under it. The renderer writes
  every point a run carries, once per carrier.
- MarkupRegistry.With(IMarkupCodec) refuses the kinds core writes itself, which
  are read without consulting a registry.
- The docs said three packages; there are five.

Found by CodeRabbit on #18.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  19 +-
 Directory.Build.props                         |   2 +-
 .../Emitters/AnsiBBCodeEmitter.cs             |  49 +++--
 .../Emitters/AnsiEmitterSupport.cs            | 104 ++++++----
 MarkupString.Ansi/Emitters/AnsiHtmlEmitter.cs |  66 +++----
 MarkupString.Ansi/Emitters/AnsiSetEmitter.cs  |   3 -
 .../Emitters/ElementHtmlEmitter.cs            | 178 ++++++++++++------
 MarkupString.Html/HtmlRegistration.cs         |   8 +-
 .../Ansi/AnsiForeignLayerTests.cs             |  56 ++++--
 MarkupString.Tests/SharedVocabularyTests.cs   | 100 +++++++++-
 MarkupString/BellMarkup.cs                    |   3 +
 MarkupString/Elements/ElementCodecs.cs        |   6 +
 MarkupString/IPointMarkup.cs                  |   6 +
 MarkupString/MarkupRegistry.cs                |  11 +-
 MarkupString/MarkupText.Elements.cs           |   4 +-
 MarkupString/MarkupText.cs                    |  95 +++++++++-
 MarkupString/MarkupTextRenderer.cs            |  70 ++++---
 MarkupString/MarkupTextSerializer.cs          |   2 +-
 MarkupString/PublicAPI.Unshipped.txt          |   2 +
 README.md                                     |   4 +-
 docs/formats.md                               |   5 +
 docs/releasing.md                             |   9 +-
 22 files changed, 586 insertions(+), 216 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 580dc0b..a2ae7f1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,9 +30,11 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   a picture that is a link in every dialect. The vocabulary serialises as built-in kinds, so storing it
   needs no package registered.
 - **Points.** `IPointMarkup` is a markup that stands at a point rather than marking text — a sound, a
-  bell, a clear. It rides on `MarkupText.PointCarrier` (a zero-width space; the bell keeps its own
-  U+0007), and `MarkupText.Point(markup)` builds one of your own. A format with no emitter for a point
-  writes nothing at all — not the carrier, and not the layers around it.
+  bell, a clear. It rides on its own `IPointMarkup.Carrier` (a zero-width space, `MarkupText.PointCarrier`;
+  the bell keeps its U+0007), and `MarkupText.Point(markup)` builds one of your own. A format with no
+  emitter for a point writes nothing at all — not the carrier, and not the layers around it. A point
+  marks its carrier and nothing else: `MarkupText.Wrap` refuses one over other text, and a cover read
+  back with a point out of place drops the point and keeps the text.
 - **`MarkupString.Mxp`**, a new package. `WithMxp()` writes the vocabulary as MXP's secure elements.
   `WithMxp(supports)` holds each element to what the client answered to `<SUPPORT>`: one it refused is
   written as a format without MXP writes it — nothing for a sound, the description for a picture, the
@@ -52,11 +54,18 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - **`ToPlainText()`, `ToString()` and equality leave out point carriers.** A sound or a bell is not
   text a reader or a pattern sees: `Concat(Sound(...), Plain("hi"))` equals `Plain("hi")`. `Text`
   still holds the carriers, so positions, slicing and padding are unchanged.
+- **The kinds core serialises itself are reserved.** `MarkupRegistry.With(IMarkupCodec)` refuses a
+  codec claiming `"neutral"` or one of the shared vocabulary's kinds, which are written and read
+  without consulting a registry; a codec registered under one would write text that read back as
+  something else.
 - **A layer from another package nested inside ANSI styling now renders inside it.** The Ansi
   package's set emitters used to wrap every layer they do not own around their own output, whatever
   the nesting: `Wrap(red, Wrap(HtmlMarkup "b", "x"))` gave `<b><span style="color: …">x</span></b>`.
   It now gives `<span style="color: …"><b>x</b></span>`, and a picture inside a command link stays
-  inside the link rather than replacing it. Layers outside the styling still wrap it.
+  inside the link rather than replacing it. A layer *between* two styled layers keeps its place too:
+  `[bold, tag, red]` is a bold inside a tag inside a red, rather than one folded bold-red inside a tag.
+  A terminal is unchanged — a style there is state rather than nesting, so the sequence is still
+  written once around the run.
 
 ## 2.2.0 — 2026-09-19
 
@@ -190,5 +199,5 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   for existing SGR text, a state-diffing `SgrWriter`, and emitters for all six formats.
 - `MarkupString.Html` — `HtmlMarkup` for raw HTML/MXP tags, folding `b`/`i`/`u`/`s` into terminal
   styling through `IAnsiStyleSource`, and `HtmlCss.Fixed` for the `ms-*` classes the emitters write.
-- All three packages are `IsAotCompatible`, with a native-AOT publish in CI that fails on any
+- Every package is `IsAotCompatible`, with a native-AOT publish in CI that fails on any
   trim or AOT warning.
diff --git a/Directory.Build.props b/Directory.Build.props
index 365a297..c1ecd78 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -11,7 +11,7 @@
   </PropertyGroup>
 
   <!--
-    Package metadata that is identical across the three shipping packages. Everything that
+    Package metadata that is identical across the shipping packages. Everything that
     differs per package — PackageId, AssemblyName, Description, project references — stays in
     the project file. Test and smoke projects set IsPackable=false, so these are inert there.
   -->
diff --git a/MarkupString.Ansi/Emitters/AnsiBBCodeEmitter.cs b/MarkupString.Ansi/Emitters/AnsiBBCodeEmitter.cs
index 270aec2..56b69f1 100644
--- a/MarkupString.Ansi/Emitters/AnsiBBCodeEmitter.cs
+++ b/MarkupString.Ansi/Emitters/AnsiBBCodeEmitter.cs
@@ -17,11 +17,13 @@ public bool TryEmit(MarkupSet set, ReadOnlySpan<char> body, in EmitContext conte
 		ArgumentNullException.ThrowIfNull(set);
 		ArgumentNullException.ThrowIfNull(output);
 
-		using var inner = AnsiEmitterSupport.WriteInner(set, body, context);
-		if (inner is not null) body = inner.WrittenSpan;
-
-		var style = AnsiEmitterSupport.Fold(set, context.Format);
+		AnsiEmitterSupport.EmitSegmented(set, body, context, output, WriteTags);
+		return true;
+	}
 
+	/// <summary>Writes one stretch of folded layers as BBCode tags.</summary>
+	private static void WriteTags(in AnsiStyle style, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
 		// Reverse video has no BBCode form either, so the colour that would show as the text colour
 		// is the one written.
 		var foreground = style.Inverted ? style.Background : style.Foreground;
@@ -33,35 +35,30 @@ public bool TryEmit(MarkupSet set, ReadOnlySpan<char> body, in EmitContext conte
 			? candidate
 			: null;
 
-		using var core = new PooledCharWriter(body.Length + 64);
-
 		if (hex.Length > 0)
 		{
-			core.Write("[color=");
-			core.Write(hex);
-			core.Write("]");
+			output.Write("[color=");
+			output.Write(hex);
+			output.Write("]");
 		}
 		if (link is not null)
 		{
-			core.Write("[url=");
-			core.Write(link);
-			core.Write("]");
+			output.Write("[url=");
+			output.Write(link);
+			output.Write("]");
 		}
-		if (style.Bold) core.Write("[b]");
-		if (style.Italic) core.Write("[i]");
-		if (style.Underlined) core.Write("[u]");
-		if (style.StrikeThrough) core.Write("[s]");
-
-		core.Write(body);
+		if (style.Bold) output.Write("[b]");
+		if (style.Italic) output.Write("[i]");
+		if (style.Underlined) output.Write("[u]");
+		if (style.StrikeThrough) output.Write("[s]");
 
-		if (style.StrikeThrough) core.Write("[/s]");
-		if (style.Underlined) core.Write("[/u]");
-		if (style.Italic) core.Write("[/i]");
-		if (style.Bold) core.Write("[/b]");
-		if (link is not null) core.Write("[/url]");
-		if (hex.Length > 0) core.Write("[/color]");
+		output.Write(body);
 
-		AnsiEmitterSupport.WriteWrapped(set, core.WrittenSpan, context, output);
-		return true;
+		if (style.StrikeThrough) output.Write("[/s]");
+		if (style.Underlined) output.Write("[/u]");
+		if (style.Italic) output.Write("[/i]");
+		if (style.Bold) output.Write("[/b]");
+		if (link is not null) output.Write("[/url]");
+		if (hex.Length > 0) output.Write("[/color]");
 	}
 }
diff --git a/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs b/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs
index e0b3d02..070767b 100644
--- a/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs
+++ b/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs
@@ -53,37 +53,73 @@ internal static AnsiStyle Fold(MarkupSet? set, MarkupFormat format)
 	}
 
 	/// <summary>
-	/// The layers this package does not own that sit inside every layer it does — a picture inside a
-	/// link — applied to <paramref name="body"/> before any styling is, so they stay inside it. Null when
-	/// there are none, and the body is used as it is.
+	/// Writes one contiguous stretch of layers this package folds, around a body the layers inside it
+	/// have already been written into.
 	/// </summary>
-	internal static PooledCharWriter? WriteInner(MarkupSet set, ReadOnlySpan<char> body, in EmitContext context)
+	internal delegate void SegmentWriter(in AnsiStyle style, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output);
+
+	/// <summary>
+	/// Writes a run in the nesting it was built with, for a format that expresses nesting: the layers
+	/// this package folds are written by <paramref name="writeSegment"/> in stretches, and a layer it
+	/// does not own is written by its own emitter between them. <c>[bold, tag, red]</c> is a bold inside
+	/// a tag inside a red, and comes out that way, rather than as one bold red inside a tag.
+	/// </summary>
+	/// <remarks>
+	/// The common shapes cost nothing extra: with no foreign layer carrying an emitter, this is one
+	/// <paramref name="writeSegment"/> over the whole fold, the same call the emitters made before there
+	/// was anything to interleave.
+	/// </remarks>
+	internal static void EmitSegmented(
+		MarkupSet set,
+		ReadOnlySpan<char> body,
+		in EmitContext context,
+		IBufferWriter<char> output,
+		SegmentWriter writeSegment)
 	{
-		var boundary = FirstClaimed(set, context.Format);
+		if (!HasDelegatedLayer(set, context))
+		{
+			writeSegment(Fold(set, context.Format), body, context, output);
+			return;
+		}
+
 		PooledCharWriter? front = null;
 		PooledCharWriter? back = null;
 		try
 		{
-			for (var i = 0; i < boundary; i++)
+			front = new PooledCharWriter(body.Length + 32);
+			front.Write(body);
+			back = new PooledCharWriter(front.WrittenCount + 32);
+
+			var pending = AnsiStyle.None;
+			var hasPending = false;
+			for (var i = 0; i < set.Count; i++)
 			{
+				if (ClaimsStyle(set[i], context.Format, out var style))
+				{
+					// Innermost first, and an inner layer's settings win, which is how Fold combines them.
+					pending = hasPending ? style.Combine(pending) : style;
+					hasPending = true;
+					continue;
+				}
+
 				var emitter = context.Registry.FindEmitter(set[i].GetType(), context.Format);
 				if (emitter is null) continue;
 
-				if (front is null)
+				if (hasPending)
 				{
-					front = new PooledCharWriter(body.Length + 16);
-					front.Write(body);
+					back.Clear();
+					writeSegment(pending, front.WrittenSpan, context, back);
+					(front, back) = (back, front);
+					pending = AnsiStyle.None;
+					hasPending = false;
 				}
 
-				back ??= new PooledCharWriter(front.WrittenCount + 16);
 				back.Clear();
 				emitter.Emit(set[i], front.WrittenSpan, context, back);
 				(front, back) = (back, front);
 			}
 
-			var written = front;
-			front = null;
-			return written;
+			writeSegment(pending, front.WrittenSpan, context, output);
 		}
 		finally
 		{
@@ -92,20 +128,25 @@ internal static AnsiStyle Fold(MarkupSet? set, MarkupFormat format)
 		}
 	}
 
-	/// <summary>The index of the innermost layer this package folds, or the set's size when it folds none.</summary>
-	private static int FirstClaimed(MarkupSet set, MarkupFormat format)
+	/// <summary>Whether any layer is one this package does not fold and something else can write.</summary>
+	private static bool HasDelegatedLayer(MarkupSet set, in EmitContext context)
 	{
 		for (var i = 0; i < set.Count; i++)
-			if (ClaimsStyle(set[i], format, out _)) return i;
-		return set.Count;
+			if (!ClaimsStyle(set[i], context.Format, out _)
+				&& context.Registry.FindEmitter(set[i].GetType(), context.Format) is not null)
+				return true;
+
+		return false;
 	}
 
 	/// <summary>
 	/// Writes <paramref name="core"/> — the run as this package rendered it — wrapped by the layers
-	/// this package does not own in <see cref="EmitContext.Format"/> that sit outside the innermost one
-	/// it does (<see cref="WriteInner"/> took those inside), innermost first, each through its own
-	/// emitter for that format. A layer with no emitter registered for the format wraps in nothing: its
-	/// body passes through.
+	/// this package does not own in <see cref="EmitContext.Format"/>, innermost first, each through its
+	/// own emitter for that format. A layer with no emitter registered for the format wraps in nothing:
+	/// its body passes through. This is the terminal's shape, where a style is state rather than
+	/// nesting: the sequence is written once around the run, and where a delegated layer's own output
+	/// sits relative to it changes nothing on screen. Formats that express nesting use
+	/// <see cref="EmitSegmented"/>.
 	/// </summary>
 	internal static void WriteWrapped(
 		MarkupSet set,
@@ -117,7 +158,7 @@ internal static void WriteWrapped(
 		PooledCharWriter? back = null;
 		try
 		{
-			for (var i = FirstClaimed(set, context.Format); i < set.Count; i++)
+			for (var i = 0; i < set.Count; i++)
 			{
 				var layer = set[i];
 				if (ClaimsStyle(layer, context.Format, out _)) continue;
@@ -181,16 +222,15 @@ internal static void EmitTagged(
 		IBufferWriter<char> output,
 		TagFlavour flavour)
 	{
-		var style = Fold(set, context.Format);
-		using var inner = WriteInner(set, body, context);
-		if (inner is not null) body = inner.WrittenSpan;
-
-		using var core = new PooledCharWriter(body.Length + 64);
-		SgrWriter.Transition(AnsiStyle.None, style, core);
-		WriteTaggedLink(style, body, core, flavour);
-		if (LeavesState(style)) SgrWriter.Reset(core);
-
-		WriteWrapped(set, core.WrittenSpan, context, output);
+		// The flavour cannot ride on the delegate's signature, so it is closed over here; a run with
+		// nothing delegated never allocates the closure's work beyond this one call.
+		EmitSegmented(set, body, context, output,
+			(in AnsiStyle style, ReadOnlySpan<char> segment, in EmitContext segmentContext, IBufferWriter<char> segmentOutput) =>
+			{
+				SgrWriter.Transition(AnsiStyle.None, style, segmentOutput);
+				WriteTaggedLink(style, segment, segmentOutput, flavour);
+				if (LeavesState(style)) SgrWriter.Reset(segmentOutput);
+			});
 	}
 
 	/// <summary>
diff --git a/MarkupString.Ansi/Emitters/AnsiHtmlEmitter.cs b/MarkupString.Ansi/Emitters/AnsiHtmlEmitter.cs
index 54152e4..b322aa9 100644
--- a/MarkupString.Ansi/Emitters/AnsiHtmlEmitter.cs
+++ b/MarkupString.Ansi/Emitters/AnsiHtmlEmitter.cs
@@ -19,11 +19,13 @@ public bool TryEmit(MarkupSet set, ReadOnlySpan<char> body, in EmitContext conte
 		ArgumentNullException.ThrowIfNull(set);
 		ArgumentNullException.ThrowIfNull(output);
 
-		using var inner = AnsiEmitterSupport.WriteInner(set, body, context);
-		if (inner is not null) body = inner.WrittenSpan;
-
-		var style = AnsiEmitterSupport.Fold(set, context.Format);
+		AnsiEmitterSupport.EmitSegmented(set, body, context, output, WriteSpan);
+		return true;
+	}
 
+	/// <summary>Writes one stretch of folded layers as a span, with the anchor inside it.</summary>
+	private static void WriteSpan(in AnsiStyle style, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
 		// Reverse video swaps the two colours rather than asking the browser to.
 		var (foreground, background) = style.Inverted
 			? (style.Background, style.Foreground)
@@ -36,47 +38,41 @@ public bool TryEmit(MarkupSet set, ReadOnlySpan<char> body, in EmitContext conte
 		var hasStyle = foregroundHex.Length > 0 || backgroundHex.Length > 0;
 		var hasClasses = HasClasses(style, hasStyle);
 
-		using var core = new PooledCharWriter(body.Length + 96);
-
-		if (hasStyle || hasClasses)
+		if (!hasStyle && !hasClasses)
 		{
-			core.Write("<span");
+			WriteAnchored(style, body, output);
+			return;
+		}
 
-			if (hasStyle)
+		output.Write("<span");
+
+		if (hasStyle)
+		{
+			output.Write(" style=\"");
+			if (foregroundHex.Length > 0)
 			{
-				core.Write(" style=\"");
-				if (foregroundHex.Length > 0)
-				{
-					core.Write("color: ");
-					core.Write(foregroundHex);
-				}
-				if (foregroundHex.Length > 0 && backgroundHex.Length > 0) core.Write("; ");
-				if (backgroundHex.Length > 0)
-				{
-					core.Write("background-color: ");
-					core.Write(backgroundHex);
-				}
-				core.Write("\"");
+				output.Write("color: ");
+				output.Write(foregroundHex);
 			}
-
-			if (hasClasses)
+			if (foregroundHex.Length > 0 && backgroundHex.Length > 0) output.Write("; ");
+			if (backgroundHex.Length > 0)
 			{
-				core.Write(" class=\"");
-				WriteClasses(style, hasStyle, core);
-				core.Write("\"");
+				output.Write("background-color: ");
+				output.Write(backgroundHex);
 			}
-
-			core.Write(">");
-			WriteAnchored(style, body, core);
-			core.Write("</span>");
+			output.Write("\"");
 		}
-		else
+
+		if (hasClasses)
 		{
-			WriteAnchored(style, body, core);
+			output.Write(" class=\"");
+			WriteClasses(style, hasStyle, output);
+			output.Write("\"");
 		}
 
-		AnsiEmitterSupport.WriteWrapped(set, core.WrittenSpan, context, output);
-		return true;
+		output.Write(">");
+		WriteAnchored(style, body, output);
+		output.Write("</span>");
 	}
 
 	/// <summary>
diff --git a/MarkupString.Ansi/Emitters/AnsiSetEmitter.cs b/MarkupString.Ansi/Emitters/AnsiSetEmitter.cs
index ed58d01..8c156ed 100644
--- a/MarkupString.Ansi/Emitters/AnsiSetEmitter.cs
+++ b/MarkupString.Ansi/Emitters/AnsiSetEmitter.cs
@@ -18,9 +18,6 @@ public bool TryEmit(MarkupSet set, ReadOnlySpan<char> body, in EmitContext conte
 		ArgumentNullException.ThrowIfNull(set);
 		ArgumentNullException.ThrowIfNull(output);
 
-		using var inner = AnsiEmitterSupport.WriteInner(set, body, context);
-		if (inner is not null) body = inner.WrittenSpan;
-
 		var effective = AnsiEmitterSupport.Fold(set, context.Format);
 		var previous = AnsiEmitterSupport.Fold(context.Previous, context.Format);
 
diff --git a/MarkupString.Html/Emitters/ElementHtmlEmitter.cs b/MarkupString.Html/Emitters/ElementHtmlEmitter.cs
index 4cc3a3f..05a3f8f 100644
--- a/MarkupString.Html/Emitters/ElementHtmlEmitter.cs
+++ b/MarkupString.Html/Emitters/ElementHtmlEmitter.cs
@@ -11,9 +11,11 @@ namespace MarkupString.Html;
 /// <remarks>
 /// Addresses are written as given. Whether a page fetches, plays or shows them — and whether a
 /// relative file name means anything to it — is the page's decision, made with a
-/// <c>Content-Security-Policy</c> or by handling the element itself.
+/// <c>Content-Security-Policy</c>, with an <see cref="HtmlTagPolicy"/>, or by handling the element
+/// itself. With a policy, every element here is held to it as it is written, and one it refuses is
+/// written as a format that cannot express it writes it: nothing for a point, the text for the rest.
 /// </remarks>
-internal sealed class ElementHtmlEmitter(Type markupType) : IMarkupEmitter
+internal sealed class ElementHtmlEmitter(Type markupType, HtmlTagPolicy? policy = null) : IMarkupEmitter
 {
 	/// <summary>The markup types this emitter writes.</summary>
 	internal static readonly Type[] Types =
@@ -23,6 +25,19 @@ internal sealed class ElementHtmlEmitter(Type markupType) : IMarkupEmitter
 		typeof(GaugeMarkup), typeof(StatusMarkup),
 	];
 
+	/// <summary>How an element is closed.</summary>
+	private enum Shape
+	{
+		/// <summary>A void element: <c>&lt;img&gt;</c>, <c>&lt;link&gt;</c>.</summary>
+		Void,
+
+		/// <summary>An element with no content of its own: <c>&lt;audio&gt;&lt;/audio&gt;</c>, an empty span.</summary>
+		Empty,
+
+		/// <summary>An element around the text it marks.</summary>
+		Wrapping,
+	}
+
 	public Type MarkupType { get; } = markupType;
 
 	public MarkupFormat Format => MarkupFormat.Html;
@@ -35,94 +50,137 @@ public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context
 		switch (markup)
 		{
 			case SoundMarkup sound:
-				output.Write("<audio class=\"ms-sound\"");
-				Attribute(output, "data-channel", sound.Channel == SoundChannel.Music ? "music" : "effects");
-				Attribute(output, "src", sound.Source);
-				Attribute(output, "preload", "none");
-				if (sound.Loops) output.Write(" loop");
-				Attribute(output, "data-volume", sound.Volume);
-				if (!sound.Loops) Attribute(output, "data-repeats", sound.Repeats);
-				if (sound.Continues) Attribute(output, "data-continues", "true");
-				output.Write("></audio>");
-				break;
+				Write(markup, output, "audio", Shape.Empty, body,
+					("class", "ms-sound"),
+					("data-channel", sound.Channel == SoundChannel.Music ? "music" : "effects"),
+					("src", sound.Source),
+					("preload", "none"),
+					("loop", sound.Loops ? string.Empty : null),
+					("data-volume", Number(sound.Volume)),
+					("data-repeats", sound.Loops ? null : Number(sound.Repeats)),
+					("data-continues", sound.Continues ? "true" : null));
+				return;
 
 			case SoundStopMarkup stop:
-				output.Write("<span class=\"ms-sound-stop\"");
-				if (stop.Channel is { } channel) Attribute(output, "data-channel", channel == SoundChannel.Music ? "music" : "effects");
-				output.Write("></span>");
-				break;
+				Write(markup, output, "span", Shape.Empty, body,
+					("class", "ms-sound-stop"),
+					("data-channel", stop.Channel switch
+					{
+						SoundChannel.Effects => "effects",
+						SoundChannel.Music => "music",
+						_ => null,
+					}));
+				return;
 
 			case ClearScreenMarkup:
-				output.Write("<span class=\"ms-clear\"></span>");
-				break;
+				Write(markup, output, "span", Shape.Empty, body, ("class", "ms-clear"));
+				return;
 
 			case ExpireLinksMarkup expire:
-				output.Write("<span class=\"ms-expire\"");
-				Attribute(output, "data-group", expire.Group);
-				output.Write("></span>");
-				break;
+				Write(markup, output, "span", Shape.Empty, body, ("class", "ms-expire"), ("data-group", expire.Group));
+				return;
 
 			case PrefetchMarkup prefetch:
-				output.Write("<link rel=\"prefetch\"");
-				Attribute(output, "href", prefetch.Source);
-				output.Write(">");
-				break;
+				Write(markup, output, "link", Shape.Void, body, ("rel", "prefetch"), ("href", prefetch.Source));
+				return;
 
 			case ImageMarkup image:
-				output.Write("<img class=\"ms-image\"");
-				Attribute(output, "src", image.Source);
-				Attribute(output, "alt", image.Description ?? string.Empty);
-				Attribute(output, "width", image.Width);
-				Attribute(output, "height", image.Height);
-				if (image.Align is { } align) Attribute(output, "data-align", align.ToString().ToLowerInvariant());
-				output.Write(">");
-				break;
+				Write(markup, output, "img", Shape.Void, body,
+					("class", "ms-image"),
+					("src", image.Source),
+					("alt", image.Description ?? string.Empty),
+					("width", Number(image.Width)),
+					("height", Number(image.Height)),
+					("data-align", image.Align?.ToString().ToLowerInvariant()));
+				return;
 
 			case PaneMarkup pane:
-				Wrapping(output, "ms-pane", body, ("data-pane", pane.Name), ("data-title", pane.Title));
-				break;
+				Write(markup, output, "span", Shape.Wrapping, body,
+					("class", "ms-pane"), ("data-pane", pane.Name), ("data-title", pane.Title));
+				return;
 
 			case VariableMarkup variable:
-				Wrapping(output, "ms-variable", body, ("data-name", variable.Name));
-				break;
+				Write(markup, output, "span", Shape.Wrapping, body, ("class", "ms-variable"), ("data-name", variable.Name));
+				return;
 
 			case GaugeMarkup gauge:
-				Wrapping(output, "ms-gauge", body,
-					("data-variable", gauge.Variable), ("data-maximum", gauge.Maximum),
+				Write(markup, output, "span", Shape.Wrapping, body,
+					("class", "ms-gauge"), ("data-variable", gauge.Variable), ("data-maximum", gauge.Maximum),
 					("data-caption", gauge.Caption), ("data-color", gauge.Color));
-				break;
+				return;
 
 			case StatusMarkup status:
-				Wrapping(output, "ms-status", body,
-					("data-variable", status.Variable), ("data-maximum", status.Maximum), ("data-caption", status.Caption));
-				break;
+				Write(markup, output, "span", Shape.Wrapping, body,
+					("class", "ms-status"), ("data-variable", status.Variable),
+					("data-maximum", status.Maximum), ("data-caption", status.Caption));
+				return;
 
 			default:
 				output.Write(body);
-				break;
+				return;
 		}
 	}
 
-	private static void Wrapping(IBufferWriter<char> output, string className, ReadOnlySpan<char> body, params ReadOnlySpan<(string Name, string? Value)> attributes)
+	/// <summary>
+	/// Writes one element, held to the policy when there is one. The tag is built as an
+	/// <see cref="HtmlMarkup"/> so that it is the same thing a policy sees anywhere else. A tag the
+	/// policy refuses leaves what a format that cannot express the element leaves: nothing for a point,
+	/// and the text for everything else — a refused picture still leaves its description.
+	/// </summary>
+	private void Write(
+		IMarkup markup,
+		IBufferWriter<char> output,
+		string name,
+		Shape shape,
+		ReadOnlySpan<char> body,
+		params ReadOnlySpan<(string Name, string? Value)> attributes)
 	{
-		output.Write("<span class=\"");
-		output.Write(className);
-		output.Write("\"");
-		foreach (var (name, value) in attributes) Attribute(output, name, value);
+		var written = new HtmlAttribute[Count(attributes)];
+		var next = 0;
+		foreach (var (attribute, value) in attributes)
+		{
+			if (value is not null) written[next++] = new HtmlAttribute(attribute, value);
+		}
+
+		var tag = HtmlMarkup.Tag(name, written);
+		if (policy is not null)
+		{
+			if (policy.Apply(tag) is not { } held)
+			{
+				if (markup is not IPointMarkup) output.Write(body);
+				return;
+			}
+
+			tag = held;
+		}
+
+		output.Write("<");
+		output.Write(tag.TagName);
+		if (tag.Attributes is { Length: > 0 } rendered)
+		{
+			output.Write(" ");
+			output.Write(rendered);
+		}
 		output.Write(">");
-		output.Write(body);
-		output.Write("</span>");
-	}
 
-	private static void Attribute(IBufferWriter<char> output, string name, int? value)
-	{
-		if (value is { } number) Attribute(output, name, number.ToString(CultureInfo.InvariantCulture));
+		if (shape == Shape.Void) return;
+
+		if (shape == Shape.Wrapping) output.Write(body);
+		output.Write("</");
+		output.Write(tag.TagName);
+		output.Write(">");
 	}
 
-	private static void Attribute(IBufferWriter<char> output, string name, string? value)
+	private static int Count(ReadOnlySpan<(string Name, string? Value)> attributes)
 	{
-		if (value is null) return;
-		output.Write(" ");
-		output.Write(new HtmlAttribute(name, value).ToString());
+		var count = 0;
+		foreach (var (_, value) in attributes)
+		{
+			if (value is not null) count++;
+		}
+
+		return count;
 	}
+
+	private static string? Number(int? value) => value?.ToString(CultureInfo.InvariantCulture);
 }
diff --git a/MarkupString.Html/HtmlRegistration.cs b/MarkupString.Html/HtmlRegistration.cs
index 73776ad..23d33a7 100644
--- a/MarkupString.Html/HtmlRegistration.cs
+++ b/MarkupString.Html/HtmlRegistration.cs
@@ -33,13 +33,17 @@ public static MarkupRegistry WithHtml(this MarkupRegistry registry)
 	/// <summary>
 	/// As <see cref="WithHtml(MarkupRegistry)"/>, but every tag rendered in <see cref="MarkupFormat.Html"/>
 	/// is held to <paramref name="htmlPolicy"/> — the tags and attributes your application is willing to
-	/// put in front of a browser. Pueblo and MXP output still carries tags as given: they go to MUD
+	/// put in front of a browser, the shared vocabulary's own elements included. Pueblo and MXP output
+	/// still carries tags as given: they go to MUD
 	/// clients, and some of what they need (a command link) is what a browser policy typically refuses.
 	/// To hold those to a policy too, add <c>new HtmlTagEmitter(format, policy)</c> after this.
 	/// </summary>
 	public static MarkupRegistry WithHtml(this MarkupRegistry registry, HtmlTagPolicy htmlPolicy)
 	{
 		ArgumentNullException.ThrowIfNull(htmlPolicy);
-		return registry.WithHtml().With(new HtmlTagEmitter(MarkupFormat.Html, htmlPolicy));
+
+		registry = registry.WithHtml().With(new HtmlTagEmitter(MarkupFormat.Html, htmlPolicy));
+		foreach (var type in ElementHtmlEmitter.Types) registry = registry.With(new ElementHtmlEmitter(type, htmlPolicy));
+		return registry;
 	}
 }
diff --git a/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs b/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs
index 2db54e0..c68c19c 100644
--- a/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs
+++ b/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs
@@ -4,9 +4,10 @@
 /// <summary>
 /// The path a run takes when it carries a layer this package does not own. Every set emitter here
 /// claims every run, so <c>AnsiEmitterSupport</c> is the only thing standing between a foreign layer and
-/// being dropped. It keeps the nesting: foreign layers inside every ANSI layer are applied to the text
-/// before the style is (<c>WriteInner</c>), and the rest wrap the styled output (<c>WriteWrapped</c>),
-/// each innermost first.
+/// being dropped. A format that expresses nesting keeps it (<c>EmitSegmented</c>: a stretch of folded
+/// layers, then the foreign layer's own emitter, then the next stretch). A terminal does not — a style
+/// there is state, not nesting — so <c>WriteWrapped</c> wraps the whole SGR core in the foreign layers,
+/// innermost first.
 /// </summary>
 public class AnsiForeignLayerTests
 {
@@ -60,31 +61,35 @@ public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context
 		.WithAnsi()
 		.With(new TagEmitter(MarkupFormat.Ansi))
 		.With(new TagEmitter(MarkupFormat.Html))
+		.With(new TagEmitter(MarkupFormat.Pueblo))
 		.With(new BoldTagEmitter());
 
 	private static readonly AnsiMarkup Red = AnsiMarkup.Create(foreground: new AnsiColor.Standard(1, false));
 
+	private static readonly AnsiMarkup Bold = AnsiMarkup.Create(bold: true);
+
 	private static string Render(MarkupText text, MarkupFormat format) => text.Render(format, Registry);
 
 	// ── Delegation of layers this package does not own ────────────────────────────
 
 	/// <summary>
-	/// Set <c>[Tag("t"), AnsiMarkup(red)]</c>. The tag is inside the colour, so the colour's sequence
-	/// and reset bracket it.
+	/// Set <c>[Tag("t"), AnsiMarkup(red)]</c>. The ANSI sequence and its reset bracket the body — the
+	/// fold produces them around the run's text — and the foreign layer wraps that whole core. Where the
+	/// tag sits relative to the sequence changes nothing on a terminal, which holds the style as state.
 	/// </summary>
 	[Test]
-	public async Task Ansi_ForeignLayerInsideAnAnsiLayer_StaysInsideTheSgr()
+	public async Task Ansi_ForeignLayerInsideAnAnsiLayer_WrapsTheSgrCore()
 	{
 		var text = MarkupText.Wrap(Red, MarkupText.Wrap(new Tag("t"), "x"));
-		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"{Esc}[31m<t>x</t>{Esc}[0m");
+		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"<t>{Esc}[31mx{Esc}[0m</t>");
 	}
 
 	/// <summary>
-	/// Set <c>[AnsiMarkup(red), Tag("t")]</c> — the same two layers the other way round, and the tag
-	/// wraps the colour.
+	/// Set <c>[AnsiMarkup(red), Tag("t")]</c> — the same two layers the other way round, and the
+	/// terminal output is the same.
 	/// </summary>
 	[Test]
-	public async Task Ansi_ForeignLayerOutsideAnAnsiLayer_WrapsTheSgr()
+	public async Task Ansi_ForeignLayerOutsideAnAnsiLayer_RendersTheSame()
 	{
 		var text = MarkupText.Wrap(new Tag("t"), MarkupText.Wrap(Red, "x"));
 		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"<t>{Esc}[31mx{Esc}[0m</t>");
@@ -95,7 +100,7 @@ public async Task Ansi_ForeignLayerOutsideAnAnsiLayer_WrapsTheSgr()
 	public async Task Ansi_TwoForeignLayers_NestInOrder()
 	{
 		var text = MarkupText.Wrap(Red, MarkupText.Wrap(new Tag("b"), MarkupText.Wrap(new Tag("a"), "x")));
-		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"{Esc}[31m<b><a>x</a></b>{Esc}[0m");
+		await Assert.That(Render(text, MarkupFormat.Ansi)).IsEqualTo($"<b><a>{Esc}[31mx{Esc}[0m</a></b>");
 	}
 
 	/// <summary>The same set in HTML: both tags are inside the colour, so the span wraps them.</summary>
@@ -107,6 +112,35 @@ await Assert.That(Render(text, MarkupFormat.Html))
 			.IsEqualTo("<span style=\"color: #aa0000\"><b><a>x</a></b></span>");
 	}
 
+	// ── A foreign layer between two of this package's ────────────────────────────
+
+	/// <summary>
+	/// Set <c>[AnsiMarkup(bold), Tag("t"), AnsiMarkup(red)]</c>: a bold inside a tag inside a red. The
+	/// two ANSI layers are not folded into one across the tag — each is written where it sits, so the
+	/// tag stays between them.
+	/// </summary>
+	[Test]
+	public async Task Html_ForeignLayerBetweenTwoAnsiLayers_KeepsItBetweenThem()
+	{
+		var text = MarkupText.Wrap(Red, MarkupText.Wrap(new Tag("t"), MarkupText.Wrap(Bold, "x")));
+
+		await Assert.That(Render(text, MarkupFormat.Html))
+			.IsEqualTo("<span style=\"color: #aa0000\"><t><span class=\"ms-bold\">x</span></t></span>");
+	}
+
+	/// <summary>
+	/// The same set for Pueblo, where a style is SGR: the inner stretch opens inside the tag, and the
+	/// terminal ends up bold red at the text either way.
+	/// </summary>
+	[Test]
+	public async Task Pueblo_ForeignLayerBetweenTwoAnsiLayers_KeepsItBetweenThem()
+	{
+		var text = MarkupText.Wrap(Red, MarkupText.Wrap(new Tag("t"), MarkupText.Wrap(Bold, "x")));
+
+		await Assert.That(Render(text, MarkupFormat.Pueblo))
+			.IsEqualTo($"{Esc}[31m<t>{Esc}[1mx{Esc}[0m</t>{Esc}[0m");
+	}
+
 	/// <summary>A foreign layer alone, with no ANSI layer to fold: only its own emitter runs.</summary>
 	[Test]
 	public async Task Html_ForeignLayerAlone_RendersOnlyItsOwnTag()
diff --git a/MarkupString.Tests/SharedVocabularyTests.cs b/MarkupString.Tests/SharedVocabularyTests.cs
index 47e3d01..88ecfae 100644
--- a/MarkupString.Tests/SharedVocabularyTests.cs
+++ b/MarkupString.Tests/SharedVocabularyTests.cs
@@ -55,7 +55,7 @@ public async Task MusicThatLoopsLoopsEverywhere()
 		await Assert.That(Render(music, MarkupFormat.Mxp)).IsEqualTo("<MUSIC theme.mid L=-1 C=1>");
 		await Assert.That(Render(music, MarkupFormat.Pueblo)).IsEqualTo("<img xch_sound=\"loop\" href=\"theme.mid\">");
 		await Assert.That(Render(music, MarkupFormat.Html)).IsEqualTo(
-			"<audio class=\"ms-sound\" data-channel=\"music\" src=\"theme.mid\" preload=\"none\" loop data-continues=\"true\"></audio>");
+			"<audio class=\"ms-sound\" data-channel=\"music\" src=\"theme.mid\" preload=\"none\" loop=\"\" data-continues=\"true\"></audio>");
 	}
 
 	/// <summary>MXP names the file and, separately, where to download it from.</summary>
@@ -218,6 +218,43 @@ public async Task TheElementsToAskAboutAreTheOnesWritten()
 		await Assert.That(MxpRegistration.Elements).Contains("DEST");
 	}
 
+	// ── An HTML policy reaches these elements too ───────────────────────────────
+
+	/// <summary>
+	/// <c>WithHtml(policy)</c> says every tag rendered for a browser is held to it. These elements are
+	/// tags, so they are held to it too: one the policy refuses is written the way a format that cannot
+	/// express it writes it.
+	/// </summary>
+	[Test]
+	public async Task AnHtmlPolicyHoldsTheseElementsToo()
+	{
+		var policy = HtmlTagPolicy.WellFormed with
+		{
+			AllowedTags = new HashSet<string> { "span" },
+			UrlAttributes = HtmlTagPolicy.AddressAttributes,
+		};
+		var registry = MarkupRegistry.Empty.WithAnsi().WithHtml(policy);
+
+		var line = MarkupText.Concat([
+			MarkupText.Sound("door.wav"),
+			MarkupText.Image("map.png", "A map"),
+			MarkupText.Pane(MarkupText.Plain("gate"), "map")]);
+
+		await Assert.That(line.Render(MarkupFormat.Html, registry))
+			.IsEqualTo("A map<span class=\"ms-pane\" data-pane=\"map\">gate</span>")
+			.Because("audio and img are not allowed tags: the sound goes, the picture leaves its description");
+	}
+
+	[Test]
+	public async Task AnHtmlPolicyCanRefuseAnAddressWithoutRefusingTheElement()
+	{
+		var policy = HtmlTagPolicy.WellFormed with { UrlAttributes = HtmlTagPolicy.AddressAttributes };
+		var registry = MarkupRegistry.Empty.WithAnsi().WithHtml(policy);
+
+		await Assert.That(MarkupText.Image("javascript:alert(1)", "A map").Render(MarkupFormat.Html, registry))
+			.IsEqualTo("<img class=\"ms-image\" alt=\"A map\">");
+	}
+
 	// ── A point is not text ─────────────────────────────────────────────────────
 
 	[Test]
@@ -260,6 +297,67 @@ public async Task AValueIsQuotedWhenMxpWouldOtherwiseSplitIt()
 		await Assert.That(Render(status, MarkupFormat.Mxp)).IsEqualTo("<STAT hp CAPTION=\"He said &quot;hi&quot; &lt;loudly&gt;\">");
 	}
 
+	// ── A point marks its carrier and nothing else ──────────────────────────────
+
+	/// <summary>
+	/// Without this, a point could stand over words: the emitter writes the point and ignores the body,
+	/// so the text under it would be swallowed, and a point over an astral character would fire twice.
+	/// </summary>
+	[Test]
+	public async Task APointCannotBeWrappedAroundText()
+	{
+		await Assert.That(() => MarkupText.Wrap(new SoundMarkup("door.wav"), "The door creaks."))
+			.Throws<ArgumentException>();
+		await Assert.That(() => MarkupText.Wrap(new SoundMarkup("door.wav"), "\U0001F600")).Throws<ArgumentException>();
+		await Assert.That(() => MarkupText.Wrap(BellMarkup.Instance, MarkupText.Plain("x"))).Throws<ArgumentException>();
+		await Assert.That(() => MarkupText.Wrap(
+			MarkupSet.Of([new SoundMarkup("door.wav"), AnsiMarkup.Create(bold: true)]), "loud")).Throws<ArgumentException>();
+	}
+
+	[Test]
+	public async Task APointWrappedInStylingIsStillAPoint()
+	{
+		var styled = MarkupText.Wrap(AnsiMarkup.Create(bold: true), MarkupText.Sound("door.wav"));
+
+		await Assert.That(Render(styled, MarkupFormat.Mxp)).Contains("<SOUND door.wav>");
+		await Assert.That(styled.ToPlainText()).IsEqualTo(string.Empty);
+	}
+
+	/// <summary>
+	/// Two points on one carrier cannot be built, but a cover read back from somewhere else can hold
+	/// them. Each is written, and neither swallows the other.
+	/// </summary>
+	[Test]
+	public async Task EveryPointOnACarrierIsWritten()
+	{
+		var two = MarkupText.Wrap(
+			MarkupSet.Of([new SoundMarkup("door.wav"), new SoundMarkup("bell.wav")]), MarkupText.PointCarrier);
+
+		await Assert.That(Render(two, MarkupFormat.Mxp)).IsEqualTo("<SOUND door.wav><SOUND bell.wav>");
+		await Assert.That(two.ToPlainText()).IsEqualTo(string.Empty);
+	}
+
+	/// <summary>
+	/// A cover that puts a point over real text is not a shape any format can render: the point is
+	/// dropped and the text kept, rather than the text disappearing under it.
+	/// </summary>
+	[Test]
+	public async Task AMisplacedPointIsDroppedAndItsTextKept()
+	{
+		var json = MarkupTextSerializer.Serialize(
+			MarkupText.Concat([MarkupText.Sound("door.wav"), Creaks]), MarkupRegistry.Empty);
+
+		// The cover, rewritten so the sound covers the sentence instead of its carrier.
+		var moved = json.Replace("\"r\":[1,1,16,0]", "\"r\":[1,0,16,1]");
+
+		var back = MarkupTextSerializer.Deserialize(moved, MarkupRegistry.Empty);
+
+		await Assert.That(back.ToPlainText()).EndsWith("The door creaks.");
+		await Assert.That(back.Runs.Any(run => run.Markups.Any(markup => markup is IPointMarkup))).IsFalse();
+		await Assert.That(Render(back, MarkupFormat.Mxp)).EndsWith("The door creaks.")
+			.Because("the sentence is kept; only the point that could not be written where it sat is gone");
+	}
+
 	// ── Storage ──────────────────────────────────────────────────────────────────
 
 	/// <summary>The vocabulary is core's, so text carrying it round-trips with no package registered at all.</summary>
diff --git a/MarkupString/BellMarkup.cs b/MarkupString/BellMarkup.cs
index 0431646..62d28ca 100644
--- a/MarkupString/BellMarkup.cs
+++ b/MarkupString/BellMarkup.cs
@@ -16,6 +16,9 @@ public sealed class BellMarkup : IPointMarkup
 	/// <summary>The character a bell is carried on.</summary>
 	public const string Character = "\u0007";
 
+	/// <inheritdoc/>
+	public string Carrier => Character;
+
 	/// <summary>The one instance; a bell carries no state.</summary>
 	public static readonly BellMarkup Instance = new();
 
diff --git a/MarkupString/Elements/ElementCodecs.cs b/MarkupString/Elements/ElementCodecs.cs
index 514423d..6c298c3 100644
--- a/MarkupString/Elements/ElementCodecs.cs
+++ b/MarkupString/Elements/ElementCodecs.cs
@@ -7,6 +7,9 @@ namespace MarkupString;
 /// </summary>
 internal static class ElementCodecs
 {
+	/// <summary>The kind the serializer writes for <see cref="NeutralMarkup"/>, which needs no codec.</summary>
+	public const string NeutralKind = "neutral";
+
 	private static readonly IMarkupCodec[] All =
 	[
 		new Codec<BellMarkup>("bell", static (_, _) => { }, static _ => BellMarkup.Instance),
@@ -106,6 +109,9 @@ internal static class ElementCodecs
 
 	public static IMarkupCodec? Find(string kind) => ByKind.GetValueOrDefault(kind);
 
+	/// <summary>Whether <paramref name="kind"/> is one core writes itself, and so not one to register.</summary>
+	public static bool IsReserved(string kind) => kind == NeutralKind || ByKind.ContainsKey(kind);
+
 	private static string? String(JsonElement element, string name) =>
 		element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String ? value.GetString() : null;
 
diff --git a/MarkupString/IPointMarkup.cs b/MarkupString/IPointMarkup.cs
index 870f890..6fb790c 100644
--- a/MarkupString/IPointMarkup.cs
+++ b/MarkupString/IPointMarkup.cs
@@ -15,4 +15,10 @@ namespace MarkupString;
 /// </remarks>
 public interface IPointMarkup : IMarkup
 {
+	/// <summary>
+	/// The character this point rides on, one per occurrence. A point marks its carrier and nothing
+	/// else: <see cref="MarkupText.Wrap(IMarkup, string)"/> refuses any other text, so a point can never
+	/// stand over words a format would then swallow.
+	/// </summary>
+	string Carrier => MarkupText.PointCarrier;
 }
diff --git a/MarkupString/MarkupRegistry.cs b/MarkupString/MarkupRegistry.cs
index 312c5bb..9fb1b9f 100644
--- a/MarkupString/MarkupRegistry.cs
+++ b/MarkupString/MarkupRegistry.cs
@@ -128,11 +128,20 @@ public MarkupRegistry With(ILineFramer framer)
 	/// or markup type. A codec the new one displaces on either side is dropped from both sides, so a
 	/// kind and a markup type are never mapped to two different codecs: a codec that can no longer
 	/// be found by its wire kind must not still be found by its type, or text would serialise under
-	/// a kind that reads back as something else.
+	/// a kind that reads back as something else. The kinds core writes itself — the shared vocabulary's,
+	/// and <c>"neutral"</c> — are reserved, because they are read without consulting a registry at all.
 	/// </summary>
+	/// <exception cref="ArgumentException"><paramref name="codec"/> claims a kind core writes itself.</exception>
 	public MarkupRegistry With(IMarkupCodec codec)
 	{
 		ArgumentNullException.ThrowIfNull(codec);
+		if (ElementCodecs.IsReserved(codec.Kind))
+		{
+			throw new ArgumentException(
+				$"The kind '{codec.Kind}' is core's own: it is written and read without a registry, so a codec registered under it would write text that reads back as something else. Pick another kind.",
+				nameof(codec));
+		}
+
 		var byKind = new Dictionary<string, IMarkupCodec>(_codecsByKind.Count + 1, StringComparer.Ordinal);
 		foreach (var pair in _codecsByKind)
 			if (pair.Value.MarkupType != codec.MarkupType) byKind[pair.Key] = pair.Value;
diff --git a/MarkupString/MarkupText.Elements.cs b/MarkupString/MarkupText.Elements.cs
index de5be27..89c9c37 100644
--- a/MarkupString/MarkupText.Elements.cs
+++ b/MarkupString/MarkupText.Elements.cs
@@ -19,11 +19,11 @@ public sealed partial class MarkupText
 	/// </summary>
 	public const string PointCarrier = "\u200b";
 
-	/// <summary>A point in the text, riding on <see cref="PointCarrier"/>.</summary>
+	/// <summary>A point in the text, riding on its own <see cref="IPointMarkup.Carrier"/>.</summary>
 	public static MarkupText Point(IPointMarkup markup)
 	{
 		ArgumentNullException.ThrowIfNull(markup);
-		return Wrap(markup, PointCarrier);
+		return Wrap(markup, markup.Carrier);
 	}
 
 	/// <summary>Plays a sound effect. See <see cref="SoundMarkup"/>.</summary>
diff --git a/MarkupString/MarkupText.cs b/MarkupString/MarkupText.cs
index 4863079..f79b3ae 100644
--- a/MarkupString/MarkupText.cs
+++ b/MarkupString/MarkupText.cs
@@ -19,13 +19,13 @@ public sealed partial class MarkupText : IEquatable<MarkupText>
 
 	/// <summary>
 	/// Constructs a <see cref="MarkupText"/> from raw text and candidate runs. Normalises the
-	/// runs: drops empty/out-of-range runs, sorts by <see cref="Run.Start"/>, and coalesces
-	/// adjacent runs carrying an equal <see cref="MarkupSet"/>.
+	/// runs: drops empty/out-of-range runs and points that do not match the text they cover, sorts by
+	/// <see cref="Run.Start"/>, and coalesces adjacent runs carrying an equal <see cref="MarkupSet"/>.
 	/// </summary>
 	internal MarkupText(string text, ImmutableArray<Run> runs)
 	{
 		Text = text;
-		Runs = Normalise(runs, text.Length);
+		Runs = Normalise(runs, text, text.Length);
 	}
 
 	public static MarkupText Plain(string text) => text.Length switch
@@ -44,12 +44,34 @@ internal MarkupText(string text, ImmutableArray<Run> runs)
 
 	public static MarkupText Wrap(IMarkup markup, string text) => Wrap(MarkupSet.Of(markup), text);
 
-	public static MarkupText Wrap(MarkupSet markups, string text) =>
-		text.Length == 0 ? Empty : new MarkupText(text, [new Run(0, text.Length, markups)]);
+	/// <exception cref="ArgumentException">
+	/// A point in <paramref name="markups"/> stands over something other than its own carrier.
+	/// </exception>
+	public static MarkupText Wrap(MarkupSet markups, string text)
+	{
+		if (text.Length == 0) return Empty;
+		CheckPoints(markups, text);
+		return new MarkupText(text, [new Run(0, text.Length, markups)]);
+	}
 
+	/// <exception cref="ArgumentException">
+	/// <paramref name="markup"/> is a point and <paramref name="inner"/> is something other than its own
+	/// carrier, or already carries markup of its own.
+	/// </exception>
 	public static MarkupText Wrap(IMarkup markup, MarkupText inner)
 	{
 		if (inner.Length == 0) return Empty;
+		if (markup is IPointMarkup point)
+		{
+			CheckPoint(point, inner.Text);
+			if (!inner.Runs.IsDefaultOrEmpty)
+			{
+				throw new ArgumentException(
+					$"{markup.GetType().Name} is a point, and a point marks its carrier alone, which carries no markup of its own.",
+					nameof(inner));
+			}
+		}
+
 		var outer = MarkupSet.Of(markup);
 		var builder = ImmutableArray.CreateBuilder<Run>(inner.Runs.Length * 2 + 1);
 		var position = 0;
@@ -177,7 +199,64 @@ private static bool IsPoint(Run run)
 	/// any run was altered (clipped, dropped, merged, or sorted) — never the original array in
 	/// that case, even when the run count happens to match.
 	/// </summary>
-	private static ImmutableArray<Run> Normalise(ImmutableArray<Run> runs, int length)
+	/// <summary>Every point in the set marks only its own carrier.</summary>
+	private static void CheckPoints(MarkupSet markups, string text)
+	{
+		foreach (var markup in markups)
+			if (markup is IPointMarkup point)
+				CheckPoint(point, text);
+	}
+
+	private static void CheckPoint(IPointMarkup point, string text)
+	{
+		if (IsCarriedBy(point, text.AsSpan())) return;
+
+		throw new ArgumentException(
+			$"{point.GetType().Name} is a point: it marks its own carrier, not text. Build one with MarkupText.Point.",
+			nameof(text));
+	}
+
+	/// <summary>Whether <paramref name="text"/> is that point's carrier, one character per occurrence.</summary>
+	private static bool IsCarriedBy(IPointMarkup point, ReadOnlySpan<char> text)
+	{
+		var carrier = point.Carrier.AsSpan();
+		if (carrier.Length == 0 || text.Length == 0 || text.Length % carrier.Length != 0) return false;
+
+		for (var i = 0; i < text.Length; i += carrier.Length)
+			if (!text.Slice(i, carrier.Length).SequenceEqual(carrier))
+				return false;
+
+		return true;
+	}
+
+	/// <summary>
+	/// The set with any point that does not match the text it covers dropped. Construction refuses that
+	/// shape, so this is what stands between a hand-written or corrupted serialised cover and a renderer
+	/// that would write the point and swallow the text under it.
+	/// </summary>
+	private static MarkupSet WithoutMisplacedPoints(MarkupSet markups, ReadOnlySpan<char> text)
+	{
+		var keep = true;
+		foreach (var markup in markups)
+		{
+			if (markup is IPointMarkup point && !IsCarriedBy(point, text))
+			{
+				keep = false;
+				break;
+			}
+		}
+
+		if (keep) return markups;
+
+		var kept = new List<IMarkup>(markups.Count);
+		foreach (var markup in markups)
+			if (markup is not IPointMarkup point || IsCarriedBy(point, text))
+				kept.Add(markup);
+
+		return kept.Count == 0 ? MarkupSet.Of(NeutralMarkup.Instance) : MarkupSet.Of(kept);
+	}
+
+	private static ImmutableArray<Run> Normalise(ImmutableArray<Run> runs, string text, int length)
 	{
 		if (runs.IsDefaultOrEmpty) return ImmutableArray<Run>.Empty;
 		var sorted = false;
@@ -194,7 +273,9 @@ private static ImmutableArray<Run> Normalise(ImmutableArray<Run> runs, int lengt
 				changed = true;
 				continue;
 			}
-			var run = new Run(start, end - start, raw.Markups);
+			var markups = WithoutMisplacedPoints(raw.Markups, text.AsSpan(start, end - start));
+			if (!ReferenceEquals(markups, raw.Markups)) changed = true;
+			var run = new Run(start, end - start, markups);
 			if (run.Start != raw.Start || run.Length != raw.Length) changed = true;
 			if (builder.Count > 0)
 			{
diff --git a/MarkupString/MarkupTextRenderer.cs b/MarkupString/MarkupTextRenderer.cs
index f797999..67c62f3 100644
--- a/MarkupString/MarkupTextRenderer.cs
+++ b/MarkupString/MarkupTextRenderer.cs
@@ -170,25 +170,18 @@ private static bool RenderRun(
 		IBufferWriter<char> output)
 	{
 		var markups = run.Markups;
-		var point = FindPoint(markups);
-		IMarkupEmitter? pointEmitter = null;
-		if (point is not null)
-		{
-			// A point's carrier is not text. With no emitter for this format the point writes nothing —
-			// not the carrier, and not the layers around it, which would wrap an empty body.
-			pointEmitter = registry.FindEmitter(point.GetType(), format);
-			if (pointEmitter is null) return false;
-			markups = Without(markups, point);
-		}
+		var points = CountPoints(markups);
 
 		var front = new PooledCharWriter(body.Length + 16);
 		PooledCharWriter? back = null;
 		try
 		{
-			if (pointEmitter is not null)
+			if (points > 0)
 			{
-				// Equal points side by side coalesce into one run; each carrier is still one point.
-				for (var i = 0; i < body.Length; i++) pointEmitter.Emit(point!, body.Slice(i, 1), context, front);
+				// A point's carrier is not text. With no emitter for this format the point writes nothing
+				// — not the carrier, and not the layers around it, which would wrap an empty body.
+				if (!WritePoints(markups, body, format, registry, context, front)) return false;
+				markups = Without(markups, points);
 				if (markups is null)
 				{
 					output.Write(front.WrittenSpan);
@@ -212,7 +205,7 @@ private static bool RenderRun(
 				back.Clear();
 			}
 
-			var emitted = pointEmitter is not null;
+			var emitted = points > 0;
 			for (var i = 0; i < markups!.Count; i++)
 			{
 				var markup = markups[i];
@@ -235,22 +228,53 @@ private static bool RenderRun(
 		}
 	}
 
-	/// <summary>The point a run carries, if any.</summary>
-	private static IPointMarkup? FindPoint(MarkupSet markups)
+	/// <summary>How many points the run carries. A well-formed run carries at most one.</summary>
+	private static int CountPoints(MarkupSet markups)
+	{
+		var points = 0;
+		foreach (var markup in markups)
+			if (markup is IPointMarkup) points++;
+		return points;
+	}
+
+	/// <summary>
+	/// Writes every point the run carries, innermost first, once per carrier it covers — equal points
+	/// side by side coalesce into one run, and each carrier is still one point. Returns whether anything
+	/// was written: a point this format has no emitter for writes nothing at all, and a run of nothing
+	/// but such points is dropped whole, carrier included.
+	/// </summary>
+	private static bool WritePoints(
+		MarkupSet markups,
+		ReadOnlySpan<char> body,
+		MarkupFormat format,
+		MarkupRegistry registry,
+		in EmitContext context,
+		IBufferWriter<char> output)
 	{
+		var written = false;
 		foreach (var markup in markups)
-			if (markup is IPointMarkup point) return point;
-		return null;
+		{
+			if (markup is not IPointMarkup point) continue;
+
+			var emitter = registry.FindEmitter(point.GetType(), format);
+			if (emitter is null) continue;
+
+			var carrier = point.Carrier.Length;
+			for (var i = 0; i + carrier <= body.Length; i += carrier) emitter.Emit(point, body.Slice(i, carrier), context, output);
+			written = true;
+		}
+
+		return written;
 	}
 
-	/// <summary>The run's other layers, or null when the point was its only one.</summary>
-	private static MarkupSet? Without(MarkupSet markups, IPointMarkup point)
+	/// <summary>The run's layers with the points taken out, or null when it carried nothing else.</summary>
+	private static MarkupSet? Without(MarkupSet markups, int points)
 	{
-		if (markups.Count == 1) return null;
+		if (markups.Count == points) return null;
 
-		var rest = new List<IMarkup>(markups.Count - 1);
+		var rest = new List<IMarkup>(markups.Count - points);
 		foreach (var markup in markups)
-			if (!ReferenceEquals(markup, point)) rest.Add(markup);
+			if (markup is not IPointMarkup) rest.Add(markup);
 		return MarkupSet.Of(rest);
 	}
 }
diff --git a/MarkupString/MarkupTextSerializer.cs b/MarkupString/MarkupTextSerializer.cs
index 1bf4a5e..a27a14e 100644
--- a/MarkupString/MarkupTextSerializer.cs
+++ b/MarkupString/MarkupTextSerializer.cs
@@ -43,7 +43,7 @@ namespace MarkupString;
 public static class MarkupTextSerializer
 {
 	/// <summary>The kind written for, and read back as, <see cref="NeutralMarkup.Instance"/>.</summary>
-	private const string NeutralKind = "neutral";
+	private const string NeutralKind = ElementCodecs.NeutralKind;
 
 	/// <summary>
 	/// Leaves non-ASCII text as literal UTF-8 rather than <c>\uXXXX</c> escapes. The default encoder
diff --git a/MarkupString/PublicAPI.Unshipped.txt b/MarkupString/PublicAPI.Unshipped.txt
index 1ffbe6b..eba9d2e 100644
--- a/MarkupString/PublicAPI.Unshipped.txt
+++ b/MarkupString/PublicAPI.Unshipped.txt
@@ -199,3 +199,5 @@ static MarkupString.VariableMarkup.operator !=(MarkupString.VariableMarkup? left
 static MarkupString.VariableMarkup.operator ==(MarkupString.VariableMarkup? left, MarkupString.VariableMarkup? right) -> bool
 static readonly MarkupString.ClearScreenMarkup.Instance -> MarkupString.ClearScreenMarkup!
 const MarkupString.MarkupText.PointCarrier = "​" -> string!
+MarkupString.BellMarkup.Carrier.get -> string!
+MarkupString.IPointMarkup.Carrier.get -> string!
diff --git a/README.md b/README.md
index 7bd1cb5..078d63d 100644
--- a/README.md
+++ b/README.md
@@ -118,7 +118,7 @@ TextLayout.Rows(
   pays for a reset it does not need.
 - **Unicode-correct by construction.** Extractions snap inward to cluster boundaries, edits snap
   outward; padding and alignment measure in cells, not code units.
-- **AOT and trimming clean.** All three packages are `IsAotCompatible` with no reflection and no
+- **AOT and trimming clean.** Every package is `IsAotCompatible` with no reflection and no
   dynamic code, and CI publishes a native binary with every assembly rooted, failing on any
   `IL2xxx`/`IL3xxx` warning.
 
@@ -130,7 +130,7 @@ TextLayout.Rows(
 
 Semantic versioning, driven by [MinVer](https://github.com/adamralph/minver): the tag `v1.2.3`
 builds `1.2.3`, and any other commit builds the next patch as a `-preview.0.N` prerelease. The
-three packages share one version and are released together. Public API changes are tracked in
+packages share one version and are released together. Public API changes are tracked in
 `PublicAPI.Shipped.txt` / `PublicAPI.Unshipped.txt` and enforced at build time.
 
 ## Contributing
diff --git a/docs/formats.md b/docs/formats.md
index 3099519..6250fe7 100644
--- a/docs/formats.md
+++ b/docs/formats.md
@@ -105,6 +105,11 @@ text: `ToPlainText()`, `ToString()` and equality leave it out, and the renderer
 format with an emitter for the point writes the point; a format with none writes nothing, not even the
 styling around it. `MarkupText.Point(markup)` makes a point of your own.
 
+A point marks its carrier and nothing else. `MarkupText.Wrap` refuses a point over anything but its own
+carrier, so a point can never stand over words that a format would then swallow, and a cover read back
+with one out of place drops the point rather than the text. Styling *around* a point is fine: the
+styling is written only if the point is.
+
 ### What an MXP client said it supports
 
 MXP asks a client which elements it can render with `<SUPPORT>`, and a client that answered `-image`
diff --git a/docs/releasing.md b/docs/releasing.md
index d7026da..59e176e 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -1,6 +1,6 @@
 # Releasing
 
-For maintainers. The three packages share one version and are always released together.
+For maintainers. The five packages share one version and are always released together.
 
 ## How a version is decided
 
@@ -33,8 +33,9 @@ build if the two ever disagree.
    The tag triggers `.github/workflows/release.yml`. `workflow_dispatch` with the tag name as input
    does the same thing by hand.
 
-4. After the release lands on nuget.org, set `PackageValidationBaselineVersion` to it in each of
-   the three package files. Package validation then diffs every later build against that published
+4. After the release lands on nuget.org, set `PackageValidationBaselineVersion` to it in each
+   package file — a package gets the property with its own first release, since there is nothing to
+   diff against before that. Package validation then diffs every later build against that published
    surface and fails on a break — including one you did not mean to make.
 
    A release that *does* remove or re-signature public API is the exception: drop the property for
@@ -88,4 +89,4 @@ policy.
 - [ ] `PublicAPI.Unshipped.txt` promoted to `PublicAPI.Shipped.txt` in every package
 - [ ] Trusted publishing policy exists on nuget.org for `SharpMUSH/MarkupString` (first release only)
 - [ ] Tag pushed, `Release` workflow green
-- [ ] `PackageValidationBaselineVersion` raised to the version just published (and added to a package on its first release)
+- [ ] `PackageValidationBaselineVersion` raised to the version just published in each released package

From f72932f3bd1bd2776b0367476d886653c4d30677 Mon Sep 17 00:00:00 2001
From: Harry Cordewener <admin@twilightdays.org>
Date: Tue, 22 Sep 2026 13:03:38 -0500
Subject: [PATCH 4/4] A cleared stretch stays cleared across a delegated layer

AnsiStyle.Clear discards the styling around it. With a layer from another
package between two stretches of styling, the outer stretch was still written
around the delegated output, so the colour came back.

Found by CodeRabbit on #18.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 .../Emitters/AnsiEmitterSupport.cs            | 10 ++++++--
 .../Ansi/AnsiForeignLayerTests.cs             | 24 +++++++++++++++++++
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs b/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs
index 070767b..91fdc65 100644
--- a/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs
+++ b/MarkupString.Ansi/Emitters/AnsiEmitterSupport.cs
@@ -92,6 +92,11 @@ internal static void EmitSegmented(
 
 			var pending = AnsiStyle.None;
 			var hasPending = false;
+
+			// A style that clears discards everything around it (AnsiStyle.Combine), and a delegated layer
+			// in between does not change that: once a stretch has cleared, the stretches outside it write
+			// no styling at all.
+			var cleared = false;
 			for (var i = 0; i < set.Count; i++)
 			{
 				if (ClaimsStyle(set[i], context.Format, out var style))
@@ -107,8 +112,9 @@ internal static void EmitSegmented(
 
 				if (hasPending)
 				{
+					cleared |= pending.Clear;
 					back.Clear();
-					writeSegment(pending, front.WrittenSpan, context, back);
+					writeSegment(cleared ? AnsiStyle.None : pending, front.WrittenSpan, context, back);
 					(front, back) = (back, front);
 					pending = AnsiStyle.None;
 					hasPending = false;
@@ -119,7 +125,7 @@ internal static void EmitSegmented(
 				(front, back) = (back, front);
 			}
 
-			writeSegment(pending, front.WrittenSpan, context, output);
+			writeSegment(cleared ? AnsiStyle.None : pending, front.WrittenSpan, context, output);
 		}
 		finally
 		{
diff --git a/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs b/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs
index c68c19c..db6c571 100644
--- a/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs
+++ b/MarkupString.Tests/Ansi/AnsiForeignLayerTests.cs
@@ -68,6 +68,8 @@ public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context
 
 	private static readonly AnsiMarkup Bold = AnsiMarkup.Create(bold: true);
 
+	private static readonly AnsiMarkup Cleared = AnsiMarkup.Create(clear: true);
+
 	private static string Render(MarkupText text, MarkupFormat format) => text.Render(format, Registry);
 
 	// ── Delegation of layers this package does not own ────────────────────────────
@@ -141,6 +143,28 @@ await Assert.That(Render(text, MarkupFormat.Pueblo))
 			.IsEqualTo($"{Esc}[31m<t>{Esc}[1mx{Esc}[0m</t>{Esc}[0m");
 	}
 
+	/// <summary>
+	/// Set <c>[AnsiMarkup(clear), Tag("t"), AnsiMarkup(red)]</c>. A style that clears discards what is
+	/// around it, and a delegated layer in between does not let the red back in.
+	/// </summary>
+	[Test]
+	public async Task Html_ClearInsideAForeignLayer_StillDiscardsTheStyleAroundIt()
+	{
+		var text = MarkupText.Wrap(Red, MarkupText.Wrap(new Tag("t"), MarkupText.Wrap(Cleared, "x")));
+
+		await Assert.That(Render(text, MarkupFormat.Html)).IsEqualTo("<t>x</t>");
+		await Assert.That(Render(text, MarkupFormat.Pueblo)).IsEqualTo("<t>x</t>");
+	}
+
+	/// <summary>The same set with the clear outside the tag: there is nothing inside it to keep.</summary>
+	[Test]
+	public async Task Html_ClearOutsideAForeignLayer_DiscardsTheStyleToo()
+	{
+		var text = MarkupText.Wrap(Red, MarkupText.Wrap(Cleared, MarkupText.Wrap(new Tag("t"), "x")));
+
+		await Assert.That(Render(text, MarkupFormat.Html)).IsEqualTo("<t>x</t>");
+	}
+
 	/// <summary>A foreign layer alone, with no ANSI layer to fold: only its own emitter runs.</summary>
 	[Test]
 	public async Task Html_ForeignLayerAlone_RendersOnlyItsOwnTag()