diff --git a/CHANGELOG.md b/CHANGELOG.md
index 98093eb..755cec2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,23 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **`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
+
 - **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
diff --git a/MarkupString.AotSmoke/MarkupString.AotSmoke.csproj b/MarkupString.AotSmoke/MarkupString.AotSmoke.csproj
index f0928af..9f4d4ca 100644
--- a/MarkupString.AotSmoke/MarkupString.AotSmoke.csproj
+++ b/MarkupString.AotSmoke/MarkupString.AotSmoke.csproj
@@ -18,11 +18,13 @@
     <TrimmerRootAssembly Include="MarkupString" />
     <TrimmerRootAssembly Include="MarkupString.Ansi" />
     <TrimmerRootAssembly Include="MarkupString.Html" />
+    <TrimmerRootAssembly Include="MarkupString.Mxp" />
   </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" />
   </ItemGroup>
 </Project>
diff --git a/MarkupString.AotSmoke/Program.cs b/MarkupString.AotSmoke/Program.cs
index 4c87612..850f3df 100644
--- a/MarkupString.AotSmoke/Program.cs
+++ b/MarkupString.AotSmoke/Program.cs
@@ -2,13 +2,14 @@
 using MarkupString;
 using MarkupString.Ansi;
 using MarkupString.Html;
+using MarkupString.Mxp;
 
 // 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();
 
 // 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 +36,11 @@
 	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/");
+
+var text = MarkupText.Concat([red, wide, nested, MarkupText.Space, link, MarkupText.Space, command, sound]);
 
 MarkupFormat[] formats =
 [
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..41e4a22
--- /dev/null
+++ b/MarkupString.Mxp/README.md
@@ -0,0 +1,63 @@
+# 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.
+
+## 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.Tests/MarkupString.Tests.csproj b/MarkupString.Tests/MarkupString.Tests.csproj
index 64cb666..7f67df4 100644
--- a/MarkupString.Tests/MarkupString.Tests.csproj
+++ b/MarkupString.Tests/MarkupString.Tests.csproj
@@ -19,5 +19,6 @@
     <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" />
   </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("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/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.slnx b/MarkupString.slnx
index f5a6ed7..e30a8b9 100644
--- a/MarkupString.slnx
+++ b/MarkupString.slnx
@@ -2,6 +2,7 @@
   <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.Tests/MarkupString.Tests.csproj" />
   <Project Path="MarkupString/MarkupString.csproj" />
 </Solution>
diff --git a/README.md b/README.md
index ca911d8..757af30 100644
--- a/README.md
+++ b/README.md
@@ -31,6 +31,7 @@ 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
 ```
 
 | Package | What it gives you |
@@ -38,6 +39,7 @@ 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. |
 
 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..763ac4a 100644
--- a/docs/formats.md
+++ b/docs/formats.md
@@ -102,6 +102,34 @@ 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.
+
 ## Line framers
 
 An `ILineFramer` writes a prefix at the start of every line that has content — a line holding