diff --git a/CHANGELOG.md b/CHANGELOG.md
index 98093eb..fdcb411 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,43 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **`MarkupString.Pueblo`, a new package: Pueblo's own extensions.** `PuebloElements` builds the
+  `xch_` vocabulary a Pueblo client reads — `xch_pane`, `xch_page`, `xch_prefetch`, `xch_mudtext`, the
+  `xch_sound`/`xch_alert`/`xch_speech` family, the `xch_mode` switches, and an `<img>` carrying
+  `xch_cmd`, `xch_hint` or `xch_graph` — from the client's own tag and attribute tables. They render as
+  Pueblo tags for `Pueblo`, as an image or a span for `Html` where one fits, and as nothing at all
+  everywhere else, carrier included.
+  - Plain HTML stays `HtmlMarkup`'s (Pueblo reads an HTML subset), and styling and links stay
+    `AnsiMarkup`'s, which already writes each dialect's own form. Only what is Pueblo's alone is here,
+    so nothing about the existing kinds changes.
+
+- **`MarkupString.Mxp`, a new package: MXP's own elements.** `MxpElements` builds what the
+  specification defines — `SOUND`, `MUSIC`, `IMAGE`, `GAUGE`, `STAT`, `FRAME`, `VAR`, `EXPIRE`,
+  `RELOCATE`, `USER`, `PASSWORD`, `NOBR`, `SBR` — and `MxpElement` writes one it does not. They render
+  as MXP tags for `Mxp`, as the nearest thing a browser has for `Html` (an `<img>`, an `<audio>`, a
+  `data-entity` span a page can draw), and as **nothing at all** for every other format, the zero-width
+  carrier a standalone element rides on included, so the same text is safe to send to every client.
+  - An address is written for a browser only when the element carries an absolute `http`/`https` URL of
+    its own: MXP's `FName` names a file in the game's sound or image directory, which a browser cannot
+    resolve.
+  - `WithMxp(element => ...)` holds what is written to what the client answered in MXP's `<SUPPORT>`
+    exchange; a refused element writes nothing, or its content alone when it wraps, so a `FRAME` a client
+    cannot open does not take the text inside it. With no predicate every element is written — never
+    asked is not refused. `new MxpSilentEmitter(MarkupFormat.Html)` after it keeps MXP out of the browser
+    entirely.
+
+### Added
+
+- **`MarkupString.Pueblo`, a new package: Pueblo's own extensions.** `PuebloElements` builds the
+  `xch_` vocabulary a Pueblo client reads — `xch_pane`, `xch_page`, `xch_prefetch`, `xch_mudtext`, the
+  `xch_sound`/`xch_alert`/`xch_speech` family, the `xch_mode` switches, and an `<img>` carrying
+  `xch_cmd`, `xch_hint` or `xch_graph` — from the client's own tag and attribute tables. They render as
+  Pueblo tags for `Pueblo`, as an image or a span for `Html` where one fits, and as nothing at all
+  everywhere else, carrier included.
+  - Plain HTML stays `HtmlMarkup`'s (Pueblo reads an HTML subset), and styling and links stay
+    `AnsiMarkup`'s, which already writes each dialect's own form. Only what is Pueblo's alone is here,
+    so nothing about the existing kinds changes.
+
 - **Checked `HtmlMarkup` construction.** `HtmlMarkup.Tag(name, params attributes)` validates the
   tag and attribute names and writes each value encoded, so nothing in a value can end the attribute
   or the tag. `HtmlMarkup.IsValidTagName`, `IsValidAttributeName` and `TryParseAttributes` (which
@@ -44,6 +81,16 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **`MarkupString.Pueblo`, a new package: Pueblo's own extensions.** `PuebloElements` builds the
+  `xch_` vocabulary a Pueblo client reads — `xch_pane`, `xch_page`, `xch_prefetch`, `xch_mudtext`, the
+  `xch_sound`/`xch_alert`/`xch_speech` family, the `xch_mode` switches, and an `<img>` carrying
+  `xch_cmd`, `xch_hint` or `xch_graph` — from the client's own tag and attribute tables. They render as
+  Pueblo tags for `Pueblo`, as an image or a span for `Html` where one fits, and as nothing at all
+  everywhere else, carrier included.
+  - Plain HTML stays `HtmlMarkup`'s (Pueblo reads an HTML subset), and styling and links stay
+    `AnsiMarkup`'s, which already writes each dialect's own form. Only what is Pueblo's alone is here,
+    so nothing about the existing kinds changes.
+
 - `MarkupText.GraphemeCount`, lazy `EnumerateGraphemes()`, and `SubstringGraphemes(start[, count])`
   preserve all markup layers while counting and extracting whole extended grapheme clusters.
 - Allocation-free `Graphemes.Count` and `Graphemes.Enumerate` expose cluster counts and UTF-16 ranges.
@@ -74,6 +121,16 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **`MarkupString.Pueblo`, a new package: Pueblo's own extensions.** `PuebloElements` builds the
+  `xch_` vocabulary a Pueblo client reads — `xch_pane`, `xch_page`, `xch_prefetch`, `xch_mudtext`, the
+  `xch_sound`/`xch_alert`/`xch_speech` family, the `xch_mode` switches, and an `<img>` carrying
+  `xch_cmd`, `xch_hint` or `xch_graph` — from the client's own tag and attribute tables. They render as
+  Pueblo tags for `Pueblo`, as an image or a span for `Html` where one fits, and as nothing at all
+  everywhere else, carrier included.
+  - Plain HTML stays `HtmlMarkup`'s (Pueblo reads an HTML subset), and styling and links stay
+    `AnsiMarkup`'s, which already writes each dialect's own form. Only what is Pueblo's alone is here,
+    so nothing about the existing kinds changes.
+
 - A column layout engine in `MarkupString.Layout`. `ColumnFormat` describes a column — how its
   text is shaped into lines, how those lines are drawn, and how it behaves among its neighbours
   — and is composed with `with`. `MarkupText.FormatColumn` draws one; `TextLayout.Rows` and
@@ -103,6 +160,16 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **`MarkupString.Pueblo`, a new package: Pueblo's own extensions.** `PuebloElements` builds the
+  `xch_` vocabulary a Pueblo client reads — `xch_pane`, `xch_page`, `xch_prefetch`, `xch_mudtext`, the
+  `xch_sound`/`xch_alert`/`xch_speech` family, the `xch_mode` switches, and an `<img>` carrying
+  `xch_cmd`, `xch_hint` or `xch_graph` — from the client's own tag and attribute tables. They render as
+  Pueblo tags for `Pueblo`, as an image or a span for `Html` where one fits, and as nothing at all
+  everywhere else, carrier included.
+  - Plain HTML stays `HtmlMarkup`'s (Pueblo reads an HTML subset), and styling and links stay
+    `AnsiMarkup`'s, which already writes each dialect's own form. Only what is Pueblo's alone is here,
+    so nothing about the existing kinds changes.
+
 - `AnsiCss.Fixed` in `MarkupString.Ansi` — the stylesheet for the `ms-*` classes. Every one of
   those classes is written by this package's HTML emitter, so a consumer rendering HTML with
   `MarkupString` + `MarkupString.Ansi` alone can now reach the rules; in 1.0.0 they existed only in
@@ -119,6 +186,16 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **`MarkupString.Pueblo`, a new package: Pueblo's own extensions.** `PuebloElements` builds the
+  `xch_` vocabulary a Pueblo client reads — `xch_pane`, `xch_page`, `xch_prefetch`, `xch_mudtext`, the
+  `xch_sound`/`xch_alert`/`xch_speech` family, the `xch_mode` switches, and an `<img>` carrying
+  `xch_cmd`, `xch_hint` or `xch_graph` — from the client's own tag and attribute tables. They render as
+  Pueblo tags for `Pueblo`, as an image or a span for `Html` where one fits, and as nothing at all
+  everywhere else, carrier included.
+  - Plain HTML stays `HtmlMarkup`'s (Pueblo reads an HTML subset), and styling and links stay
+    `AnsiMarkup`'s, which already writes each dialect's own form. Only what is Pueblo's alone is here,
+    so nothing about the existing kinds changes.
+
 - `MarkupText` — immutable text plus coalesced, non-overlapping runs of layered markup, with
   slicing, searching, splitting, trimming, splicing, padding, centring and joining that carry the
   markup with them.
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..ef6eb37 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]);
+// One of MXP's own elements: a tag in MXP, an element in HTML, and nothing anywhere else — the
+// carrier included, which is the part a trimmed build could get wrong.
+var sound = MxpElements.Sound("door.wav", volume: 80, url: "https://example.test/sounds/");
+
+// And Pueblo's own vocabulary, which the same text carries for a Pueblo client and nobody else.
+var pueblo = PuebloElements.Sound("door.wav", volume: 80);
+
+var text = MarkupText.Concat([red, wide, nested, MarkupText.Space, link, MarkupText.Space, command, sound, pueblo]);
 
 MarkupFormat[] formats =
 [
diff --git a/MarkupString.Html/README.md b/MarkupString.Html/README.md
index 6c547be..dbb2782 100644
--- a/MarkupString.Html/README.md
+++ b/MarkupString.Html/README.md
@@ -18,6 +18,12 @@ its body untouched.
 dotnet add package MarkupString.Html
 ```
 
+It is one of MarkupString's three **tag dialects**, beside
+[`MarkupString.Mxp`](https://www.nuget.org/packages/MarkupString.Mxp) and
+[`MarkupString.Pueblo`](https://www.nuget.org/packages/MarkupString.Pueblo), which carry those two
+clients' own vocabularies. This one is HTML: what a browser reads, and what Pueblo reads as its own
+subset.
+
 ## Usage
 
 ```csharp
diff --git a/MarkupString.Mxp/Emitters/MxpElementEmitter.cs b/MarkupString.Mxp/Emitters/MxpElementEmitter.cs
new file mode 100644
index 0000000..0680f30
--- /dev/null
+++ b/MarkupString.Mxp/Emitters/MxpElementEmitter.cs
@@ -0,0 +1,92 @@
+using System.Buffers;
+
+namespace MarkupString.Mxp;
+
+/// <summary>
+/// Writes an <see cref="MxpElement"/> as the MXP tag it is: <c>&lt;SOUND door.wav V=80&gt;</c> for one
+/// that stands alone, and <c>&lt;FRAME …&gt;body&lt;/FRAME&gt;</c> for one that wraps content.
+/// </summary>
+/// <remarks>
+/// The carrier a standalone element rides on is dropped rather than written: the tag stands in its
+/// place, and a zero-width space left behind would travel to clients that never asked for one.
+/// </remarks>
+public sealed class MxpElementEmitter : IMarkupEmitter
+{
+	private readonly Func<MxpElement, bool>? _supports;
+
+	/// <summary>An emitter that writes every element, for a connection whose client was never asked.</summary>
+	public static readonly MxpElementEmitter Instance = new(null);
+
+	/// <summary>
+	/// An emitter that writes only the elements <paramref name="supports"/> accepts. MXP's
+	/// <c>&lt;SUPPORT&gt;</c> exchange is what answers that question, and the answer belongs to a
+	/// connection rather than to a registry, so the predicate is the consumer's — usually a lookup into
+	/// what one client replied.
+	/// </summary>
+	/// <remarks>
+	/// An element the predicate refuses is written the way a format without MXP writes it: nothing for one
+	/// that stands alone, and the content alone for one that wraps. That second half is the point of
+	/// asking — a <c>FRAME</c> a client cannot open would otherwise take the text that followed it with
+	/// it.
+	/// </remarks>
+	public MxpElementEmitter(Func<MxpElement, bool>? supports)
+	{
+		_supports = supports;
+	}
+
+	/// <inheritdoc/>
+	public Type MarkupType => typeof(MxpElement);
+
+	/// <inheritdoc/>
+	public MarkupFormat Format => MarkupFormat.Mxp;
+
+	/// <inheritdoc/>
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(markup);
+		ArgumentNullException.ThrowIfNull(output);
+
+		var element = (MxpElement)markup;
+		if (_supports is not null && !_supports(element))
+		{
+			if (element.WrapsContent) output.Write(body);
+			return;
+		}
+
+		output.Write(element.ToString());
+
+		if (!element.WrapsContent) return;
+
+		output.Write(body);
+		output.Write("</");
+		output.Write(element.Name);
+		output.Write(">");
+	}
+}
+
+/// <summary>
+/// Writes an <see cref="MxpElement"/> for a format that has no MXP: the body for an element that wraps
+/// content, and nothing at all for one that stands alone, carrier included.
+/// </summary>
+/// <remarks>
+/// Registered for every format this package does not translate, so the same text can go to every client:
+/// a terminal is not sent a tag it would show as text, and it is not sent the zero-width space the tag
+/// rode on either.
+/// </remarks>
+public sealed class MxpSilentEmitter(MarkupFormat format) : IMarkupEmitter
+{
+	/// <inheritdoc/>
+	public Type MarkupType => typeof(MxpElement);
+
+	/// <inheritdoc/>
+	public MarkupFormat Format { get; } = format;
+
+	/// <inheritdoc/>
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(markup);
+		ArgumentNullException.ThrowIfNull(output);
+
+		if (((MxpElement)markup).WrapsContent) output.Write(body);
+	}
+}
diff --git a/MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs b/MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs
new file mode 100644
index 0000000..772c8aa
--- /dev/null
+++ b/MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs
@@ -0,0 +1,160 @@
+using System.Buffers;
+using System.Net;
+
+namespace MarkupString.Mxp;
+
+/// <summary>
+/// Writes an <see cref="MxpElement"/> as the nearest thing a browser has, for the handful that have one:
+/// an image, a sound, a gauge, status text and a frame. Everything else writes nothing, as it does for a
+/// terminal. An <c>&lt;audio&gt;</c> element is standard HTML, not a Pueblo tag; it is written without
+/// <c>autoplay</c>, because a browser refuses that until the person has interacted with the page.
+/// </summary>
+/// <remarks>
+/// <para>Each carries its MXP name in a <c>data-mxp</c> attribute and an <c>ms-mxp-*</c> class, so a page
+/// can find them, style them, or take over an element this emitter renders plainly. A page that wants
+/// none of it registers <see cref="MxpSilentEmitter"/> for <see cref="MarkupFormat.Html"/> instead.</para>
+/// <para>A source address is written only when it is an absolute <c>http</c> or <c>https</c> URL. MXP's <c>FName</c> is a file on the game's own sound or
+/// image directory, which a browser has no way to resolve, so an element with no <c>URL</c> of its own
+/// renders as its caption rather than a broken fetch.</para>
+/// </remarks>
+public sealed class MxpHtmlEmitter : IMarkupEmitter
+{
+	/// <summary>The one instance; the emitter carries no state.</summary>
+	public static readonly MxpHtmlEmitter Instance = new();
+
+	private MxpHtmlEmitter()
+	{
+	}
+
+	/// <inheritdoc/>
+	public Type MarkupType => typeof(MxpElement);
+
+	/// <inheritdoc/>
+	public MarkupFormat Format => MarkupFormat.Html;
+
+	/// <inheritdoc/>
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(markup);
+		ArgumentNullException.ThrowIfNull(output);
+
+		var element = (MxpElement)markup;
+		switch (element.Name.ToUpperInvariant())
+		{
+			case "IMAGE":
+				WriteImage(element, output);
+				return;
+			case "SOUND" or "MUSIC":
+				WriteAudio(element, output);
+				return;
+			case "GAUGE":
+				WriteGauge(element, output);
+				return;
+			case "STAT":
+				WriteStat(element, output);
+				return;
+			case "FRAME" or "VAR":
+				WriteWrapper(element, body, output);
+				return;
+			default:
+				if (element.WrapsContent) output.Write(body);
+				return;
+		}
+	}
+
+	private static void WriteImage(MxpElement element, IBufferWriter<char> output)
+	{
+		var source = Address(element, "URL");
+		if (source is null) return;
+
+		output.Write("<img class=\"ms-mxp-image\" data-mxp=\"IMAGE\" src=\"");
+		output.Write(WebUtility.HtmlEncode(source));
+		output.Write("\" alt=\"");
+		output.Write(WebUtility.HtmlEncode(Positional(element) ?? string.Empty));
+		output.Write("\">");
+	}
+
+	private static void WriteAudio(MxpElement element, IBufferWriter<char> output)
+	{
+		var source = Address(element, "U");
+		if (source is null) return;
+
+		output.Write("<audio class=\"ms-mxp-");
+		output.Write(element.Name.ToLowerInvariant());
+		output.Write("\" data-mxp=\"");
+		output.Write(element.Name.ToUpperInvariant());
+		output.Write("\" src=\"");
+		output.Write(WebUtility.HtmlEncode(source));
+
+		// No autoplay: a browser refuses audible autoplay until the person has interacted with the page,
+		// so it would play nothing and say nothing about why. Whether this sounds, and when, is the page's
+		// to decide from the data-mxp attribute — as it is for a bell.
+		output.Write("\" preload=\"none\"></audio>");
+	}
+
+	private static void WriteGauge(MxpElement element, IBufferWriter<char> output)
+	{
+		// The entity names are the client's to resolve, and a browser holds none of them, so the page is
+		// given the names and draws the bar itself.
+		output.Write("<span class=\"ms-mxp-gauge\" data-mxp=\"GAUGE\" data-entity=\"");
+		output.Write(WebUtility.HtmlEncode(Positional(element) ?? string.Empty));
+		output.Write("\" data-max=\"");
+		output.Write(WebUtility.HtmlEncode(Named(element, "MAX") ?? string.Empty));
+		output.Write("\">");
+		output.Write(WebUtility.HtmlEncode(Named(element, "CAPTION") ?? Positional(element) ?? string.Empty));
+		output.Write("</span>");
+	}
+
+	private static void WriteStat(MxpElement element, IBufferWriter<char> output)
+	{
+		output.Write("<span class=\"ms-mxp-stat\" data-mxp=\"STAT\" data-entity=\"");
+		output.Write(WebUtility.HtmlEncode(Positional(element) ?? string.Empty));
+		output.Write("\">");
+		output.Write(WebUtility.HtmlEncode(Named(element, "CAPTION") ?? Positional(element) ?? string.Empty));
+		output.Write("</span>");
+	}
+
+	private static void WriteWrapper(MxpElement element, ReadOnlySpan<char> body, IBufferWriter<char> output)
+	{
+		output.Write("<span class=\"ms-mxp-");
+		output.Write(element.Name.ToLowerInvariant());
+		output.Write("\" data-mxp=\"");
+		output.Write(element.Name.ToUpperInvariant());
+		output.Write("\" data-name=\"");
+		output.Write(WebUtility.HtmlEncode(Positional(element) ?? string.Empty));
+		output.Write("\">");
+		output.Write(body);
+		output.Write("</span>");
+	}
+
+	private static string? Positional(MxpElement element)
+	{
+		foreach (var argument in element.Arguments)
+		{
+			if (argument.Name is null) return argument.Value;
+		}
+
+		return null;
+	}
+
+	private static string? Named(MxpElement element, string name)
+	{
+		foreach (var argument in element.Arguments)
+		{
+			if (string.Equals(argument.Name, name, StringComparison.OrdinalIgnoreCase)) return argument.Value;
+		}
+
+		return null;
+	}
+
+	/// <summary>The element's own address, when it gave one a browser can fetch.</summary>
+	private static string? Address(MxpElement element, string name)
+	{
+		var value = Named(element, name);
+		if (value is null) return null;
+
+		return Uri.TryCreate(value, UriKind.Absolute, out var uri) && uri.Scheme is "http" or "https"
+			? value
+			: null;
+	}
+}
diff --git a/MarkupString.Mxp/MarkupString.Mxp.csproj b/MarkupString.Mxp/MarkupString.Mxp.csproj
new file mode 100644
index 0000000..5c1f54d
--- /dev/null
+++ b/MarkupString.Mxp/MarkupString.Mxp.csproj
@@ -0,0 +1,25 @@
+<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>
+    <Description>MXP's own elements for MarkupString — sounds, images, gauges, status text, frames and the rest — written as MXP tags for a client that negotiated them, as the nearest HTML for a browser, and as nothing at all for a client that has neither.</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/MxpElement.cs b/MarkupString.Mxp/MxpElement.cs
new file mode 100644
index 0000000..7857383
--- /dev/null
+++ b/MarkupString.Mxp/MxpElement.cs
@@ -0,0 +1,101 @@
+using System.Collections.Immutable;
+using System.Text;
+
+namespace MarkupString.Mxp;
+
+/// <summary>One argument of an <see cref="MxpElement"/>: positional when <see cref="Name"/> is null.</summary>
+/// <param name="Name">The argument's name, or <see langword="null"/> for a positional one.</param>
+/// <param name="Value">The value, unquoted and unencoded; the empty string for a flag such as <c>ISMAP</c>.</param>
+public readonly record struct MxpArgument(string? Name, string Value)
+{
+	/// <summary>The argument as it is written in a tag, quoted when the value needs it.</summary>
+	public override string ToString() =>
+		Name is null ? Quote(Value) : Value.Length == 0 ? Name : Name + "=" + Quote(Value);
+
+	/// <summary>
+	/// MXP separates arguments with whitespace and reads a quoted value as one, so a value carrying
+	/// whitespace or a quote of its own is quoted and its quotes written as entities. Everything else is
+	/// left as the caller wrote it.
+	/// </summary>
+	private static string Quote(string value)
+	{
+		if (value.Length == 0) return "\"\"";
+
+		var needsQuotes = false;
+		foreach (var c in value)
+		{
+			if (c is '"' or '\'' || char.IsWhiteSpace(c))
+			{
+				needsQuotes = true;
+				break;
+			}
+		}
+
+		return needsQuotes ? "\"" + value.Replace("\"", "&quot;") + "\"" : value;
+	}
+}
+
+/// <summary>
+/// One of MXP's own elements — a sound, an image, a gauge, a frame — as a markup layer.
+/// <see cref="MxpElements"/> builds the ones the specification defines; this type is also the way to
+/// write one it does not.
+/// </summary>
+/// <remarks>
+/// <para>An element that wraps nothing (<c>SOUND</c>, <c>IMAGE</c>, <c>EXPIRE</c>, …) rides on a
+/// zero-width carrier, the way a bell rides on its own character: it is a point
+/// in the text rather than a property of any of it. An element that wraps content (<c>FRAME</c>,
+/// <c>VAR</c>) marks the content it applies to and is closed after it.</para>
+/// <para>A format that cannot express an element writes nothing at all, carrier included, so the same
+/// text is safe to send to every client. What a client can actually render is not asked here: MXP's
+/// <c>&lt;SUPPORT&gt;</c> exchange answers that, and deciding what to do about the answer belongs to the
+/// application.</para>
+/// </remarks>
+/// <param name="Name">The element's name, e.g. <c>SOUND</c>.</param>
+/// <param name="Arguments">Its arguments, in the order they are written.</param>
+/// <param name="WrapsContent">Whether the element closes after the text it marks, rather than standing alone.</param>
+public sealed record MxpElement(string Name, ImmutableArray<MxpArgument> Arguments, bool WrapsContent) : IMarkup
+{
+	/// <summary>
+	/// The character a standalone element rides on: a zero-width space, which measures nothing and is
+	/// never written out — every format either writes the element or writes nothing.
+	/// </summary>
+	public const string Carrier = "\u200b";
+
+	/// <summary>Creates an element and the text it stands in, for one that wraps nothing.</summary>
+	/// <exception cref="ArgumentException"><paramref name="name"/> is not an element name.</exception>
+	public static MarkupText Standalone(string name, params ReadOnlySpan<MxpArgument> arguments) =>
+		MarkupText.Wrap(new MxpElement(Checked(name), [.. arguments], false), Carrier);
+
+	/// <summary>Creates an element wrapping <paramref name="content"/>.</summary>
+	/// <exception cref="ArgumentException"><paramref name="name"/> is not an element name.</exception>
+	public static MarkupText Wrapping(string name, MarkupText content, params ReadOnlySpan<MxpArgument> arguments) =>
+		MarkupText.Wrap(new MxpElement(Checked(name), [.. arguments], true), content);
+
+	/// <summary>The tag as MXP reads it: <c>&lt;NAME arg arg=value&gt;</c>.</summary>
+	public override string ToString()
+	{
+		var written = new StringBuilder("<").Append(Name);
+		foreach (var argument in Arguments) written.Append(' ').Append(argument.ToString());
+		return written.Append('>').ToString();
+	}
+
+	/// <summary>An element name is a letter, then letters, digits or hyphens — the same shape a tag has.</summary>
+	public static bool IsValidName(string name)
+	{
+		if (string.IsNullOrEmpty(name) || !IsAsciiLetter(name[0])) return false;
+
+		foreach (var c in name)
+		{
+			if (!IsAsciiLetter(c) && !char.IsAsciiDigit(c) && c != '-') return false;
+		}
+
+		return true;
+	}
+
+	private static bool IsAsciiLetter(char c) => char.IsAsciiLetter(c);
+
+	private static string Checked(string name) =>
+		IsValidName(name)
+			? name
+			: throw new ArgumentException($"'{name}' is not an element name.", nameof(name));
+}
diff --git a/MarkupString.Mxp/MxpElementCodec.cs b/MarkupString.Mxp/MxpElementCodec.cs
new file mode 100644
index 0000000..e6cbaa3
--- /dev/null
+++ b/MarkupString.Mxp/MxpElementCodec.cs
@@ -0,0 +1,68 @@
+using System.Collections.Immutable;
+using System.Text.Json;
+
+namespace MarkupString.Mxp;
+
+/// <summary>
+/// Reads and writes <see cref="MxpElement"/> in the serializer's envelope, under kind <c>"mxp"</c>.
+/// Keys are <c>e</c> (the element name), <c>w</c> (whether it wraps content, written only when it does)
+/// and <c>a</c> (the arguments, each an array of name — null for a positional one — and value).
+/// </summary>
+public sealed class MxpElementCodec : IMarkupCodec
+{
+	/// <inheritdoc/>
+	public string Kind => "mxp";
+
+	/// <inheritdoc/>
+	public Type MarkupType => typeof(MxpElement);
+
+	/// <inheritdoc/>
+	public void Write(Utf8JsonWriter writer, IMarkup markup)
+	{
+		ArgumentNullException.ThrowIfNull(writer);
+		ArgumentNullException.ThrowIfNull(markup);
+
+		var element = (MxpElement)markup;
+		writer.WriteString("e", element.Name);
+		if (element.WrapsContent) writer.WriteBoolean("w", true);
+
+		if (element.Arguments.Length == 0) return;
+
+		writer.WriteStartArray("a");
+		foreach (var argument in element.Arguments)
+		{
+			writer.WriteStartArray();
+			if (argument.Name is null) writer.WriteNullValue();
+			else writer.WriteStringValue(argument.Name);
+			writer.WriteStringValue(argument.Value);
+			writer.WriteEndArray();
+		}
+
+		writer.WriteEndArray();
+	}
+
+	/// <inheritdoc/>
+	public IMarkup Read(JsonElement element)
+	{
+		var name = element.TryGetProperty("e", out var e) && e.ValueKind == JsonValueKind.String
+			? e.GetString() ?? string.Empty
+			: string.Empty;
+
+		var wraps = element.TryGetProperty("w", out var w) && w.ValueKind == JsonValueKind.True;
+
+		var arguments = ImmutableArray.CreateBuilder<MxpArgument>();
+		if (element.TryGetProperty("a", out var a) && a.ValueKind == JsonValueKind.Array)
+		{
+			foreach (var pair in a.EnumerateArray())
+			{
+				if (pair.ValueKind != JsonValueKind.Array || pair.GetArrayLength() != 2) continue;
+
+				var argumentName = pair[0].ValueKind == JsonValueKind.String ? pair[0].GetString() : null;
+				var value = pair[1].ValueKind == JsonValueKind.String ? pair[1].GetString() ?? string.Empty : string.Empty;
+				arguments.Add(new MxpArgument(argumentName, value));
+			}
+		}
+
+		return new MxpElement(name, [.. arguments], wraps);
+	}
+}
diff --git a/MarkupString.Mxp/MxpElements.cs b/MarkupString.Mxp/MxpElements.cs
new file mode 100644
index 0000000..643181d
--- /dev/null
+++ b/MarkupString.Mxp/MxpElements.cs
@@ -0,0 +1,218 @@
+using System.Collections.Immutable;
+using System.Globalization;
+
+namespace MarkupString.Mxp;
+
+/// <summary>Where an <see cref="MxpElements.Image"/> sits against the text around it.</summary>
+public enum MxpAlign
+{
+	/// <summary>Unset; the client decides.</summary>
+	Default,
+	Left,
+	Right,
+	Top,
+	Middle,
+	Bottom,
+}
+
+/// <summary>What a <see cref="MxpElements.Frame"/> call does to the frame it names.</summary>
+public enum MxpFrameAction
+{
+	/// <summary>Create the frame, or show it again.</summary>
+	Open,
+	/// <summary>Close it.</summary>
+	Close,
+	/// <summary>Send everything that follows to it.</summary>
+	Redirect,
+}
+
+/// <summary>
+/// MXP's own elements, as the specification defines them: the ones that play a sound, show an image,
+/// draw a gauge, open a frame, and the rest.
+/// </summary>
+/// <remarks>
+/// Each returns the text the element stands in, so it composes with everything else:
+/// <c>MarkupText.Concat(MxpElements.Sound("door.wav"), MarkupText.Plain("The door creaks."))</c>. An
+/// argument left unset is not written, so a client sees the specification's own defaults.
+/// </remarks>
+public static class MxpElements
+{
+	/// <summary>
+	/// <c>&lt;SOUND&gt;</c> — plays a sound once. <paramref name="volume"/>, <paramref name="loops"/> and
+	/// <paramref name="priority"/> are MXP's <c>V</c>, <c>L</c> and <c>P</c>; <paramref name="type"/> and
+	/// <paramref name="url"/> its <c>T</c> and <c>U</c>. Pass <paramref name="file"/> as <c>Off</c> to stop
+	/// whatever is playing.
+	/// </summary>
+	public static MarkupText Sound(
+		string file, int? volume = null, int? loops = null, int? priority = null, string? type = null, string? url = null) =>
+		MxpElement.Standalone("SOUND", [.. Media(file, volume, loops, priority, type, url, null)]);
+
+	/// <summary>
+	/// <c>&lt;MUSIC&gt;</c> — plays music, which differs from a sound in that a client keeps it going.
+	/// <paramref name="continues"/> is MXP's <c>C</c>: whether a repeat of the same file plays on rather
+	/// than restarting.
+	/// </summary>
+	public static MarkupText Music(
+		string file, int? volume = null, int? loops = null, bool? continues = null, string? type = null, string? url = null) =>
+		MxpElement.Standalone("MUSIC", [.. Media(file, volume, loops, null, type, url, continues)]);
+
+	/// <summary>
+	/// <c>&lt;IMAGE&gt;</c> — shows an image. <paramref name="height"/>, <paramref name="width"/>,
+	/// <paramref name="horizontalSpace"/> and <paramref name="verticalSpace"/> are MXP's <c>H</c>,
+	/// <c>W</c>, <c>HSPACE</c> and <c>VSPACE</c>; <paramref name="isMap"/> its <c>ISMAP</c>, which makes
+	/// the image clickable.
+	/// </summary>
+	public static MarkupText Image(
+		string file,
+		string? url = null,
+		string? type = null,
+		string? height = null,
+		string? width = null,
+		string? horizontalSpace = null,
+		string? verticalSpace = null,
+		MxpAlign align = MxpAlign.Default,
+		bool isMap = false)
+	{
+		var arguments = ImmutableArray.CreateBuilder<MxpArgument>();
+		arguments.Add(new MxpArgument(null, file));
+		Add(arguments, "URL", url);
+		Add(arguments, "T", type);
+		Add(arguments, "H", height);
+		Add(arguments, "W", width);
+		Add(arguments, "HSPACE", horizontalSpace);
+		Add(arguments, "VSPACE", verticalSpace);
+		if (align != MxpAlign.Default) Add(arguments, "ALIGN", align.ToString().ToUpperInvariant());
+		if (isMap) arguments.Add(new MxpArgument("ISMAP", string.Empty));
+		return MxpElement.Standalone("IMAGE", [.. arguments]);
+	}
+
+	/// <summary>
+	/// <c>&lt;GAUGE&gt;</c> — draws a bar from an entity the client already holds, so it redraws itself as
+	/// that entity changes. <paramref name="entity"/> and <paramref name="max"/> name entities, not values.
+	/// </summary>
+	public static MarkupText Gauge(string entity, string? max = null, string? caption = null, string? colour = null)
+	{
+		var arguments = ImmutableArray.CreateBuilder<MxpArgument>();
+		arguments.Add(new MxpArgument(null, entity));
+		Add(arguments, "MAX", max);
+		Add(arguments, "CAPTION", caption);
+		Add(arguments, "COLOR", colour);
+		return MxpElement.Standalone("GAUGE", [.. arguments]);
+	}
+
+	/// <summary><c>&lt;STAT&gt;</c> — the same, as status-bar text rather than a bar.</summary>
+	public static MarkupText Stat(string entity, string? max = null, string? caption = null)
+	{
+		var arguments = ImmutableArray.CreateBuilder<MxpArgument>();
+		arguments.Add(new MxpArgument(null, entity));
+		Add(arguments, "MAX", max);
+		Add(arguments, "CAPTION", caption);
+		return MxpElement.Standalone("STAT", [.. arguments]);
+	}
+
+	/// <summary>
+	/// <c>&lt;EXPIRE&gt;</c> — takes back the links written under <paramref name="name"/>, or every link so
+	/// far when no name is given, so an exit that has closed stops being clickable.
+	/// </summary>
+	public static MarkupText Expire(string? name = null) =>
+		name is null ? MxpElement.Standalone("EXPIRE") : MxpElement.Standalone("EXPIRE", new MxpArgument(null, name));
+
+	/// <summary><c>&lt;USER&gt;</c> — asks the client to send the username it stored for this world.</summary>
+	public static MarkupText User() => MxpElement.Standalone("USER");
+
+	/// <summary><c>&lt;PASSWORD&gt;</c> — asks the client to send the password it stored for this world.</summary>
+	public static MarkupText Password() => MxpElement.Standalone("PASSWORD");
+
+	/// <summary><c>&lt;NOBR&gt;</c> — the newline after this does not break the line.</summary>
+	public static MarkupText NoBreak() => MxpElement.Standalone("NOBR");
+
+	/// <summary><c>&lt;SBR&gt;</c> — a soft break: a space the client may wrap at.</summary>
+	public static MarkupText SoftBreak() => MxpElement.Standalone("SBR");
+
+	/// <summary>
+	/// <c>&lt;RELOCATE&gt;</c> — tells the client to connect somewhere else. <paramref name="quiet"/> is
+	/// MXP's <c>QUIET</c>, which asks it not to say so.
+	/// </summary>
+	public static MarkupText Relocate(string host, int port, bool quiet = false)
+	{
+		var arguments = ImmutableArray.CreateBuilder<MxpArgument>();
+		arguments.Add(new MxpArgument(null, host));
+		arguments.Add(new MxpArgument(null, port.ToString(CultureInfo.InvariantCulture)));
+		if (quiet) arguments.Add(new MxpArgument("QUIET", string.Empty));
+		return MxpElement.Standalone("RELOCATE", [.. arguments]);
+	}
+
+	/// <summary>
+	/// <c>&lt;FRAME&gt;</c> — opens, closes or redirects a window of its own, wrapping the text that goes
+	/// to it. Everything but <paramref name="name"/> and <paramref name="action"/> is layout the client
+	/// applies when it creates the frame.
+	/// </summary>
+	public static MarkupText Frame(
+		MarkupText content,
+		string name,
+		MxpFrameAction action = MxpFrameAction.Open,
+		string? title = null,
+		bool isInternal = false,
+		MxpAlign align = MxpAlign.Default,
+		string? left = null,
+		string? top = null,
+		string? width = null,
+		string? height = null,
+		bool? scrolling = null,
+		bool floating = false)
+	{
+		var arguments = ImmutableArray.CreateBuilder<MxpArgument>();
+		arguments.Add(new MxpArgument(null, name));
+		Add(arguments, "ACTION", action.ToString().ToUpperInvariant());
+		Add(arguments, "TITLE", title);
+		if (isInternal) arguments.Add(new MxpArgument("INTERNAL", string.Empty));
+		if (align != MxpAlign.Default) Add(arguments, "ALIGN", align.ToString().ToUpperInvariant());
+		Add(arguments, "LEFT", left);
+		Add(arguments, "TOP", top);
+		Add(arguments, "WIDTH", width);
+		Add(arguments, "HEIGHT", height);
+		if (scrolling is { } scrolls) Add(arguments, "SCROLLING", scrolls ? "yes" : "no");
+		if (floating) arguments.Add(new MxpArgument("FLOATING", string.Empty));
+		return MxpElement.Wrapping("FRAME", content, [.. arguments]);
+	}
+
+	/// <summary>
+	/// <c>&lt;VAR&gt;</c> — shows <paramref name="value"/> and keeps it in the client under
+	/// <paramref name="name"/>, where a <see cref="Gauge"/> or a <see cref="Stat"/> can read it.
+	/// </summary>
+	public static MarkupText Var(
+		MarkupText value,
+		string name,
+		string? description = null,
+		bool isPrivate = false,
+		bool publish = false,
+		bool delete = false)
+	{
+		var arguments = ImmutableArray.CreateBuilder<MxpArgument>();
+		arguments.Add(new MxpArgument(null, name));
+		Add(arguments, "DESC", description);
+		if (isPrivate) arguments.Add(new MxpArgument("PRIVATE", string.Empty));
+		if (publish) arguments.Add(new MxpArgument("PUBLISH", string.Empty));
+		if (delete) arguments.Add(new MxpArgument("DELETE", string.Empty));
+		return MxpElement.Wrapping("VAR", value, [.. arguments]);
+	}
+
+	private static ImmutableArray<MxpArgument> Media(
+		string file, int? volume, int? loops, int? priority, string? type, string? url, bool? continues)
+	{
+		var arguments = ImmutableArray.CreateBuilder<MxpArgument>();
+		arguments.Add(new MxpArgument(null, file));
+		if (volume is { } v) Add(arguments, "V", v.ToString(CultureInfo.InvariantCulture));
+		if (loops is { } l) Add(arguments, "L", l.ToString(CultureInfo.InvariantCulture));
+		if (priority is { } p) Add(arguments, "P", p.ToString(CultureInfo.InvariantCulture));
+		if (continues is { } c) Add(arguments, "C", c ? "1" : "0");
+		Add(arguments, "T", type);
+		Add(arguments, "U", url);
+		return [.. arguments];
+	}
+
+	private static void Add(ImmutableArray<MxpArgument>.Builder arguments, string name, string? value)
+	{
+		if (value is not null) arguments.Add(new MxpArgument(name, value));
+	}
+}
diff --git a/MarkupString.Mxp/MxpRegistration.cs b/MarkupString.Mxp/MxpRegistration.cs
new file mode 100644
index 0000000..394fed5
--- /dev/null
+++ b/MarkupString.Mxp/MxpRegistration.cs
@@ -0,0 +1,41 @@
+namespace MarkupString.Mxp;
+
+/// <summary>Installs this package's emitters and codec into a <see cref="MarkupRegistry"/>.</summary>
+public static class MxpRegistration
+{
+	/// <summary>
+	/// Returns a registry that writes an <see cref="MxpElement"/> as an MXP tag in
+	/// <see cref="MarkupFormat.Mxp"/>, as the nearest HTML in <see cref="MarkupFormat.Html"/>, and as
+	/// nothing in every other format — carrier included, so a terminal is sent neither a tag it would show
+	/// as text nor the zero-width space it rode on.
+	/// </summary>
+	/// <remarks>
+	/// A registry is cheap to build, so one per connection — carrying that client's answers — costs a
+	/// dictionary copy, and one built without <paramref name="supports"/> serves every client that was
+	/// never asked.
+	/// To keep MXP's elements out of the browser entirely, add
+	/// <c>new MxpSilentEmitter(MarkupFormat.Html)</c> after this; the last emitter registered for a format
+	/// wins.
+	/// </remarks>
+	/// <param name="registry">The registry to add to.</param>
+	/// <param name="supports">
+	/// Which elements this connection's client said it can render, from MXP's <c>&lt;SUPPORT&gt;</c>
+	/// exchange. Null writes every element, which is the right answer for a client that was never asked.
+	/// An element it refuses is written as a format without MXP writes it: nothing for one that stands
+	/// alone, and the content alone for one that wraps — so a <c>FRAME</c> a client cannot open does not
+	/// take the text that followed it.
+	/// </param>
+	public static MarkupRegistry WithMxp(this MarkupRegistry registry, Func<MxpElement, bool>? supports = null)
+	{
+		ArgumentNullException.ThrowIfNull(registry);
+
+		return registry
+			.With(supports is null ? MxpElementEmitter.Instance : new MxpElementEmitter(supports))
+			.With(MxpHtmlEmitter.Instance)
+			.With(new MxpSilentEmitter(MarkupFormat.Ansi))
+			.With(new MxpSilentEmitter(MarkupFormat.Pueblo))
+			.With(new MxpSilentEmitter(MarkupFormat.Plain))
+			.With(new MxpSilentEmitter(MarkupFormat.BBCode))
+			.With(new MxpElementCodec());
+	}
+}
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..c14bf6b
--- /dev/null
+++ b/MarkupString.Mxp/PublicAPI.Unshipped.txt
@@ -0,0 +1,84 @@
+#nullable enable
+const MarkupString.Mxp.MxpElement.Carrier = "​" -> string!
+MarkupString.Mxp.MxpAlign
+MarkupString.Mxp.MxpAlign.Bottom = 5 -> MarkupString.Mxp.MxpAlign
+MarkupString.Mxp.MxpAlign.Default = 0 -> MarkupString.Mxp.MxpAlign
+MarkupString.Mxp.MxpAlign.Left = 1 -> MarkupString.Mxp.MxpAlign
+MarkupString.Mxp.MxpAlign.Middle = 4 -> MarkupString.Mxp.MxpAlign
+MarkupString.Mxp.MxpAlign.Right = 2 -> MarkupString.Mxp.MxpAlign
+MarkupString.Mxp.MxpAlign.Top = 3 -> MarkupString.Mxp.MxpAlign
+MarkupString.Mxp.MxpArgument
+MarkupString.Mxp.MxpArgument.Deconstruct(out string? Name, out string! Value) -> void
+MarkupString.Mxp.MxpArgument.Equals(MarkupString.Mxp.MxpArgument other) -> bool
+MarkupString.Mxp.MxpArgument.MxpArgument(string? Name, string! Value) -> void
+MarkupString.Mxp.MxpArgument.MxpArgument() -> void
+MarkupString.Mxp.MxpArgument.Name.get -> string?
+MarkupString.Mxp.MxpArgument.Name.init -> void
+MarkupString.Mxp.MxpArgument.Value.get -> string!
+MarkupString.Mxp.MxpArgument.Value.init -> void
+MarkupString.Mxp.MxpElement
+MarkupString.Mxp.MxpElement.Arguments.get -> System.Collections.Immutable.ImmutableArray<MarkupString.Mxp.MxpArgument>
+MarkupString.Mxp.MxpElement.Arguments.init -> void
+MarkupString.Mxp.MxpElement.<Clone>$() -> MarkupString.Mxp.MxpElement!
+MarkupString.Mxp.MxpElementCodec
+MarkupString.Mxp.MxpElementCodec.Kind.get -> string!
+MarkupString.Mxp.MxpElementCodec.MarkupType.get -> System.Type!
+MarkupString.Mxp.MxpElementCodec.MxpElementCodec() -> void
+MarkupString.Mxp.MxpElementCodec.Read(System.Text.Json.JsonElement element) -> MarkupString.IMarkup!
+MarkupString.Mxp.MxpElementCodec.Write(System.Text.Json.Utf8JsonWriter! writer, MarkupString.IMarkup! markup) -> void
+MarkupString.Mxp.MxpElement.Deconstruct(out string! Name, out System.Collections.Immutable.ImmutableArray<MarkupString.Mxp.MxpArgument> Arguments, out bool WrapsContent) -> void
+MarkupString.Mxp.MxpElementEmitter
+MarkupString.Mxp.MxpElementEmitter.Emit(MarkupString.IMarkup! markup, System.ReadOnlySpan<char> body, in MarkupString.EmitContext context, System.Buffers.IBufferWriter<char>! output) -> void
+MarkupString.Mxp.MxpElementEmitter.Format.get -> MarkupString.MarkupFormat!
+MarkupString.Mxp.MxpElementEmitter.MarkupType.get -> System.Type!
+MarkupString.Mxp.MxpElement.Equals(MarkupString.Mxp.MxpElement? other) -> bool
+MarkupString.Mxp.MxpElement.MxpElement(string! Name, System.Collections.Immutable.ImmutableArray<MarkupString.Mxp.MxpArgument> Arguments, bool WrapsContent) -> void
+MarkupString.Mxp.MxpElement.Name.get -> string!
+MarkupString.Mxp.MxpElement.Name.init -> void
+MarkupString.Mxp.MxpElements
+MarkupString.Mxp.MxpElement.WrapsContent.get -> bool
+MarkupString.Mxp.MxpElement.WrapsContent.init -> void
+MarkupString.Mxp.MxpFrameAction
+MarkupString.Mxp.MxpFrameAction.Close = 1 -> MarkupString.Mxp.MxpFrameAction
+MarkupString.Mxp.MxpFrameAction.Open = 0 -> MarkupString.Mxp.MxpFrameAction
+MarkupString.Mxp.MxpFrameAction.Redirect = 2 -> MarkupString.Mxp.MxpFrameAction
+MarkupString.Mxp.MxpHtmlEmitter
+MarkupString.Mxp.MxpHtmlEmitter.Emit(MarkupString.IMarkup! markup, System.ReadOnlySpan<char> body, in MarkupString.EmitContext context, System.Buffers.IBufferWriter<char>! output) -> void
+MarkupString.Mxp.MxpHtmlEmitter.Format.get -> MarkupString.MarkupFormat!
+MarkupString.Mxp.MxpHtmlEmitter.MarkupType.get -> System.Type!
+MarkupString.Mxp.MxpRegistration
+MarkupString.Mxp.MxpSilentEmitter
+MarkupString.Mxp.MxpSilentEmitter.Emit(MarkupString.IMarkup! markup, System.ReadOnlySpan<char> body, in MarkupString.EmitContext context, System.Buffers.IBufferWriter<char>! output) -> void
+MarkupString.Mxp.MxpSilentEmitter.Format.get -> MarkupString.MarkupFormat!
+MarkupString.Mxp.MxpSilentEmitter.MarkupType.get -> System.Type!
+MarkupString.Mxp.MxpSilentEmitter.MxpSilentEmitter(MarkupString.MarkupFormat! format) -> void
+~override MarkupString.Mxp.MxpArgument.Equals(object obj) -> bool
+override MarkupString.Mxp.MxpArgument.GetHashCode() -> int
+override MarkupString.Mxp.MxpArgument.ToString() -> string!
+override MarkupString.Mxp.MxpElement.Equals(object? obj) -> bool
+override MarkupString.Mxp.MxpElement.GetHashCode() -> int
+override MarkupString.Mxp.MxpElement.ToString() -> string!
+static MarkupString.Mxp.MxpArgument.operator !=(MarkupString.Mxp.MxpArgument left, MarkupString.Mxp.MxpArgument right) -> bool
+static MarkupString.Mxp.MxpArgument.operator ==(MarkupString.Mxp.MxpArgument left, MarkupString.Mxp.MxpArgument right) -> bool
+static MarkupString.Mxp.MxpElement.IsValidName(string! name) -> bool
+static MarkupString.Mxp.MxpElement.operator !=(MarkupString.Mxp.MxpElement? left, MarkupString.Mxp.MxpElement? right) -> bool
+static MarkupString.Mxp.MxpElement.operator ==(MarkupString.Mxp.MxpElement? left, MarkupString.Mxp.MxpElement? right) -> bool
+static MarkupString.Mxp.MxpElements.Expire(string? name = null) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.Frame(MarkupString.MarkupText! content, string! name, MarkupString.Mxp.MxpFrameAction action = MarkupString.Mxp.MxpFrameAction.Open, string? title = null, bool isInternal = false, MarkupString.Mxp.MxpAlign align = MarkupString.Mxp.MxpAlign.Default, string? left = null, string? top = null, string? width = null, string? height = null, bool? scrolling = null, bool floating = false) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.Gauge(string! entity, string? max = null, string? caption = null, string? colour = null) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.Image(string! file, string? url = null, string? type = null, string? height = null, string? width = null, string? horizontalSpace = null, string? verticalSpace = null, MarkupString.Mxp.MxpAlign align = MarkupString.Mxp.MxpAlign.Default, bool isMap = false) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.Music(string! file, int? volume = null, int? loops = null, bool? continues = null, string? type = null, string? url = null) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.NoBreak() -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.Password() -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.Relocate(string! host, int port, bool quiet = false) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.SoftBreak() -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.Sound(string! file, int? volume = null, int? loops = null, int? priority = null, string? type = null, string? url = null) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.Stat(string! entity, string? max = null, string? caption = null) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElement.Standalone(string! name, params System.ReadOnlySpan<MarkupString.Mxp.MxpArgument> arguments) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.User() -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElements.Var(MarkupString.MarkupText! value, string! name, string? description = null, bool isPrivate = false, bool publish = false, bool delete = false) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpElement.Wrapping(string! name, MarkupString.MarkupText! content, params System.ReadOnlySpan<MarkupString.Mxp.MxpArgument> arguments) -> MarkupString.MarkupText!
+static MarkupString.Mxp.MxpRegistration.WithMxp(this MarkupString.MarkupRegistry! registry, System.Func<MarkupString.Mxp.MxpElement!, bool>? supports = null) -> MarkupString.MarkupRegistry!
+MarkupString.Mxp.MxpElementEmitter.MxpElementEmitter(System.Func<MarkupString.Mxp.MxpElement!, bool>? supports) -> void
+static readonly MarkupString.Mxp.MxpElementEmitter.Instance -> MarkupString.Mxp.MxpElementEmitter!
+static readonly MarkupString.Mxp.MxpHtmlEmitter.Instance -> MarkupString.Mxp.MxpHtmlEmitter!
diff --git a/MarkupString.Mxp/README.md b/MarkupString.Mxp/README.md
new file mode 100644
index 0000000..8fd3c77
--- /dev/null
+++ b/MarkupString.Mxp/README.md
@@ -0,0 +1,68 @@
+# MarkupString.Mxp
+
+MXP's own elements for [`MarkupString`](https://www.nuget.org/packages/MarkupString): a sound, an image, a gauge, status text, a frame, and the rest of what [MXP](https://www.zuggsoft.com/zmud/mxp.htm) defines beyond styling and links.
+
+```sh
+dotnet add package MarkupString.Mxp
+```
+
+## Usage
+
+```csharp
+MarkupRegistry.Default = MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp();
+
+var line = MarkupText.Concat(
+  MxpElements.Sound("door.wav", volume: 80, url: "https://example.test/sounds/"),
+  MarkupText.Plain("The door creaks open."));
+
+line.Render(MarkupFormat.Mxp);    // <SOUND door.wav V=80 U=https://example.test/sounds/>The door creaks open.
+line.Render(MarkupFormat.Ansi);   // The door creaks open.
+```
+
+An element that wraps nothing is a point in the text, carried the way a bell is; one that wraps content
+(`FRAME`, `VAR`) marks the text it applies to. A format with no MXP writes **nothing at all**, carrier
+included, so the same text is safe to send to every client.
+
+It is one of MarkupString's three **tag dialects**, beside
+[`MarkupString.Html`](https://www.nuget.org/packages/MarkupString.Html) (plain HTML, for browsers) and
+[`MarkupString.Pueblo`](https://www.nuget.org/packages/MarkupString.Pueblo) (Pueblo's `xch_`
+vocabulary). Each writes its own tags; none of them reads another's.
+
+## What each format gets
+
+| | MXP | HTML | everything else |
+|---|---|---|---|
+| `IMAGE` | the tag | `<img>`, when the element carries a URL | nothing |
+| `SOUND`, `MUSIC` | the tag | `<audio>`, when it carries a URL | nothing |
+| `GAUGE`, `STAT` | the tag | a `data-entity` span for the page to draw | nothing |
+| `FRAME`, `VAR` | the tag around its content | a span around its content | the content |
+| `EXPIRE`, `USER`, `PASSWORD`, `NOBR`, `SBR`, `RELOCATE` | the tag | nothing | nothing |
+
+Every HTML element carries its MXP name in `data-mxp` and an `ms-mxp-*` class, so a page can style them
+or take one over. To keep MXP out of the browser entirely, add `new MxpSilentEmitter(MarkupFormat.Html)`
+after `WithMxp()`.
+
+## What the client said it can render
+
+MXP asks with `<SUPPORT>` for a reason, and `WithMxp` takes the answer:
+
+```csharp
+// report is what the client replied, from the telnet layer's <SUPPORT> exchange
+var wire = MarkupRegistry.Default.WithMxp(element => !report.Refuses(element.Name));
+```
+
+An element the predicate refuses is written the way a format without MXP writes it: nothing for one
+that stands alone, and **the content alone** for one that wraps — so a `FRAME` a client cannot open does
+not take the text inside it somewhere the player never sees. With no predicate every element is written,
+which is the right answer for a client that was never asked: never asked is not the same as refused.
+
+## What this package does not decide
+
+Which client you are talking to, and what it answered, belong to the connection — the `<SUPPORT>`
+exchange itself lives in the telnet layer
+([TelnetNegotiationCore](https://github.com/HarryCordewener/TelnetNegotiationCore)). This package renders
+what it is given, and holds it to the answer you hand it.
+
+## Licence
+
+Apache-2.0. Source, guides and issues: [SharpMUSH/MarkupString](https://github.com/SharpMUSH/MarkupString).
diff --git a/MarkupString.Pueblo/Emitters/PuebloElementEmitter.cs b/MarkupString.Pueblo/Emitters/PuebloElementEmitter.cs
new file mode 100644
index 0000000..1edb833
--- /dev/null
+++ b/MarkupString.Pueblo/Emitters/PuebloElementEmitter.cs
@@ -0,0 +1,90 @@
+using System.Buffers;
+
+namespace MarkupString.Pueblo;
+
+/// <summary>
+/// Writes a <see cref="PuebloElement"/> as the Pueblo tag it is: <c>&lt;xch_page clear="text"&gt;</c> for
+/// one that stands alone, and <c>&lt;xch_pane …&gt;body&lt;/xch_pane&gt;</c> for one that wraps content.
+/// </summary>
+/// <remarks>
+/// The carrier a standalone element rides on is dropped rather than written: the tag stands in its
+/// place, and a zero-width space left behind would travel to clients that never asked for one.
+/// </remarks>
+public sealed class PuebloElementEmitter : IMarkupEmitter
+{
+	private readonly Func<PuebloElement, bool>? _supports;
+
+	/// <summary>An emitter that writes every element, for a connection whose client was never asked.</summary>
+	public static readonly PuebloElementEmitter Instance = new(null);
+
+	/// <summary>
+	/// An emitter that writes only the elements <paramref name="supports"/> accepts. Pueblo has no exchange
+	/// that asks a client what it renders — a world learns that from its handshake and its own
+	/// configuration — so this is here for a consumer that knows something the library cannot.
+	/// </summary>
+	/// <remarks>
+	/// An element the predicate refuses is written the way a format without Pueblo writes it: nothing for
+	/// one that stands alone, and the content alone for one that wraps, so a pane a client cannot open
+	/// does not take the text inside it.
+	/// </remarks>
+	public PuebloElementEmitter(Func<PuebloElement, bool>? supports)
+	{
+		_supports = supports;
+	}
+
+	/// <inheritdoc/>
+	public Type MarkupType => typeof(PuebloElement);
+
+	/// <inheritdoc/>
+	public MarkupFormat Format => MarkupFormat.Pueblo;
+
+	/// <inheritdoc/>
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(markup);
+		ArgumentNullException.ThrowIfNull(output);
+
+		var element = (PuebloElement)markup;
+		if (_supports is not null && !_supports(element))
+		{
+			if (element.WrapsContent) output.Write(body);
+			return;
+		}
+
+		output.Write(element.ToString());
+
+		if (!element.WrapsContent) return;
+
+		output.Write(body);
+		output.Write("</");
+		output.Write(element.Name);
+		output.Write(">");
+	}
+}
+
+/// <summary>
+/// Writes an <see cref="PuebloElement"/> for a format that has no Pueblo: the body for an element that wraps
+/// content, and nothing at all for one that stands alone, carrier included.
+/// </summary>
+/// <remarks>
+/// Registered for every format this package does not translate, so the same text can go to every client:
+/// a terminal is not sent a tag it would show as text, and it is not sent the zero-width space the tag
+/// rode on either.
+/// </remarks>
+public sealed class PuebloSilentEmitter(MarkupFormat format) : IMarkupEmitter
+{
+	/// <inheritdoc/>
+	public Type MarkupType => typeof(PuebloElement);
+
+	/// <inheritdoc/>
+	public MarkupFormat Format { get; } = format;
+
+	/// <inheritdoc/>
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(markup);
+		ArgumentNullException.ThrowIfNull(output);
+
+		if (((PuebloElement)markup).WrapsContent) output.Write(body);
+	}
+}
diff --git a/MarkupString.Pueblo/Emitters/PuebloHtmlEmitter.cs b/MarkupString.Pueblo/Emitters/PuebloHtmlEmitter.cs
new file mode 100644
index 0000000..ffa3b84
--- /dev/null
+++ b/MarkupString.Pueblo/Emitters/PuebloHtmlEmitter.cs
@@ -0,0 +1,79 @@
+using System.Buffers;
+using System.Net;
+
+namespace MarkupString.Pueblo;
+
+/// <summary>
+/// Writes a <see cref="PuebloElement"/> as the nearest thing a browser has, for the two that have one:
+/// a picture and a pane. Everything else — the page instruction, the mode switches, prefetching, the
+/// sound attributes — writes nothing, because none of it means anything outside a Pueblo client.
+/// </summary>
+/// <remarks>
+/// <para>Each carries its Pueblo name in a <c>data-pueblo</c> attribute and an <c>ms-pueblo-*</c> class,
+/// so a page can find them, style them, or take one over.</para>
+/// <para>A source is written only when it is an absolute <c>http</c> or <c>https</c> URL: Pueblo names
+/// a file against the world's own directory, which a browser cannot resolve.</para>
+/// </remarks>
+public sealed class PuebloHtmlEmitter : IMarkupEmitter
+{
+	/// <summary>The one instance; the emitter carries no state.</summary>
+	public static readonly PuebloHtmlEmitter Instance = new();
+
+	private PuebloHtmlEmitter()
+	{
+	}
+
+	/// <inheritdoc/>
+	public Type MarkupType => typeof(PuebloElement);
+
+	/// <inheritdoc/>
+	public MarkupFormat Format => MarkupFormat.Html;
+
+	/// <inheritdoc/>
+	public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context, IBufferWriter<char> output)
+	{
+		ArgumentNullException.ThrowIfNull(markup);
+		ArgumentNullException.ThrowIfNull(output);
+
+		var element = (PuebloElement)markup;
+
+		if (element.Name.Equals("xch_pane", StringComparison.OrdinalIgnoreCase))
+		{
+			output.Write("<span class=\"ms-pueblo-pane\" data-pueblo=\"xch_pane\" data-name=\"");
+			output.Write(WebUtility.HtmlEncode(Attribute(element, "name") ?? string.Empty));
+			output.Write("\">");
+			output.Write(body);
+			output.Write("</span>");
+			return;
+		}
+
+		// An <img> carrying one of the sound attributes is a sound rather than a picture, and the file it
+		// names is the world's, not an address.
+		if (element.Name.Equals("img", StringComparison.OrdinalIgnoreCase)
+			&& Attribute(element, "src") is { } source
+			&& Address(source) is { } address)
+		{
+			output.Write("<img class=\"ms-pueblo-image\" data-pueblo=\"img\" src=\"");
+			output.Write(WebUtility.HtmlEncode(address));
+			output.Write("\" alt=\"");
+			output.Write(WebUtility.HtmlEncode(Attribute(element, "xch_hint") ?? string.Empty));
+			output.Write("\">");
+			return;
+		}
+
+		if (element.WrapsContent) output.Write(body);
+	}
+
+	private static string? Attribute(PuebloElement element, string name)
+	{
+		foreach (var attribute in element.Attributes)
+		{
+			if (string.Equals(attribute.Name, name, StringComparison.OrdinalIgnoreCase)) return attribute.Value;
+		}
+
+		return null;
+	}
+
+	private static string? Address(string value) =>
+		Uri.TryCreate(value, UriKind.Absolute, out var uri) && uri.Scheme is "http" or "https" ? value : null;
+}
diff --git a/MarkupString.Pueblo/MarkupString.Pueblo.csproj b/MarkupString.Pueblo/MarkupString.Pueblo.csproj
new file mode 100644
index 0000000..fc0f10d
--- /dev/null
+++ b/MarkupString.Pueblo/MarkupString.Pueblo.csproj
@@ -0,0 +1,25 @@
+<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>
+    <Description>Pueblo's own extensions for MarkupString — its panes, page control, sounds, prefetching and mode switches — written as Pueblo tags for a Pueblo client, as the nearest HTML for a browser, and as nothing at all for a client with neither.</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.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..78b6efc
--- /dev/null
+++ b/MarkupString.Pueblo/PublicAPI.Unshipped.txt
@@ -0,0 +1,76 @@
+#nullable enable
+const MarkupString.Pueblo.PuebloElement.Carrier = "​" -> string!
+MarkupString.Pueblo.PuebloAttribute
+MarkupString.Pueblo.PuebloAttribute.Deconstruct(out string! Name, out string! Value) -> void
+MarkupString.Pueblo.PuebloAttribute.Equals(MarkupString.Pueblo.PuebloAttribute other) -> bool
+MarkupString.Pueblo.PuebloAttribute.Name.get -> string!
+MarkupString.Pueblo.PuebloAttribute.Name.init -> void
+MarkupString.Pueblo.PuebloAttribute.PuebloAttribute(string! Name, string! Value) -> void
+MarkupString.Pueblo.PuebloAttribute.PuebloAttribute() -> void
+MarkupString.Pueblo.PuebloAttribute.Value.get -> string!
+MarkupString.Pueblo.PuebloAttribute.Value.init -> void
+MarkupString.Pueblo.PuebloClear
+MarkupString.Pueblo.PuebloClear.All = 1 -> MarkupString.Pueblo.PuebloClear
+MarkupString.Pueblo.PuebloClear.Text = 0 -> MarkupString.Pueblo.PuebloClear
+MarkupString.Pueblo.PuebloElement
+MarkupString.Pueblo.PuebloElement.Attributes.get -> System.Collections.Immutable.ImmutableArray<MarkupString.Pueblo.PuebloAttribute>
+MarkupString.Pueblo.PuebloElement.Attributes.init -> void
+MarkupString.Pueblo.PuebloElement.<Clone>$() -> MarkupString.Pueblo.PuebloElement!
+MarkupString.Pueblo.PuebloElementCodec
+MarkupString.Pueblo.PuebloElementCodec.Kind.get -> string!
+MarkupString.Pueblo.PuebloElementCodec.MarkupType.get -> System.Type!
+MarkupString.Pueblo.PuebloElementCodec.PuebloElementCodec() -> void
+MarkupString.Pueblo.PuebloElementCodec.Read(System.Text.Json.JsonElement element) -> MarkupString.IMarkup!
+MarkupString.Pueblo.PuebloElementCodec.Write(System.Text.Json.Utf8JsonWriter! writer, MarkupString.IMarkup! markup) -> void
+MarkupString.Pueblo.PuebloElement.Deconstruct(out string! Name, out System.Collections.Immutable.ImmutableArray<MarkupString.Pueblo.PuebloAttribute> Attributes, out bool WrapsContent) -> void
+MarkupString.Pueblo.PuebloElementEmitter
+MarkupString.Pueblo.PuebloElementEmitter.Emit(MarkupString.IMarkup! markup, System.ReadOnlySpan<char> body, in MarkupString.EmitContext context, System.Buffers.IBufferWriter<char>! output) -> void
+MarkupString.Pueblo.PuebloElementEmitter.Format.get -> MarkupString.MarkupFormat!
+MarkupString.Pueblo.PuebloElementEmitter.MarkupType.get -> System.Type!
+MarkupString.Pueblo.PuebloElementEmitter.PuebloElementEmitter(System.Func<MarkupString.Pueblo.PuebloElement!, bool>? supports) -> void
+MarkupString.Pueblo.PuebloElement.Equals(MarkupString.Pueblo.PuebloElement? other) -> bool
+MarkupString.Pueblo.PuebloElement.Name.get -> string!
+MarkupString.Pueblo.PuebloElement.Name.init -> void
+MarkupString.Pueblo.PuebloElement.PuebloElement(string! Name, System.Collections.Immutable.ImmutableArray<MarkupString.Pueblo.PuebloAttribute> Attributes, bool WrapsContent) -> void
+MarkupString.Pueblo.PuebloElements
+MarkupString.Pueblo.PuebloElement.WrapsContent.get -> bool
+MarkupString.Pueblo.PuebloElement.WrapsContent.init -> void
+MarkupString.Pueblo.PuebloHtmlEmitter
+MarkupString.Pueblo.PuebloHtmlEmitter.Emit(MarkupString.IMarkup! markup, System.ReadOnlySpan<char> body, in MarkupString.EmitContext context, System.Buffers.IBufferWriter<char>! output) -> void
+MarkupString.Pueblo.PuebloHtmlEmitter.Format.get -> MarkupString.MarkupFormat!
+MarkupString.Pueblo.PuebloHtmlEmitter.MarkupType.get -> System.Type!
+MarkupString.Pueblo.PuebloMode
+MarkupString.Pueblo.PuebloMode.Html = 1 -> MarkupString.Pueblo.PuebloMode
+MarkupString.Pueblo.PuebloMode.PureHtml = 2 -> MarkupString.Pueblo.PuebloMode
+MarkupString.Pueblo.PuebloMode.Text = 0 -> MarkupString.Pueblo.PuebloMode
+MarkupString.Pueblo.PuebloRegistration
+MarkupString.Pueblo.PuebloSilentEmitter
+MarkupString.Pueblo.PuebloSilentEmitter.Emit(MarkupString.IMarkup! markup, System.ReadOnlySpan<char> body, in MarkupString.EmitContext context, System.Buffers.IBufferWriter<char>! output) -> void
+MarkupString.Pueblo.PuebloSilentEmitter.Format.get -> MarkupString.MarkupFormat!
+MarkupString.Pueblo.PuebloSilentEmitter.MarkupType.get -> System.Type!
+MarkupString.Pueblo.PuebloSilentEmitter.PuebloSilentEmitter(MarkupString.MarkupFormat! format) -> void
+~override MarkupString.Pueblo.PuebloAttribute.Equals(object obj) -> bool
+override MarkupString.Pueblo.PuebloAttribute.GetHashCode() -> int
+override MarkupString.Pueblo.PuebloAttribute.ToString() -> string!
+override MarkupString.Pueblo.PuebloElement.Equals(object? obj) -> bool
+override MarkupString.Pueblo.PuebloElement.GetHashCode() -> int
+override MarkupString.Pueblo.PuebloElement.ToString() -> string!
+static MarkupString.Pueblo.PuebloAttribute.operator !=(MarkupString.Pueblo.PuebloAttribute left, MarkupString.Pueblo.PuebloAttribute right) -> bool
+static MarkupString.Pueblo.PuebloAttribute.operator ==(MarkupString.Pueblo.PuebloAttribute left, MarkupString.Pueblo.PuebloAttribute right) -> bool
+static MarkupString.Pueblo.PuebloElement.IsValidName(string! name) -> bool
+static MarkupString.Pueblo.PuebloElement.operator !=(MarkupString.Pueblo.PuebloElement? left, MarkupString.Pueblo.PuebloElement? right) -> bool
+static MarkupString.Pueblo.PuebloElement.operator ==(MarkupString.Pueblo.PuebloElement? left, MarkupString.Pueblo.PuebloElement? right) -> bool
+static MarkupString.Pueblo.PuebloElements.Alert(string! file, int? volume = null, string? device = null) -> MarkupString.MarkupText!
+static MarkupString.Pueblo.PuebloElements.Image(string! source, string? command = null, string? hint = null, string? graph = null, string? width = null, string? height = null) -> MarkupString.MarkupText!
+static MarkupString.Pueblo.PuebloElements.Mode(MarkupString.Pueblo.PuebloMode mode) -> MarkupString.MarkupText!
+static MarkupString.Pueblo.PuebloElements.Page(MarkupString.Pueblo.PuebloClear clear = MarkupString.Pueblo.PuebloClear.Text) -> MarkupString.MarkupText!
+static MarkupString.Pueblo.PuebloElements.Pane(MarkupString.MarkupText! content, string! name, string? title = null, string? minimumWidth = null, string? minimumHeight = null, string? alignTo = null, bool? scrolling = null, string? options = null) -> MarkupString.MarkupText!
+static MarkupString.Pueblo.PuebloElements.Prefetch(string! source) -> MarkupString.MarkupText!
+static MarkupString.Pueblo.PuebloElements.Sound(string! file, int? volume = null, string? device = null) -> MarkupString.MarkupText!
+static MarkupString.Pueblo.PuebloElements.Speech(string! text, int? volume = null, string? device = null) -> MarkupString.MarkupText!
+static MarkupString.Pueblo.PuebloElement.Standalone(string! name, params System.ReadOnlySpan<MarkupString.Pueblo.PuebloAttribute> attributes) -> MarkupString.MarkupText!
+static MarkupString.Pueblo.PuebloElement.Wrapping(string! name, MarkupString.MarkupText! content, params System.ReadOnlySpan<MarkupString.Pueblo.PuebloAttribute> attributes) -> MarkupString.MarkupText!
+static MarkupString.Pueblo.PuebloRegistration.WithPueblo(this MarkupString.MarkupRegistry! registry, System.Func<MarkupString.Pueblo.PuebloElement!, bool>? supports = null) -> MarkupString.MarkupRegistry!
+static readonly MarkupString.Pueblo.PuebloElementEmitter.Instance -> MarkupString.Pueblo.PuebloElementEmitter!
+static readonly MarkupString.Pueblo.PuebloHtmlEmitter.Instance -> MarkupString.Pueblo.PuebloHtmlEmitter!
+static MarkupString.Pueblo.PuebloElements.MudText(MarkupString.MarkupText! content) -> MarkupString.MarkupText!
diff --git a/MarkupString.Pueblo/PuebloElement.cs b/MarkupString.Pueblo/PuebloElement.cs
new file mode 100644
index 0000000..6eb822f
--- /dev/null
+++ b/MarkupString.Pueblo/PuebloElement.cs
@@ -0,0 +1,85 @@
+using System.Collections.Immutable;
+using System.Text;
+
+namespace MarkupString.Pueblo;
+
+/// <summary>One attribute of a <see cref="PuebloElement"/>, written HTML-style as <c>name="value"</c>.</summary>
+/// <param name="Name">The attribute name, e.g. <c>xch_cmd</c>.</param>
+/// <param name="Value">The value, unencoded; the empty string for a flag such as <c>ismap</c>.</param>
+public readonly record struct PuebloAttribute(string Name, string Value)
+{
+	/// <summary>The attribute as it is written in a tag, with the four characters that are markup encoded.</summary>
+	public override string ToString() => Value.Length == 0 ? Name : $"{Name}=\"{Encode(Value)}\"";
+
+	/// <summary>
+	/// Pueblo reads HTML, so a value is encoded as an HTML attribute value is: <c>&amp;</c>, <c>"</c>,
+	/// <c>&lt;</c> and <c>&gt;</c> as entities, everything else as the caller wrote it.
+	/// </summary>
+	internal static string Encode(string value) =>
+		value.AsSpan().IndexOfAny("&\"<>") < 0
+			? value
+			: value.Replace("&", "&amp;").Replace("\"", "&quot;").Replace("<", "&lt;").Replace(">", "&gt;");
+}
+
+/// <summary>
+/// One of Pueblo's own extensions as a markup layer: a pane, a page instruction, a sound, a prefetch, a
+/// mode switch. <see cref="PuebloElements"/> builds the ones the client understands; this type is also
+/// the way to write one it does not.
+/// </summary>
+/// <remarks>
+/// <para>Pueblo renders an HTML subset, and plain HTML belongs in <c>MarkupString.Html</c>'s
+/// <c>HtmlMarkup</c>. What lives here is the part that is Pueblo's alone — the <c>xch_</c> vocabulary
+/// and the elements around it — which means nothing to a browser or to an MXP client.</para>
+/// <para>An element that wraps nothing rides on a zero-width carrier, as MXP's do; one that wraps content
+/// marks the text it applies to. A format that cannot express an element writes nothing at all, carrier
+/// included, so the same text is safe to send to every client.</para>
+/// <para>Styling and links are not here: bold, colour and a command link travel as <c>AnsiMarkup</c>,
+/// which every format already writes in its own dialect — <c>&lt;A XCH_CMD&gt;</c> for Pueblo.</para>
+/// </remarks>
+/// <param name="Name">The element's name, e.g. <c>xch_page</c>.</param>
+/// <param name="Attributes">Its attributes, in the order they are written.</param>
+/// <param name="WrapsContent">Whether the element closes after the text it marks, rather than standing alone.</param>
+public sealed record PuebloElement(string Name, ImmutableArray<PuebloAttribute> Attributes, bool WrapsContent) : IMarkup
+{
+	/// <summary>
+	/// The character a standalone element rides on: a zero-width space, which measures nothing and is
+	/// never written out — every format either writes the element or writes nothing.
+	/// </summary>
+	public const string Carrier = "​";
+
+	/// <summary>Creates an element and the text it stands in, for one that wraps nothing.</summary>
+	/// <exception cref="ArgumentException"><paramref name="name"/> is not an element name.</exception>
+	public static MarkupText Standalone(string name, params ReadOnlySpan<PuebloAttribute> attributes) =>
+		MarkupText.Wrap(new PuebloElement(Checked(name), [.. attributes], false), Carrier);
+
+	/// <summary>Creates an element wrapping <paramref name="content"/>.</summary>
+	/// <exception cref="ArgumentException"><paramref name="name"/> is not an element name.</exception>
+	public static MarkupText Wrapping(string name, MarkupText content, params ReadOnlySpan<PuebloAttribute> attributes) =>
+		MarkupText.Wrap(new PuebloElement(Checked(name), [.. attributes], true), content);
+
+	/// <summary>The tag as Pueblo reads it: <c>&lt;name attr="value"&gt;</c>.</summary>
+	public override string ToString()
+	{
+		var written = new StringBuilder("<").Append(Name);
+		foreach (var attribute in Attributes) written.Append(' ').Append(attribute.ToString());
+		return written.Append('>').ToString();
+	}
+
+	/// <summary>An element name is a letter, then letters, digits, hyphens or underscores.</summary>
+	public static bool IsValidName(string name)
+	{
+		if (string.IsNullOrEmpty(name) || !char.IsAsciiLetter(name[0])) return false;
+
+		foreach (var c in name)
+		{
+			if (!char.IsAsciiLetterOrDigit(c) && c != '-' && c != '_') return false;
+		}
+
+		return true;
+	}
+
+	private static string Checked(string name) =>
+		IsValidName(name)
+			? name
+			: throw new ArgumentException($"'{name}' is not an element name.", nameof(name));
+}
diff --git a/MarkupString.Pueblo/PuebloElementCodec.cs b/MarkupString.Pueblo/PuebloElementCodec.cs
new file mode 100644
index 0000000..aeb41a0
--- /dev/null
+++ b/MarkupString.Pueblo/PuebloElementCodec.cs
@@ -0,0 +1,69 @@
+using System.Collections.Immutable;
+using System.Text.Json;
+
+namespace MarkupString.Pueblo;
+
+/// <summary>
+/// Reads and writes <see cref="PuebloElement"/> in the serializer's envelope, under kind <c>"pueblo"</c>.
+/// Keys are <c>e</c> (the element name), <c>w</c> (whether it wraps content, written only when it does)
+/// and <c>a</c> (the attributes, each an array of name and value).
+/// </summary>
+public sealed class PuebloElementCodec : IMarkupCodec
+{
+	/// <inheritdoc/>
+	public string Kind => "pueblo";
+
+	/// <inheritdoc/>
+	public Type MarkupType => typeof(PuebloElement);
+
+	/// <inheritdoc/>
+	public void Write(Utf8JsonWriter writer, IMarkup markup)
+	{
+		ArgumentNullException.ThrowIfNull(writer);
+		ArgumentNullException.ThrowIfNull(markup);
+
+		var element = (PuebloElement)markup;
+		writer.WriteString("e", element.Name);
+		if (element.WrapsContent) writer.WriteBoolean("w", true);
+
+		if (element.Attributes.Length == 0) return;
+
+		writer.WriteStartArray("a");
+		foreach (var attribute in element.Attributes)
+		{
+			writer.WriteStartArray();
+			writer.WriteStringValue(attribute.Name);
+			writer.WriteStringValue(attribute.Value);
+			writer.WriteEndArray();
+		}
+
+		writer.WriteEndArray();
+	}
+
+	/// <inheritdoc/>
+	public IMarkup Read(JsonElement element)
+	{
+		var name = element.TryGetProperty("e", out var e) && e.ValueKind == JsonValueKind.String
+			? e.GetString() ?? string.Empty
+			: string.Empty;
+
+		var wraps = element.TryGetProperty("w", out var w) && w.ValueKind == JsonValueKind.True;
+
+		var attributes = ImmutableArray.CreateBuilder<PuebloAttribute>();
+		if (element.TryGetProperty("a", out var a) && a.ValueKind == JsonValueKind.Array)
+		{
+			foreach (var pair in a.EnumerateArray())
+			{
+				if (pair.ValueKind != JsonValueKind.Array || pair.GetArrayLength() != 2) continue;
+
+				if (pair[0].ValueKind != JsonValueKind.String) continue;
+
+				var attributeName = pair[0].GetString() ?? string.Empty;
+				var value = pair[1].ValueKind == JsonValueKind.String ? pair[1].GetString() ?? string.Empty : string.Empty;
+				attributes.Add(new PuebloAttribute(attributeName, value));
+			}
+		}
+
+		return new PuebloElement(name, [.. attributes], wraps);
+	}
+}
diff --git a/MarkupString.Pueblo/PuebloElements.cs b/MarkupString.Pueblo/PuebloElements.cs
new file mode 100644
index 0000000..8cd9ef1
--- /dev/null
+++ b/MarkupString.Pueblo/PuebloElements.cs
@@ -0,0 +1,148 @@
+using System.Collections.Immutable;
+using System.Globalization;
+
+namespace MarkupString.Pueblo;
+
+/// <summary>How a Pueblo client reads what follows a <see cref="PuebloElements.Mode"/> switch.</summary>
+public enum PuebloMode
+{
+	/// <summary>Plain MUD text: line ends break lines, and the font is fixed-width.</summary>
+	Text,
+	/// <summary>HTML, with MUD-text conventions still applied.</summary>
+	Html,
+	/// <summary>HTML alone, which is what a world switches to once it is sending markup.</summary>
+	PureHtml,
+}
+
+/// <summary>What a <see cref="PuebloElements.Page"/> instruction clears.</summary>
+public enum PuebloClear
+{
+	/// <summary>The text the player has already been shown.</summary>
+	Text,
+	/// <summary>Everything, the images included.</summary>
+	All,
+}
+
+/// <summary>
+/// Pueblo's own extensions, as its client reads them: the pane, the page instruction, the sound and
+/// alert attributes, prefetching, and the mode switches a world uses to enter HTML.
+/// </summary>
+/// <remarks>
+/// Names are the client's own (<c>api/ChHtmSym.cpp</c> and the sound module in
+/// <see href="https://github.com/uecasm/pueblo">uecasm/pueblo</see>). Plain HTML is not here — Pueblo
+/// reads an HTML subset, and <c>HtmlMarkup</c> writes that — and neither are styling and links, which
+/// travel as <c>AnsiMarkup</c> and are already written per dialect.
+/// </remarks>
+public static class PuebloElements
+{
+	/// <summary>
+	/// <c>&lt;xch_page&gt;</c> — clears what the player has been shown. The handshake sends this as part
+	/// of moving a client into HTML.
+	/// </summary>
+	public static MarkupText Page(PuebloClear clear = PuebloClear.Text) =>
+		PuebloElement.Standalone("xch_page", new PuebloAttribute("clear", clear.ToString().ToLowerInvariant()));
+
+	/// <summary>
+	/// <c>&lt;img xch_mode=…&gt;</c> — how the client reads what follows. A world announces
+	/// <see cref="PuebloMode.PureHtml"/> once it is sending markup rather than MUD text.
+	/// </summary>
+	public static MarkupText Mode(PuebloMode mode) =>
+		PuebloElement.Standalone("img", new PuebloAttribute("xch_mode", mode switch
+		{
+			PuebloMode.PureHtml => "purehtml",
+			PuebloMode.Html => "html",
+			_ => "text",
+		}));
+
+	/// <summary>
+	/// <c>&lt;xch_mudtext&gt;</c> — marks text the client should treat as it treats a non-HTML world's:
+	/// line ends break lines, and the font is fixed-width.
+	/// </summary>
+	/// <remarks>
+	/// The <c>&lt;/xch_mudtext&gt;</c> that takes a whole connection out of MUD-text handling is part of
+	/// the Pueblo handshake, which belongs to the telnet layer rather than here.
+	/// </remarks>
+	public static MarkupText MudText(MarkupText content) => PuebloElement.Wrapping("xch_mudtext", content);
+
+	/// <summary>
+	/// <c>&lt;xch_pane&gt;</c> — a pane of its own, wrapping what goes to it. MXP's <c>FRAME</c> was
+	/// modelled on this.
+	/// </summary>
+	public static MarkupText Pane(
+		MarkupText content,
+		string name,
+		string? title = null,
+		string? minimumWidth = null,
+		string? minimumHeight = null,
+		string? alignTo = null,
+		bool? scrolling = null,
+		string? options = null)
+	{
+		var attributes = ImmutableArray.CreateBuilder<PuebloAttribute>();
+		attributes.Add(new PuebloAttribute("name", name));
+		Add(attributes, "panetitle", title);
+		Add(attributes, "minwidth", minimumWidth);
+		Add(attributes, "minheight", minimumHeight);
+		Add(attributes, "alignto", alignTo);
+		if (scrolling is { } scrolls) Add(attributes, "scrolling", scrolls ? "yes" : "no");
+		Add(attributes, "options", options);
+		return PuebloElement.Wrapping("xch_pane", content, [.. attributes]);
+	}
+
+	/// <summary>
+	/// <c>&lt;img xch_sound=…&gt;</c> — plays a sound. <paramref name="volume"/> and
+	/// <paramref name="device"/> are the client's <c>xch_volume</c> and <c>xch_device</c>.
+	/// </summary>
+	public static MarkupText Sound(string file, int? volume = null, string? device = null) =>
+		SoundLike("xch_sound", file, volume, device);
+
+	/// <summary><c>&lt;img xch_alert=…&gt;</c> — the same, for a sound that is asking for attention.</summary>
+	public static MarkupText Alert(string file, int? volume = null, string? device = null) =>
+		SoundLike("xch_alert", file, volume, device);
+
+	/// <summary><c>&lt;img xch_speech=…&gt;</c> — text for the client to speak.</summary>
+	public static MarkupText Speech(string text, int? volume = null, string? device = null) =>
+		SoundLike("xch_speech", text, volume, device);
+
+	/// <summary>
+	/// <c>&lt;xch_prefetch&gt;</c> — asks the client to fetch something now that it will want soon.
+	/// </summary>
+	public static MarkupText Prefetch(string source) =>
+		PuebloElement.Standalone("xch_prefetch", new PuebloAttribute("src", source));
+
+	/// <summary>
+	/// <c>&lt;img&gt;</c> with Pueblo's own attributes: a picture that can carry a command, a tooltip, and
+	/// the graph hook its VRML worlds use.
+	/// </summary>
+	public static MarkupText Image(
+		string source,
+		string? command = null,
+		string? hint = null,
+		string? graph = null,
+		string? width = null,
+		string? height = null)
+	{
+		var attributes = ImmutableArray.CreateBuilder<PuebloAttribute>();
+		attributes.Add(new PuebloAttribute("src", source));
+		Add(attributes, "xch_cmd", command);
+		Add(attributes, "xch_hint", hint);
+		Add(attributes, "xch_graph", graph);
+		Add(attributes, "width", width);
+		Add(attributes, "height", height);
+		return PuebloElement.Standalone("img", [.. attributes]);
+	}
+
+	private static MarkupText SoundLike(string attribute, string value, int? volume, string? device)
+	{
+		var attributes = ImmutableArray.CreateBuilder<PuebloAttribute>();
+		attributes.Add(new PuebloAttribute(attribute, value));
+		if (volume is { } level) Add(attributes, "xch_volume", level.ToString(CultureInfo.InvariantCulture));
+		Add(attributes, "xch_device", device);
+		return PuebloElement.Standalone("img", [.. attributes]);
+	}
+
+	private static void Add(ImmutableArray<PuebloAttribute>.Builder attributes, string name, string? value)
+	{
+		if (value is not null) attributes.Add(new PuebloAttribute(name, value));
+	}
+}
diff --git a/MarkupString.Pueblo/PuebloRegistration.cs b/MarkupString.Pueblo/PuebloRegistration.cs
new file mode 100644
index 0000000..8007bd3
--- /dev/null
+++ b/MarkupString.Pueblo/PuebloRegistration.cs
@@ -0,0 +1,41 @@
+namespace MarkupString.Pueblo;
+
+/// <summary>Installs this package's emitters and codec into a <see cref="MarkupRegistry"/>.</summary>
+public static class PuebloRegistration
+{
+	/// <summary>
+	/// Returns a registry that writes an <see cref="PuebloElement"/> as an Pueblo tag in
+	/// <see cref="MarkupFormat.Pueblo"/>, as the nearest HTML in <see cref="MarkupFormat.Html"/>, and as
+	/// nothing in every other format — carrier included, so a terminal is sent neither a tag it would show
+	/// as text nor the zero-width space it rode on.
+	/// </summary>
+	/// <remarks>
+	/// A registry is cheap to build, so one per connection — carrying that client's answers — costs a
+	/// dictionary copy, and one built without <paramref name="supports"/> serves every client that was
+	/// never asked.
+	/// To keep Pueblo's elements out of the browser entirely, add
+	/// <c>new PuebloSilentEmitter(MarkupFormat.Html)</c> after this; the last emitter registered for a format
+	/// wins.
+	/// </remarks>
+	/// <param name="registry">The registry to add to.</param>
+	/// <param name="supports">
+	/// Which elements to write, for a consumer that knows a client renders only some of them. Null writes
+	/// every element, which is the ordinary case: Pueblo has no exchange that asks.
+	/// An element it refuses is written as a format without Pueblo writes it: nothing for one that stands
+	/// alone, and the content alone for one that wraps — so a <c>FRAME</c> a client cannot open does not
+	/// take the text that followed it.
+	/// </param>
+	public static MarkupRegistry WithPueblo(this MarkupRegistry registry, Func<PuebloElement, bool>? supports = null)
+	{
+		ArgumentNullException.ThrowIfNull(registry);
+
+		return registry
+			.With(supports is null ? PuebloElementEmitter.Instance : new PuebloElementEmitter(supports))
+			.With(PuebloHtmlEmitter.Instance)
+			.With(new PuebloSilentEmitter(MarkupFormat.Ansi))
+			.With(new PuebloSilentEmitter(MarkupFormat.Mxp))
+			.With(new PuebloSilentEmitter(MarkupFormat.Plain))
+			.With(new PuebloSilentEmitter(MarkupFormat.BBCode))
+			.With(new PuebloElementCodec());
+	}
+}
diff --git a/MarkupString.Pueblo/README.md b/MarkupString.Pueblo/README.md
new file mode 100644
index 0000000..f055cee
--- /dev/null
+++ b/MarkupString.Pueblo/README.md
@@ -0,0 +1,59 @@
+# MarkupString.Pueblo
+
+Pueblo's own extensions for [`MarkupString`](https://www.nuget.org/packages/MarkupString): its panes,
+page control, sounds, prefetching and mode switches — the `xch_` vocabulary a Pueblo client reads and
+nothing else does.
+
+```sh
+dotnet add package MarkupString.Pueblo
+```
+
+It is one of MarkupString's three **tag dialects**, beside
+[`MarkupString.Html`](https://www.nuget.org/packages/MarkupString.Html) (plain HTML, for browsers) and
+[`MarkupString.Mxp`](https://www.nuget.org/packages/MarkupString.Mxp) (MXP's own elements). Each writes
+its own tags; none of them reads another's.
+
+## What belongs here, and what does not
+
+Pueblo renders an HTML subset, so **plain HTML is not here**: `<b>`, `<pre>`, `<font>` and the rest are
+[`MarkupString.Html`](https://www.nuget.org/packages/MarkupString.Html)'s `HtmlMarkup`, which Pueblo
+reads as HTML. **Styling and links are not here either**: bold, colour and a command link travel as
+`AnsiMarkup` and are already written per dialect — `<A XCH_CMD>` for Pueblo, `<SEND HREF>` for MXP.
+
+What is here is the part that is Pueblo's alone, and means nothing to a browser or an MXP client.
+
+## Usage
+
+```csharp
+MarkupRegistry.Default = MarkupRegistry.Empty.WithAnsi().WithHtml().WithPueblo();
+
+var line = MarkupText.Concat(
+  PuebloElements.Sound("door.wav", volume: 80),
+  MarkupText.Plain("The door creaks open."));
+
+line.Render(MarkupFormat.Pueblo);  // <img xch_sound="door.wav" xch_volume="80">The door creaks open.
+line.Render(MarkupFormat.Mxp);     // The door creaks open.
+line.Render(MarkupFormat.Ansi);    // The door creaks open.
+```
+
+| | Pueblo | HTML | everything else |
+|---|---|---|---|
+| `Image` | `<img>` with `xch_cmd`, `xch_hint`, `xch_graph` | `<img>`, when the source is an absolute URL | nothing |
+| `Sound`, `Alert`, `Speech` | `<img xch_sound=…>` and its siblings | nothing — the file is the world's, not an address | nothing |
+| `Pane` | `<xch_pane>` around its content | a span around its content | the content |
+| `Page`, `Mode`, `MudText`, `Prefetch` | the tag | nothing | nothing |
+
+An element that wraps nothing is a point in the text, carried on a zero-width space; a format that
+cannot express it writes **nothing at all**, carrier included, so the same text is safe to send to every
+client.
+
+## What this package does not do
+
+The Pueblo handshake — the hello, `PUEBLOCLIENT`, and the sequence that moves a client into HTML — is
+the telnet layer's, in
+[TelnetNegotiationCore](https://github.com/HarryCordewener/TelnetNegotiationCore). This package renders
+what it is given.
+
+## Licence
+
+Apache-2.0. Source, guides and issues: [SharpMUSH/MarkupString](https://github.com/SharpMUSH/MarkupString).
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/Mxp/MxpElementTests.cs b/MarkupString.Tests/Mxp/MxpElementTests.cs
new file mode 100644
index 0000000..4db38b5
--- /dev/null
+++ b/MarkupString.Tests/Mxp/MxpElementTests.cs
@@ -0,0 +1,222 @@
+using MarkupString.Ansi;
+using MarkupString.Html;
+using MarkupString.Mxp;
+namespace MarkupString.Tests.Mxp;
+
+/// <summary>
+/// MXP's own elements: a tag for a client that negotiated MXP, the nearest thing a browser has, and
+/// nothing at all for a client with neither — so the same text is safe to send to every one of them.
+/// </summary>
+/// <remarks>
+/// Syntax from the <see href="https://www.zuggsoft.com/zmud/mxp.htm">MXP specification</see>.
+/// </remarks>
+public class MxpElementTests
+{
+	private static readonly MarkupRegistry Registry = MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp();
+
+	private static string Render(MarkupText text, MarkupFormat format) => text.Render(format, Registry);
+
+	// ── Written as MXP ──────────────────────────────────────────────────────────
+
+	[Test]
+	public async Task AnElementIsWrittenAsItsTag()
+	{
+		await Assert.That(Render(MxpElements.Sound("door.wav"), MarkupFormat.Mxp)).IsEqualTo("<SOUND door.wav>");
+		await Assert.That(Render(MxpElements.Sound("door.wav", volume: 80, loops: 2, priority: 10), MarkupFormat.Mxp))
+			.IsEqualTo("<SOUND door.wav V=80 L=2 P=10>");
+		await Assert.That(Render(MxpElements.Music("theme.mid", continues: true), MarkupFormat.Mxp))
+			.IsEqualTo("<MUSIC theme.mid C=1>");
+		await Assert.That(Render(MxpElements.Image("map.png", align: MxpAlign.Left, isMap: true), MarkupFormat.Mxp))
+			.IsEqualTo("<IMAGE map.png ALIGN=LEFT ISMAP>");
+		await Assert.That(Render(MxpElements.Gauge("hp", "maxhp", "Hit Points", "red"), MarkupFormat.Mxp))
+			.IsEqualTo("<GAUGE hp MAX=maxhp CAPTION=\"Hit Points\" COLOR=red>");
+		await Assert.That(Render(MxpElements.Stat("mana", caption: "Mana"), MarkupFormat.Mxp))
+			.IsEqualTo("<STAT mana CAPTION=Mana>");
+		await Assert.That(Render(MxpElements.Expire("exits"), MarkupFormat.Mxp)).IsEqualTo("<EXPIRE exits>");
+		await Assert.That(Render(MxpElements.Expire(), MarkupFormat.Mxp)).IsEqualTo("<EXPIRE>");
+		await Assert.That(Render(MxpElements.User(), MarkupFormat.Mxp)).IsEqualTo("<USER>");
+		await Assert.That(Render(MxpElements.Password(), MarkupFormat.Mxp)).IsEqualTo("<PASSWORD>");
+		await Assert.That(Render(MxpElements.NoBreak(), MarkupFormat.Mxp)).IsEqualTo("<NOBR>");
+		await Assert.That(Render(MxpElements.SoftBreak(), MarkupFormat.Mxp)).IsEqualTo("<SBR>");
+		await Assert.That(Render(MxpElements.Relocate("other.example", 4201, quiet: true), MarkupFormat.Mxp))
+			.IsEqualTo("<RELOCATE other.example 4201 QUIET>");
+	}
+
+	[Test]
+	public async Task AnElementThatWrapsContentClosesAfterIt()
+	{
+		var frame = MxpElements.Frame(MarkupText.Plain("Map goes here"), "map", MxpFrameAction.Open, "The Map", scrolling: false);
+
+		await Assert.That(Render(frame, MarkupFormat.Mxp))
+			.IsEqualTo("<FRAME map ACTION=OPEN TITLE=\"The Map\" SCROLLING=no>Map goes here</FRAME>");
+
+		var variable = MxpElements.Var(MarkupText.Plain("42"), "hp", description: "Hit points");
+
+		await Assert.That(Render(variable, MarkupFormat.Mxp))
+			.IsEqualTo("<VAR hp DESC=\"Hit points\">42</VAR>");
+	}
+
+	/// <summary>
+	/// MXP separates arguments with whitespace and reads a quoted value as one, so a value carrying
+	/// either is quoted and its own quotes written as entities.
+	/// </summary>
+	[Test]
+	public async Task AValueThatNeedsQuotingIsQuoted()
+	{
+		var stat = MxpElements.Stat("hp", caption: "He said \"hello\"");
+
+		await Assert.That(Render(stat, MarkupFormat.Mxp)).IsEqualTo("<STAT hp CAPTION=\"He said &quot;hello&quot;\">");
+	}
+
+	// ── Written for everyone else ───────────────────────────────────────────────
+
+	[Test]
+	[Arguments("ansi")]
+	[Arguments("plain")]
+	[Arguments("bbcode")]
+	[Arguments("pueblo")]
+	public async Task AFormatWithNoMxpWritesNothing_CarrierIncluded(string format)
+	{
+		var line = MarkupText.Concat(MxpElements.Sound("door.wav"), MarkupText.Plain("The door creaks."));
+
+		await Assert.That(Render(line, MarkupFormat.TryParse(format)!)).IsEqualTo("The door creaks.")
+			.Because("a client that cannot read the tag must not be sent the character it rode on either");
+	}
+
+	[Test]
+	public async Task AWrappingElementLeavesItsContentBehind()
+	{
+		var frame = MxpElements.Frame(MarkupText.Plain("Map goes here"), "map");
+
+		await Assert.That(Render(frame, MarkupFormat.Ansi)).IsEqualTo("Map goes here");
+		await Assert.That(Render(frame, MarkupFormat.Plain)).IsEqualTo("Map goes here");
+	}
+
+	[Test]
+	public async Task AnElementMeasuresNothing()
+	{
+		var line = MarkupText.Concat(MxpElements.Sound("door.wav"), MarkupText.Plain("ab"));
+
+		await Assert.That(DisplayWidth.Of(line.Text)).IsEqualTo(2);
+	}
+
+	// ── Written for a browser ───────────────────────────────────────────────────
+
+	[Test]
+	public async Task ABrowserGetsTheNearestThingItHas()
+	{
+		await Assert.That(Render(MxpElements.Image("map.png", url: "https://example.test/map.png"), MarkupFormat.Html))
+			.IsEqualTo("<img class=\"ms-mxp-image\" data-mxp=\"IMAGE\" src=\"https://example.test/map.png\" alt=\"map.png\">");
+		await Assert.That(Render(MxpElements.Sound("door.wav", url: "https://example.test/door.wav"), MarkupFormat.Html))
+			.IsEqualTo("<audio class=\"ms-mxp-sound\" data-mxp=\"SOUND\" src=\"https://example.test/door.wav\" preload=\"none\"></audio>")
+			.Because("<audio> is standard HTML, but autoplay is refused until the person has interacted with the page, so whether it sounds is the page's call");
+		await Assert.That(Render(MxpElements.Gauge("hp", "maxhp", "Hit Points"), MarkupFormat.Html))
+			.IsEqualTo("<span class=\"ms-mxp-gauge\" data-mxp=\"GAUGE\" data-entity=\"hp\" data-max=\"maxhp\">Hit Points</span>");
+		await Assert.That(Render(MxpElements.Frame(MarkupText.Plain("x"), "map"), MarkupFormat.Html))
+			.IsEqualTo("<span class=\"ms-mxp-frame\" data-mxp=\"FRAME\" data-name=\"map\">x</span>");
+	}
+
+	/// <summary>
+	/// MXP's <c>FName</c> names a file in the game's own sound or image directory, which a browser cannot
+	/// resolve, and an address it could be made to fetch is not one to follow blindly.
+	/// </summary>
+	[Test]
+	[Arguments(null)]
+	[Arguments("javascript:alert(1)")]
+	[Arguments("/relative/door.wav")]
+	public async Task ABrowserIsSentNoAddressItCannotTrust(string? url)
+	{
+		await Assert.That(Render(MxpElements.Sound("door.wav", url: url), MarkupFormat.Html)).IsEqualTo(string.Empty);
+	}
+
+	[Test]
+	public async Task ElementsWithNoBrowserEquivalentWriteNothing()
+	{
+		await Assert.That(Render(MxpElements.Expire(), MarkupFormat.Html)).IsEqualTo(string.Empty);
+		await Assert.That(Render(MxpElements.Relocate("other.example", 4201), MarkupFormat.Html)).IsEqualTo(string.Empty);
+		await Assert.That(Render(MxpElements.NoBreak(), MarkupFormat.Html)).IsEqualTo(string.Empty);
+	}
+
+	[Test]
+	public async Task ABrowserCanBeKeptOutOfMxpEntirely()
+	{
+		var registry = MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp().With(new MxpSilentEmitter(MarkupFormat.Html));
+		var line = MarkupText.Concat(
+			MxpElements.Image("map.png", url: "https://example.test/map.png"), MarkupText.Plain("a map"));
+
+		await Assert.That(line.Render(MarkupFormat.Html, registry)).IsEqualTo("a map");
+	}
+
+	// ── What the client said it can render ──────────────────────────────────────
+
+	/// <summary>
+	/// MXP asks with <c>&lt;SUPPORT&gt;</c> for a reason: a client that answered <c>-image</c> should not be
+	/// sent one. The set of answers belongs to a connection, so the predicate is the consumer's; refusing
+	/// an element writes it the way a format without MXP writes it.
+	/// </summary>
+	[Test]
+	public async Task AnElementTheClientRefusedIsNotWritten()
+	{
+		var registry = MarkupRegistry.Empty.WithAnsi().WithHtml()
+			.WithMxp(element => !element.Name.Equals("IMAGE", StringComparison.OrdinalIgnoreCase));
+
+		var line = MarkupText.Concat(MxpElements.Image("map.png"), MarkupText.Plain("A map hangs here."));
+
+		await Assert.That(line.Render(MarkupFormat.Mxp, registry)).IsEqualTo("A map hangs here.");
+		await Assert.That(MxpElements.Sound("door.wav").Render(MarkupFormat.Mxp, registry)).IsEqualTo("<SOUND door.wav>")
+			.Because("only the refused element is held back");
+	}
+
+	/// <summary>
+	/// The half that matters most: a frame a client cannot open would otherwise take the text inside it
+	/// somewhere the player never sees.
+	/// </summary>
+	[Test]
+	public async Task ARefusedWrappingElementKeepsItsContent()
+	{
+		var registry = MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp(_ => false);
+
+		var frame = MxpElements.Frame(MarkupText.Plain("The map is here."), "map");
+
+		await Assert.That(frame.Render(MarkupFormat.Mxp, registry)).IsEqualTo("The map is here.");
+	}
+
+	[Test]
+	public async Task WithNoAnswersEveryElementIsWritten()
+	{
+		await Assert.That(Render(MxpElements.Image("map.png"), MarkupFormat.Mxp)).IsEqualTo("<IMAGE map.png>")
+			.Because("a client that was never asked is not a client that refused");
+	}
+
+	// ── The rest ────────────────────────────────────────────────────────────────
+
+	[Test]
+	public async Task AnElementRoundTripsThroughTheSerializer()
+	{
+		var line = MarkupText.Concat(
+			MxpElements.Gauge("hp", "maxhp", "Hit Points"),
+			MxpElements.Frame(MarkupText.Plain("Map"), "map"));
+
+		var back = MarkupTextSerializer.Deserialize(MarkupTextSerializer.Serialize(line, Registry), Registry);
+
+		await Assert.That(back.Render(MarkupFormat.Mxp, Registry)).IsEqualTo(Render(line, MarkupFormat.Mxp));
+	}
+
+	[Test]
+	public async Task AnElementNotInTheSpecificationCanStillBeWritten()
+	{
+		var custom = MxpElement.Standalone("XCUSTOM", new MxpArgument(null, "one"), new MxpArgument("TWO", "2"));
+
+		await Assert.That(Render(custom, MarkupFormat.Mxp)).IsEqualTo("<XCUSTOM one TWO=2>");
+		await Assert.That(Render(custom, MarkupFormat.Html)).IsEqualTo(string.Empty);
+	}
+
+	[Test]
+	[Arguments("has space")]
+	[Arguments("")]
+	[Arguments("1bad")]
+	public async Task AnElementNameIsChecked(string name)
+	{
+		await Assert.That(() => MxpElement.Standalone(name)).Throws<ArgumentException>();
+	}
+}
diff --git a/MarkupString.Tests/Pueblo/PuebloElementTests.cs b/MarkupString.Tests/Pueblo/PuebloElementTests.cs
new file mode 100644
index 0000000..af2067d
--- /dev/null
+++ b/MarkupString.Tests/Pueblo/PuebloElementTests.cs
@@ -0,0 +1,150 @@
+using MarkupString.Ansi;
+using MarkupString.Html;
+using MarkupString.Mxp;
+using MarkupString.Pueblo;
+namespace MarkupString.Tests.Pueblo;
+
+/// <summary>
+/// Pueblo's own extensions: its <c>xch_</c> vocabulary, which means nothing to a browser or to an MXP
+/// client, and nothing at all to a terminal.
+/// </summary>
+/// <remarks>
+/// Names are the Pueblo client's own, from its tag and attribute tables
+/// (<see href="https://github.com/uecasm/pueblo">uecasm/pueblo</see>, <c>api/ChHtmSym.cpp</c> and the
+/// sound module).
+/// </remarks>
+public class PuebloElementTests
+{
+	private static readonly MarkupRegistry Registry =
+		MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp().WithPueblo();
+
+	private static string Render(MarkupText text, MarkupFormat format) => text.Render(format, Registry);
+
+	[Test]
+	public async Task AnExtensionIsWrittenAsItsTag()
+	{
+		await Assert.That(Render(PuebloElements.Page(), MarkupFormat.Pueblo)).IsEqualTo("<xch_page clear=\"text\">");
+		await Assert.That(Render(PuebloElements.Page(PuebloClear.All), MarkupFormat.Pueblo)).IsEqualTo("<xch_page clear=\"all\">");
+		await Assert.That(Render(PuebloElements.Mode(PuebloMode.PureHtml), MarkupFormat.Pueblo))
+			.IsEqualTo("<img xch_mode=\"purehtml\">");
+		await Assert.That(Render(PuebloElements.MudText(MarkupText.Plain("as typed")), MarkupFormat.Pueblo))
+			.IsEqualTo("<xch_mudtext>as typed</xch_mudtext>");
+		await Assert.That(Render(PuebloElements.Sound("door.wav", volume: 80), MarkupFormat.Pueblo))
+			.IsEqualTo("<img xch_sound=\"door.wav\" xch_volume=\"80\">");
+		await Assert.That(Render(PuebloElements.Alert("bell.wav"), MarkupFormat.Pueblo))
+			.IsEqualTo("<img xch_alert=\"bell.wav\">");
+		await Assert.That(Render(PuebloElements.Speech("Someone pages you"), MarkupFormat.Pueblo))
+			.IsEqualTo("<img xch_speech=\"Someone pages you\">");
+		await Assert.That(Render(PuebloElements.Prefetch("https://example.test/map.png"), MarkupFormat.Pueblo))
+			.IsEqualTo("<xch_prefetch src=\"https://example.test/map.png\">");
+		await Assert.That(Render(PuebloElements.Image("map.png", command: "look map", hint: "The map"), MarkupFormat.Pueblo))
+			.IsEqualTo("<img src=\"map.png\" xch_cmd=\"look map\" xch_hint=\"The map\">");
+	}
+
+	[Test]
+	public async Task APaneWrapsWhatGoesToIt()
+	{
+		var pane = PuebloElements.Pane(MarkupText.Plain("Map goes here"), "map", "The Map", scrolling: false);
+
+		await Assert.That(Render(pane, MarkupFormat.Pueblo))
+			.IsEqualTo("<xch_pane name=\"map\" panetitle=\"The Map\" scrolling=\"no\">Map goes here</xch_pane>");
+	}
+
+	[Test]
+	public async Task AValueIsEncodedAsAnHtmlAttributeValue()
+	{
+		var image = PuebloElements.Image("map.png", command: "say \"hi\" & <bye>");
+
+		await Assert.That(Render(image, MarkupFormat.Pueblo))
+			.IsEqualTo("<img src=\"map.png\" xch_cmd=\"say &quot;hi&quot; &amp; &lt;bye&gt;\">");
+	}
+
+	/// <summary>
+	/// The point of the package: Pueblo's vocabulary is Pueblo's. An MXP client shows <c>xch_</c>
+	/// anything as text, and a terminal shows all of it.
+	/// </summary>
+	[Test]
+	[Arguments("ansi")]
+	[Arguments("plain")]
+	[Arguments("bbcode")]
+	[Arguments("mxp")]
+	public async Task AFormatThatIsNotPuebloWritesNothing_CarrierIncluded(string format)
+	{
+		var line = MarkupText.Concat(PuebloElements.Sound("door.wav"), MarkupText.Plain("The door creaks."));
+
+		await Assert.That(Render(line, MarkupFormat.TryParse(format)!)).IsEqualTo("The door creaks.");
+	}
+
+	[Test]
+	public async Task APaneKeepsItsContentEverywhereElse()
+	{
+		var pane = PuebloElements.Pane(MarkupText.Plain("Map goes here"), "map");
+
+		await Assert.That(Render(pane, MarkupFormat.Ansi)).IsEqualTo("Map goes here");
+		await Assert.That(Render(pane, MarkupFormat.Mxp)).IsEqualTo("Map goes here");
+	}
+
+	[Test]
+	public async Task ABrowserGetsAPictureAndAPane_AndNothingElse()
+	{
+		await Assert.That(Render(PuebloElements.Image("https://example.test/map.png", hint: "The map"), MarkupFormat.Html))
+			.IsEqualTo("<img class=\"ms-pueblo-image\" data-pueblo=\"img\" src=\"https://example.test/map.png\" alt=\"The map\">");
+		await Assert.That(Render(PuebloElements.Pane(MarkupText.Plain("x"), "map"), MarkupFormat.Html))
+			.IsEqualTo("<span class=\"ms-pueblo-pane\" data-pueblo=\"xch_pane\" data-name=\"map\">x</span>");
+		await Assert.That(Render(PuebloElements.Page(), MarkupFormat.Html)).IsEqualTo(string.Empty);
+		await Assert.That(Render(PuebloElements.Mode(PuebloMode.PureHtml), MarkupFormat.Html)).IsEqualTo(string.Empty);
+		await Assert.That(Render(PuebloElements.Sound("door.wav"), MarkupFormat.Html)).IsEqualTo(string.Empty)
+			.Because("a sound names a file in the world's own directory, which a browser cannot resolve");
+	}
+
+	[Test]
+	public async Task ABrowserIsSentNoAddressItCannotResolve()
+	{
+		await Assert.That(Render(PuebloElements.Image("map.png"), MarkupFormat.Html)).IsEqualTo(string.Empty);
+		await Assert.That(Render(PuebloElements.Image("javascript:alert(1)"), MarkupFormat.Html)).IsEqualTo(string.Empty);
+	}
+
+	/// <summary>
+	/// Plain HTML stays <c>HtmlMarkup</c>'s, and styling and links stay <c>AnsiMarkup</c>'s: this package
+	/// is only what Pueblo adds to HTML.
+	/// </summary>
+	[Test]
+	public async Task TheOtherKindsAreUnaffected()
+	{
+		var bold = MarkupText.Wrap(AnsiMarkup.Create(bold: true), "loud");
+		var link = MarkupText.Wrap(AnsiMarkup.Create(linkUrl: "look", linkKind: LinkKind.Command), "look");
+		var tag = MarkupText.Wrap(HtmlMarkup.Create("pre"), "spaced");
+
+		await Assert.That(Render(link, MarkupFormat.Pueblo)).Contains("<A XCH_CMD=\"look\">");
+		await Assert.That(Render(bold, MarkupFormat.Pueblo)).Contains("loud");
+		await Assert.That(Render(tag, MarkupFormat.Pueblo)).IsEqualTo("<pre>spaced</pre>");
+	}
+
+	[Test]
+	public async Task AnExtensionRoundTripsThroughTheSerializer()
+	{
+		var line = MarkupText.Concat(
+			PuebloElements.Sound("door.wav", volume: 80),
+			PuebloElements.Pane(MarkupText.Plain("Map"), "map"));
+
+		var back = MarkupTextSerializer.Deserialize(MarkupTextSerializer.Serialize(line, Registry), Registry);
+
+		await Assert.That(back.Render(MarkupFormat.Pueblo, Registry)).IsEqualTo(Render(line, MarkupFormat.Pueblo));
+	}
+
+	[Test]
+	public async Task AnExtensionMeasuresNothing()
+	{
+		var line = MarkupText.Concat(PuebloElements.Page(), MarkupText.Plain("ab"));
+
+		await Assert.That(DisplayWidth.Of(line.Text)).IsEqualTo(2);
+	}
+
+	[Test]
+	[Arguments("has space")]
+	[Arguments("")]
+	public async Task AnElementNameIsChecked(string name)
+	{
+		await Assert.That(() => PuebloElement.Standalone(name)).Throws<ArgumentException>();
+	}
+}
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/README.md b/README.md
index ca911d8..81f485a 100644
--- a/README.md
+++ b/README.md
@@ -31,6 +31,8 @@ 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 |
@@ -38,6 +40,13 @@ dotnet add package MarkupString.Html
 | [`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.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.Mxp`](https://www.nuget.org/packages/MarkupString.Mxp) | MXP's own elements — sounds, images, gauges, status text, frames — as MXP tags, as the nearest HTML, and as nothing for a client with neither. |
+| [`MarkupString.Pueblo`](https://www.nuget.org/packages/MarkupString.Pueblo) | Pueblo's own extensions — its panes, page control, sounds and mode switches — the `xch_` vocabulary nothing else reads. |
+
+The last three are the **tag dialects**: they write markup as tags in the stream, where
+`MarkupString.Ansi` writes escape sequences. Each says what it renders, because the dialects are not
+interchangeable — Pueblo's command link is `<A XCH_CMD>` and MXP's is `<SEND HREF>`, and each client
+shows the other's as text. Take the ones your audience speaks.
 
 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
diff --git a/docs/formats.md b/docs/formats.md
index 66ecb1c..0ca3481 100644
--- a/docs/formats.md
+++ b/docs/formats.md
@@ -12,6 +12,11 @@ text.RenderTo(MarkupFormat.Ansi, bufferWriter);  // straight into a buffer, no s
 `ToString()` is always the plain text. There is no `ToAnsi()` or `ToHtml()`: rendering is a
 decision about an audience, and it is made where that audience is known.
 
+Three of the kind packages — `MarkupString.Html`, `MarkupString.Mxp` and `MarkupString.Pueblo` — are the
+**tag dialects**: they write markup as tags in the stream, where `MarkupString.Ansi` writes escape
+sequences. They are not interchangeable, which is why each has its own package and its own section
+below.
+
 ## The six built-in formats
 
 | Format | Text encoding | What `MarkupString.Ansi` writes | What `MarkupString.Html` writes |
@@ -102,6 +107,43 @@ var registry = MarkupRegistry.Empty.WithAnsi().WithHtml().With(new PreFramer());
 
 One framer per format; the last one registered wins.
 
+## MXP's own elements
+
+`MarkupString.Mxp` carries the elements MXP defines beyond styling and links — `SOUND`, `MUSIC`,
+`IMAGE`, `GAUGE`, `STAT`, `FRAME`, `VAR`, `EXPIRE`, `RELOCATE`, `USER`, `PASSWORD`, `NOBR`, `SBR` — and
+anything else through `MxpElement` itself.
+
+```csharp
+MarkupRegistry.Default = MarkupRegistry.Empty.WithAnsi().WithHtml().WithMxp();
+
+var line = MarkupText.Concat(
+  MxpElements.Sound("door.wav", volume: 80, url: "https://example.test/sounds/"),
+  MarkupText.Plain("The door creaks open."));
+
+line.Render(MarkupFormat.Mxp);   // <SOUND door.wav V=80 U=...>The door creaks open.
+line.Render(MarkupFormat.Html);  // <audio ... autoplay></audio>The door creaks open.
+line.Render(MarkupFormat.Ansi);  // The door creaks open.
+```
+
+An element that wraps nothing is a point in the text; one that wraps content (`FRAME`, `VAR`) marks the
+text it applies to. **A format with no MXP writes nothing at all**, including the zero-width carrier a
+standalone element rides on, so one piece of text is safe to send to every client — a terminal is sent
+neither the tag nor the character it rode on.
+
+`WithMxp(element => ...)` holds what is written to what the client said it can render, from MXP's
+`<SUPPORT>` exchange at the telnet layer. A refused element is written as a format without MXP writes it
+— nothing, or the content alone for one that wraps, so a `FRAME` a client cannot open does not take the
+text inside it with it. With no predicate every element is written: never asked is not refused.
+
+## Pueblo's own extensions
+
+`MarkupString.Pueblo` is the same idea for the other dialect: `xch_pane`, `xch_page`, `xch_prefetch`,
+the `xch_sound` family and the mode switches — what a Pueblo client reads and nothing else does.
+
+Plain HTML stays `HtmlMarkup`'s, because Pueblo reads an HTML subset, and styling and links stay
+`AnsiMarkup`'s, because those are already written per dialect. Only what is Pueblo's alone lives here,
+and a format that cannot express it writes nothing at all, carrier included.
+
 ## Line framers
 
 An `ILineFramer` writes a prefix at the start of every line that has content — a line holding