From fe4f8379767ec5933a6f21aa0ed69aa0200428b9 Mon Sep 17 00:00:00 2001
From: Harry Cordewener <admin@twilightdays.org>
Date: Sun, 20 Sep 2026 13:39:11 -0500
Subject: [PATCH 1/4] Add MarkupString.Mxp: MXP's own elements

MXP defines more than styling and links -- sounds, images, gauges, status
text, frames, variables, expiring links, relocation, the login helpers and the
break hints. MxpElements builds each of them, and MxpElement writes one the
specification does not define.

An element that wraps nothing is a point in the text, carried the way a bell
is; one that wraps content marks the text it applies to. A format with no MXP
writes nothing at all, the carrier included, so one piece of text is safe to
send to every client: a terminal is sent neither a tag it would show as text
nor the zero-width space that tag rode on. A browser gets the nearest thing it
has -- an img, an audio, a span a page can draw a gauge from -- and only when
the element carries an absolute http or https URL of its own, since MXP's
FName names a file in the game's own directory that a browser cannot resolve.

Whether a client can render an element is a different question, answered by
MXP's SUPPORT exchange at the telnet layer; what to do about the answer is the
application's.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  14 ++
 .../MarkupString.AotSmoke.csproj              |   2 +
 MarkupString.AotSmoke/Program.cs              |   9 +-
 .../Emitters/MxpElementEmitter.cs             |  71 ++++++
 MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs   | 155 +++++++++++++
 MarkupString.Mxp/MarkupString.Mxp.csproj      |  25 ++
 MarkupString.Mxp/MxpElement.cs                | 101 ++++++++
 MarkupString.Mxp/MxpElementCodec.cs           |  68 ++++++
 MarkupString.Mxp/MxpElements.cs               | 218 ++++++++++++++++++
 MarkupString.Mxp/MxpRegistration.cs           |  30 +++
 MarkupString.Mxp/PublicAPI.Shipped.txt        |   0
 MarkupString.Mxp/PublicAPI.Unshipped.txt      |  83 +++++++
 MarkupString.Mxp/README.md                    |  48 ++++
 MarkupString.Tests/MarkupString.Tests.csproj  |   1 +
 MarkupString.Tests/Mxp/MxpElementTests.cs     | 180 +++++++++++++++
 MarkupString.slnx                             |   1 +
 README.md                                     |   2 +
 docs/formats.md                               |  26 +++
 18 files changed, 1032 insertions(+), 2 deletions(-)
 create mode 100644 MarkupString.Mxp/Emitters/MxpElementEmitter.cs
 create mode 100644 MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs
 create mode 100644 MarkupString.Mxp/MarkupString.Mxp.csproj
 create mode 100644 MarkupString.Mxp/MxpElement.cs
 create mode 100644 MarkupString.Mxp/MxpElementCodec.cs
 create mode 100644 MarkupString.Mxp/MxpElements.cs
 create mode 100644 MarkupString.Mxp/MxpRegistration.cs
 create mode 100644 MarkupString.Mxp/PublicAPI.Shipped.txt
 create mode 100644 MarkupString.Mxp/PublicAPI.Unshipped.txt
 create mode 100644 MarkupString.Mxp/README.md
 create mode 100644 MarkupString.Tests/Mxp/MxpElementTests.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 98093eb..948e0fd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,20 @@ 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()` installs it; `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..6687fa7
--- /dev/null
+++ b/MarkupString.Mxp/Emitters/MxpElementEmitter.cs
@@ -0,0 +1,71 @@
+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
+{
+	/// <summary>The one instance; the emitter carries no state.</summary>
+	public static readonly MxpElementEmitter Instance = new();
+
+	private MxpElementEmitter()
+	{
+	}
+
+	/// <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;
+		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..b691fee
--- /dev/null
+++ b/MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs
@@ -0,0 +1,155 @@
+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.
+/// </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));
+		output.Write("\" autoplay></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..a9564f6
--- /dev/null
+++ b/MarkupString.Mxp/MxpRegistration.cs
@@ -0,0 +1,30 @@
+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>
+	/// 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>
+	public static MarkupRegistry WithMxp(this MarkupRegistry registry)
+	{
+		ArgumentNullException.ThrowIfNull(registry);
+
+		return registry
+			.With(MxpElementEmitter.Instance)
+			.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..42ffee6
--- /dev/null
+++ b/MarkupString.Mxp/PublicAPI.Unshipped.txt
@@ -0,0 +1,83 @@
+#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) -> MarkupString.MarkupRegistry!
+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..d0ea7bc
--- /dev/null
+++ b/MarkupString.Mxp/README.md
@@ -0,0 +1,48 @@
+# 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 autoplay>`, 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 this package does not decide
+
+Whether a client can render an element is answered by MXP's `<SUPPORT>` exchange, which belongs to the
+telnet layer ([TelnetNegotiationCore](https://github.com/HarryCordewener/TelnetNegotiationCore)), and what
+to do about the answer is the application's. 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..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..d518914
--- /dev/null
+++ b/MarkupString.Tests/Mxp/MxpElementTests.cs
@@ -0,0 +1,180 @@
+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\" autoplay></audio>");
+		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");
+	}
+
+	// ── 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..1393c8c 100644
--- a/docs/formats.md
+++ b/docs/formats.md
@@ -102,6 +102,32 @@ 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.
+
+Whether a given client can render an element is a different question, answered by MXP's `<SUPPORT>`
+exchange at the telnet layer; what to do about the answer is the application's.
+
 ## Line framers
 
 An `ILineFramer` writes a prefix at the start of every line that has content — a line holding

From 3e6859abfa94757d77f16ddce3be746aca8fb804 Mon Sep 17 00:00:00 2001
From: Harry Cordewener <admin@twilightdays.org>
Date: Sun, 20 Sep 2026 14:14:51 -0500
Subject: [PATCH 2/4] MXP: hold elements to what the client said, and stop
 asking a browser to autoplay

WithMxp now takes a predicate carrying the answers to MXP's SUPPORT exchange.
An element the client refused is written the way a format without MXP writes
it: nothing for one that stands alone, and the content alone for one that
wraps -- which is the half that matters, since a FRAME a client cannot open
would otherwise take the text inside it somewhere nobody sees. Without a
predicate every element is written; a client that was never asked has not
refused anything.

The HTML audio element loses its autoplay attribute. The tag is standard HTML
rather than anything of Pueblo's, but a browser refuses audible autoplay until
the person has interacted with the page, so it would have played nothing and
said nothing about why. Whether it sounds is the page's decision, from the
data-mxp attribute, as it is for a bell.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  7 ++-
 .../Emitters/MxpElementEmitter.cs             | 27 ++++++++++--
 MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs   |  9 +++-
 MarkupString.Mxp/MxpRegistration.cs           | 15 ++++++-
 MarkupString.Mxp/PublicAPI.Unshipped.txt      |  3 +-
 MarkupString.Mxp/README.md                    | 23 ++++++++--
 MarkupString.Tests/Mxp/MxpElementTests.cs     | 44 ++++++++++++++++++-
 docs/formats.md                               |  6 ++-
 8 files changed, 117 insertions(+), 17 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 948e0fd..755cec2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,8 +19,11 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   - 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()` installs it; `new MxpSilentEmitter(MarkupFormat.Html)` after it keeps MXP out of the
-    browser entirely.
+  - `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
 
diff --git a/MarkupString.Mxp/Emitters/MxpElementEmitter.cs b/MarkupString.Mxp/Emitters/MxpElementEmitter.cs
index 6687fa7..0680f30 100644
--- a/MarkupString.Mxp/Emitters/MxpElementEmitter.cs
+++ b/MarkupString.Mxp/Emitters/MxpElementEmitter.cs
@@ -12,11 +12,26 @@ namespace MarkupString.Mxp;
 /// </remarks>
 public sealed class MxpElementEmitter : IMarkupEmitter
 {
-	/// <summary>The one instance; the emitter carries no state.</summary>
-	public static readonly MxpElementEmitter Instance = new();
+	private readonly Func<MxpElement, bool>? _supports;
 
-	private MxpElementEmitter()
+	/// <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/>
@@ -32,6 +47,12 @@ public void Emit(IMarkup markup, ReadOnlySpan<char> body, in EmitContext context
 		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;
diff --git a/MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs b/MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs
index b691fee..772c8aa 100644
--- a/MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs
+++ b/MarkupString.Mxp/Emitters/MxpHtmlEmitter.cs
@@ -6,7 +6,8 @@ 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.
+/// 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
@@ -84,7 +85,11 @@ private static void WriteAudio(MxpElement element, IBufferWriter<char> output)
 		output.Write(element.Name.ToUpperInvariant());
 		output.Write("\" src=\"");
 		output.Write(WebUtility.HtmlEncode(source));
-		output.Write("\" autoplay></audio>");
+
+		// 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)
diff --git a/MarkupString.Mxp/MxpRegistration.cs b/MarkupString.Mxp/MxpRegistration.cs
index a9564f6..394fed5 100644
--- a/MarkupString.Mxp/MxpRegistration.cs
+++ b/MarkupString.Mxp/MxpRegistration.cs
@@ -10,16 +10,27 @@ public static class MxpRegistration
 	/// 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>
-	public static MarkupRegistry WithMxp(this MarkupRegistry registry)
+	/// <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(MxpElementEmitter.Instance)
+			.With(supports is null ? MxpElementEmitter.Instance : new MxpElementEmitter(supports))
 			.With(MxpHtmlEmitter.Instance)
 			.With(new MxpSilentEmitter(MarkupFormat.Ansi))
 			.With(new MxpSilentEmitter(MarkupFormat.Pueblo))
diff --git a/MarkupString.Mxp/PublicAPI.Unshipped.txt b/MarkupString.Mxp/PublicAPI.Unshipped.txt
index 42ffee6..c14bf6b 100644
--- a/MarkupString.Mxp/PublicAPI.Unshipped.txt
+++ b/MarkupString.Mxp/PublicAPI.Unshipped.txt
@@ -78,6 +78,7 @@ static MarkupString.Mxp.MxpElement.Standalone(string! name, params System.ReadOn
 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) -> MarkupString.MarkupRegistry!
+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
index d0ea7bc..41e4a22 100644
--- a/MarkupString.Mxp/README.md
+++ b/MarkupString.Mxp/README.md
@@ -28,7 +28,7 @@ included, so the same text is safe to send to every client.
 | | MXP | HTML | everything else |
 |---|---|---|---|
 | `IMAGE` | the tag | `<img>`, when the element carries a URL | nothing |
-| `SOUND`, `MUSIC` | the tag | `<audio autoplay>`, when it 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 |
@@ -37,11 +37,26 @@ Every HTML element carries its MXP name in `data-mxp` and an `ms-mxp-*` class, s
 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
 
-Whether a client can render an element is answered by MXP's `<SUPPORT>` exchange, which belongs to the
-telnet layer ([TelnetNegotiationCore](https://github.com/HarryCordewener/TelnetNegotiationCore)), and what
-to do about the answer is the application's. This package renders what it is given.
+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
 
diff --git a/MarkupString.Tests/Mxp/MxpElementTests.cs b/MarkupString.Tests/Mxp/MxpElementTests.cs
index d518914..4db38b5 100644
--- a/MarkupString.Tests/Mxp/MxpElementTests.cs
+++ b/MarkupString.Tests/Mxp/MxpElementTests.cs
@@ -108,7 +108,8 @@ 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\" autoplay></audio>");
+			.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))
@@ -146,6 +147,47 @@ public async Task ABrowserCanBeKeptOutOfMxpEntirely()
 		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]
diff --git a/docs/formats.md b/docs/formats.md
index 1393c8c..763ac4a 100644
--- a/docs/formats.md
+++ b/docs/formats.md
@@ -125,8 +125,10 @@ text it applies to. **A format with no MXP writes nothing at all**, including th
 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.
 
-Whether a given client can render an element is a different question, answered by MXP's `<SUPPORT>`
-exchange at the telnet layer; what to do about the answer is the application's.
+`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
 

From 7cf689feddd9363e90a16052a7ca99041f680cbd Mon Sep 17 00:00:00 2001
From: Harry Cordewener <admin@twilightdays.org>
Date: Sun, 20 Sep 2026 16:16:29 -0500
Subject: [PATCH 3/4] Add MarkupString.Pueblo: Pueblo's own extensions

HtmlMarkup means HTML, and Pueblo reads an HTML subset, so plain tags stay
where they are. What did not have a home is the part that is Pueblo's alone:
xch_pane, xch_page, xch_prefetch, xch_mudtext, the xch_sound family, the
xch_mode switches, and an img carrying xch_cmd, xch_hint or xch_graph. Names
and shapes come from the Pueblo client's own tag and attribute tables.

They render as Pueblo tags for Pueblo, as an image or a span for a browser
where one fits, and as nothing at all everywhere else -- an MXP client shows
xch_ anything as text -- with the zero-width carrier dropped too.

Nothing about the existing kinds changes: styling and links stay AnsiMarkup's,
which already writes each dialect's own form, and the Pueblo handshake stays
the telnet layer's.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  60 +++++++
 .../MarkupString.AotSmoke.csproj              |   2 +
 MarkupString.AotSmoke/Program.cs              |   8 +-
 .../Emitters/PuebloElementEmitter.cs          |  90 +++++++++++
 .../Emitters/PuebloHtmlEmitter.cs             |  79 +++++++++
 .../MarkupString.Pueblo.csproj                |  25 +++
 MarkupString.Pueblo/PublicAPI.Shipped.txt     |   0
 MarkupString.Pueblo/PublicAPI.Unshipped.txt   |  76 +++++++++
 MarkupString.Pueblo/PuebloElement.cs          |  85 ++++++++++
 MarkupString.Pueblo/PuebloElementCodec.cs     |  69 ++++++++
 MarkupString.Pueblo/PuebloElements.cs         | 148 +++++++++++++++++
 MarkupString.Pueblo/PuebloRegistration.cs     |  41 +++++
 MarkupString.Pueblo/README.md                 |  54 +++++++
 MarkupString.Tests/MarkupString.Tests.csproj  |   1 +
 .../Pueblo/PuebloElementTests.cs              | 150 ++++++++++++++++++
 MarkupString.slnx                             |   1 +
 README.md                                     |   2 +
 docs/formats.md                               |   9 ++
 18 files changed, 898 insertions(+), 2 deletions(-)
 create mode 100644 MarkupString.Pueblo/Emitters/PuebloElementEmitter.cs
 create mode 100644 MarkupString.Pueblo/Emitters/PuebloHtmlEmitter.cs
 create mode 100644 MarkupString.Pueblo/MarkupString.Pueblo.csproj
 create mode 100644 MarkupString.Pueblo/PublicAPI.Shipped.txt
 create mode 100644 MarkupString.Pueblo/PublicAPI.Unshipped.txt
 create mode 100644 MarkupString.Pueblo/PuebloElement.cs
 create mode 100644 MarkupString.Pueblo/PuebloElementCodec.cs
 create mode 100644 MarkupString.Pueblo/PuebloElements.cs
 create mode 100644 MarkupString.Pueblo/PuebloRegistration.cs
 create mode 100644 MarkupString.Pueblo/README.md
 create mode 100644 MarkupString.Tests/Pueblo/PuebloElementTests.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 755cec2..fdcb411 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,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.
+
 - **`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
@@ -27,6 +37,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.
+
 - **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
@@ -61,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.
@@ -91,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
@@ -120,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
@@ -136,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 9f4d4ca..820fcfb 100644
--- a/MarkupString.AotSmoke/MarkupString.AotSmoke.csproj
+++ b/MarkupString.AotSmoke/MarkupString.AotSmoke.csproj
@@ -19,6 +19,7 @@
     <TrimmerRootAssembly Include="MarkupString.Ansi" />
     <TrimmerRootAssembly Include="MarkupString.Html" />
     <TrimmerRootAssembly Include="MarkupString.Mxp" />
+    <TrimmerRootAssembly Include="MarkupString.Pueblo" />
   </ItemGroup>
 
   <ItemGroup>
@@ -26,5 +27,6 @@
     <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 850f3df..ef6eb37 100644
--- a/MarkupString.AotSmoke/Program.cs
+++ b/MarkupString.AotSmoke/Program.cs
@@ -3,13 +3,14 @@
 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().WithMxp();
+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");
@@ -40,7 +41,10 @@
 // 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]);
+// 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.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..03012dd
--- /dev/null
+++ b/MarkupString.Pueblo/README.md
@@ -0,0 +1,54 @@
+# 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
+```
+
+## 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 7f67df4..5652398 100644
--- a/MarkupString.Tests/MarkupString.Tests.csproj
+++ b/MarkupString.Tests/MarkupString.Tests.csproj
@@ -20,5 +20,6 @@
     <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/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 e30a8b9..5ea97db 100644
--- a/MarkupString.slnx
+++ b/MarkupString.slnx
@@ -3,6 +3,7 @@
   <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 757af30..a259a5f 100644
--- a/README.md
+++ b/README.md
@@ -32,6 +32,7 @@ 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 |
@@ -40,6 +41,7 @@ dotnet add package MarkupString.Mxp
 | [`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 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 763ac4a..02f5e32 100644
--- a/docs/formats.md
+++ b/docs/formats.md
@@ -130,6 +130,15 @@ neither the tag nor the character it rode on.
 — 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

From 2717e4d53cf717c5c45721e14a4fd5a529fd5c6c Mon Sep 17 00:00:00 2001
From: Harry Cordewener <admin@twilightdays.org>
Date: Sun, 20 Sep 2026 16:43:01 -0500
Subject: [PATCH 4/4] Name the three tag dialects as a family in the docs

Html, Mxp and Pueblo cover one space between them -- markup written as tags in
the stream, where Ansi writes escape sequences -- and the guides now say so.
The packages keep their own names, because the dialects are not
interchangeable: a Pueblo command link is <A XCH_CMD>, an MXP one is
<SEND HREF>, and each client shows the other's as text. A reader picking a
package still reads what it renders.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 MarkupString.Html/README.md   | 6 ++++++
 MarkupString.Mxp/README.md    | 5 +++++
 MarkupString.Pueblo/README.md | 5 +++++
 README.md                     | 5 +++++
 docs/formats.md               | 5 +++++
 5 files changed, 26 insertions(+)

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/README.md b/MarkupString.Mxp/README.md
index 41e4a22..8fd3c77 100644
--- a/MarkupString.Mxp/README.md
+++ b/MarkupString.Mxp/README.md
@@ -23,6 +23,11 @@ An element that wraps nothing is a point in the text, carried the way a bell is;
 (`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 |
diff --git a/MarkupString.Pueblo/README.md b/MarkupString.Pueblo/README.md
index 03012dd..f055cee 100644
--- a/MarkupString.Pueblo/README.md
+++ b/MarkupString.Pueblo/README.md
@@ -8,6 +8,11 @@ nothing else does.
 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
diff --git a/README.md b/README.md
index a259a5f..81f485a 100644
--- a/README.md
+++ b/README.md
@@ -43,6 +43,11 @@ dotnet add package MarkupString.Pueblo
 | [`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
 rather than a fork.
diff --git a/docs/formats.md b/docs/formats.md
index 02f5e32..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 |