diff --git a/.gitignore b/.gitignore
index 4ae580f..7005519 100644
--- a/.gitignore
+++ b/.gitignore
@@ -328,3 +328,4 @@ ASALocalRun/
 
 # MFractors (Xamarin productivity tool) working folder
 .mfractor/
+*.stackdump
diff --git a/docs/advanced-filemaker-scripting-syntax.md b/docs/advanced-filemaker-scripting-syntax.md
index 17686fc..8d1ba93 100644
--- a/docs/advanced-filemaker-scripting-syntax.md
+++ b/docs/advanced-filemaker-scripting-syntax.md
@@ -59,8 +59,9 @@ the same flag:
 
 - `Exit after last: On` on found-set iterators.
 - `With dialog: Off` on steps that can suppress their confirmation UI.
-- `Restore: On|Off` — **reserved**. Not currently emitted by any POCO;
-  see "What to drop vs. surface" below for the rationale.
+- `Restore: On|Off` — emitted by steps whose XML carries a meaningful
+  stored-state flag (e.g. Enter Find Mode); see "What to drop vs.
+  surface" below for the fixed-value cases that stay XML-only.
 
 ### Form 3 — trailing `; Kind: [...]` blocks
 
@@ -125,16 +126,16 @@ Pro never alters it, never emits it in clipboard output, and no user
 workflow produces a different value. Round-tripping such state adds
 visual noise for zero information.
 
-### Canonical drop: `<Restore state="False"/>` on `If`
+### Canonical hidden state: `<Restore state="False"/>` on `If`
 
-Upstream `agentic-fm` snippets include the element; FM Pro's own
-clipboard output never does; no FM Pro user interaction produces
-`state="True"`. `IfStep` drops it on both read and write. The audit
-entry documents the drop:
-
-> &lt;Restore state="False"/&gt; — intentionally dropped. FM Pro never
-> changes the value and never emits the element in clipboard output; it
-> carries no information worth round-tripping.
+The vendored canonical reference (`docs/filemaker-xml-canonical/`,
+round-trip verified against FM Pro 2025/2026) shows FM Pro *does* write
+the element, so `IfStep` emits it in XML — but the value is fixed (no FM
+Pro user interaction produces `state="True"`), so it stays hidden from
+the display line: the shape declares it `Display = DisplayMode.Hidden`
+and it round-trips in XML only. The same treatment applies to Loop's
+`<Restore>`/`<FlushType>` pair. See the divergence review log in
+`docs/filemaker-xml-canonical/divergence-review.md`.
 
 ### Canonical surface: field `id` via `(#id)` suffix
 
diff --git a/docs/filemaker-xml-canonical/LICENSE.md b/docs/filemaker-xml-canonical/LICENSE.md
new file mode 100644
index 0000000..9a5bc01
--- /dev/null
+++ b/docs/filemaker-xml-canonical/LICENSE.md
@@ -0,0 +1,40 @@
+# License — Vendored canonical FileMaker XML references
+
+The reference material in this directory is **not** original to SharpFM. It is
+vendored, unmodified except where noted, from two open-source projects by
+**Andrew Kear** of **Clockwork Creative Technology** (https://www.clockworkct.co.uk),
+and is redistributed here under its original licence.
+
+## License: CC BY 4.0
+
+Both sources are licensed under the
+[Creative Commons Attribution 4.0 International License](https://creativecommons.org/licenses/by/4.0/).
+
+You are free to share and adapt the material for any purpose, provided you give
+appropriate credit. SharpFM gives that credit here and in the `README.md`
+alongside this file.
+
+## Attribution
+
+- **FileMaker XML Snippet Claude Skill** — reverse-engineered specification of
+  FileMaker's `fmxmlsnippet` clipboard format.
+  Source: https://github.com/andykear/FileMaker-XMLsnippet-Claude-Skill
+  Vendored version: **v1.12** (FileMaker Pro 2026 / FM 26 support).
+  Vendored under `skill/`.
+
+- **Clockwork Inspector** — open-source FileMaker DDR / database-design XML
+  analyzer. SharpFM vendors only two extracts: the `FM_STEP_IDS` step catalog
+  and the `extractStepText` display renderer, used as a cross-check catalog and
+  a reference for SharpFM's own step-display convention.
+  Source: https://github.com/andykear/FileMaker-XML-inspector-open-source
+  Vendored version: **v2.0**.
+  Vendored under `inspector/`.
+
+## What SharpFM uses this for
+
+SharpFM is an XML-faithful FileMaker clipboard editor. These references are the
+authoritative description of the exact native XML FileMaker's Script Workspace
+paste handler accepts cleanly, including the documented silent-failure modes.
+SharpFM's step model is validated against them. No SharpFM source code is
+derived from Clockwork's code; the vendored files are reference data and are
+parsed at test time only.
diff --git a/docs/filemaker-xml-canonical/README.md b/docs/filemaker-xml-canonical/README.md
new file mode 100644
index 0000000..b659300
--- /dev/null
+++ b/docs/filemaker-xml-canonical/README.md
@@ -0,0 +1,45 @@
+# Canonical FileMaker XML references (vendored)
+
+This directory vendors the authoritative, reverse-engineered description of the
+native XML FileMaker Pro's Script Workspace paste handler accepts. SharpFM's
+script-step model (`src/SharpFM.Model/Scripting/`) is validated against it so
+that XML written back to the clipboard round-trips through FileMaker with no
+silently-dropped elements.
+
+See [`LICENSE.md`](LICENSE.md) for attribution. Both sources are CC BY 4.0,
+authored by Andrew Kear / Clockwork Creative Technology.
+
+## Layout
+
+| Path | Source | Used for |
+|------|--------|----------|
+| `skill/SKILL.md`, `skill/references/*.md` | FileMaker XML Snippet Skill **v1.12** | Canonical clip-XML skeletons per step. The refresh step extracts these fenced blocks into checked-in test fixtures (under `tests/SharpFM.Tests/CanonicalSkill/fixtures/`) that the round-trip suite reads — the markdown is not parsed live at test time. **Sole source of truth for clip-XML emission.** |
+| `skill/README.upstream.md` | same | The upstream project's own README, kept for provenance. |
+| `inspector/FM_STEP_IDS.js` | Clockwork Inspector **v2.0** | Verbatim 217-entry `stepId → {name, category}` catalog. Used as the **working list** to align SharpFM's POCO `StepMetadata` (Id/Name/Category) and find the steps we don't yet model. Once the POCOs match it, **SharpFM's `StepMetadata` is the authoritative catalog** — this file stays only as the upstream reference for spotting drift on future FM releases. |
+| `inspector/extractStepText.js` | Clockwork Inspector **v2.0** | Verbatim reference renderer for human-readable step text. Seeds SharpFM's `StepDisplayRenderer` convention. The Inspector's DDR parser is **not** reused — it targets a different XML dialect (database-design XML, not clip XML). |
+
+## Silent-failure modes (from `skill/references/core.md`)
+
+The paste handler is lenient as an XML parser but strict as a paste handler.
+Structurally valid XML can paste with data silently dropped. The verified modes
+SharpFM's renderer must respect:
+
+- **Set Variable** — the variable name must be in a `<Name>` child, present and
+  last. A bare `<n>` or misplaced name pastes with no variable name.
+- **Perform JavaScript in Web Viewer** — parameters use `<Parameters Count="N"><P>…</P></Parameters>`; a `<Parameter>` element is silently dropped.
+- **Install OnTimer Script** — the interval must be wrapped in `<Interval><Calculation>…</Calculation></Interval>`; a bare top-level `<Calculation>` binds to the wrong slot and the timer never fires.
+
+## Refreshing
+
+Run [`refresh-canonical.ps1`](refresh-canonical.ps1) to re-sync both sources
+from upstream. Review the diff before committing — upstream version bumps (new
+FM releases) may add steps or change canonical shapes, which is exactly the
+signal the audit tests are meant to surface. After refreshing, regenerate the
+test fixtures from the updated skill markdown:
+
+```
+dotnet run --file docs/filemaker-xml-canonical/extract-fixtures.cs
+```
+
+This rewrites `tests/SharpFM.Tests/CanonicalSkill/fixtures/` and reports any
+catalog ids left without a fixture.
diff --git a/docs/filemaker-xml-canonical/divergence-review.md b/docs/filemaker-xml-canonical/divergence-review.md
new file mode 100644
index 0000000..3d01718
--- /dev/null
+++ b/docs/filemaker-xml-canonical/divergence-review.md
@@ -0,0 +1,158 @@
+# Divergence review log
+
+Every place SharpFM's emitted XML **changed** to match the vendored skill's
+canonical form during the canonicalization audit. The policy is *trust the
+skill*: where our output differed, we adopt the skill's form and record the
+change here for a second review.
+
+Each entry: the step, what we emitted **before**, what we emit **now**, the
+skill section that mandates it, and a review box. Tick the box once a human has
+confirmed the change is correct.
+
+> Status legend: `[ ]` awaiting review · `[x]` reviewed & accepted · `[!]` flagged for discussion
+
+## Phase 5 — worst offenders
+
+### Set Variable (141) — no behavioral change
+- [ ] Already canonical (skill §3). Refactored to the shape-driven renderer;
+  emitted XML is byte-for-byte unchanged. Listed for completeness only.
+
+### If (68), Else If (125), Else (69) — added `<Restore>`
+- **Before:** `<Restore state="False"/>` was dropped on read and never emitted.
+- **Now:** emit `<Restore state="False"/>` as the first child (before
+  `<Calculation>` where present).
+- **Skill:** §8.1. Round-trip tested against FM Pro 2025/2026 — FileMaker *does*
+  write it. Supersedes the earlier `docs/advanced-filemaker-scripting-syntax.md`
+  note that claimed FM never emits it.
+- [ ] Reviewed
+
+### Loop (71) — added `<Restore>` and `<FlushType>`
+- **Before:** emitted no children.
+- **Now:** emit `<Restore state="False"/>` then `<FlushType value="Always"/>`.
+- **Skill:** §8.1.
+- [ ] Reviewed
+
+> Both values are fixed (FileMaker never varies them), so they are hidden from
+> the display line and round-tripped in XML only.
+
+### Install OnTimer Script (148) — element order Interval → Script
+- **Before:** emitted `<Script>` then `<Interval>`.
+- **Now:** emit `<Interval>` then `<Script>` (interval wrapped in `<Interval>`,
+  which was already correct).
+- **Skill:** §8.1 / §7.3. Out-of-order children bind the interval to the wrong
+  internal slot on paste (a verified silent-failure mode).
+- [ ] Reviewed
+
+### New Window (122) — `NewWndStyles` value type + optional slots
+- **Before:** emitted a text-bodied `<NewWndStyles>{raw string}</NewWndStyles>`
+  and always-present empty `<Height>`/`<Width>`/`<DistanceFromTop>`/
+  `<DistanceFromLeft>` elements; used generic `Calculation`…`Calculation5` fields.
+- **Now:** `<NewWndStyles .../>` is the attribute-bearing element produced by the
+  `NewWindowStyles` value type; `Name`, the four dimensions and `Layout` are
+  optional and omitted when unset.
+- **Skill:** windows reference.
+- [ ] Reviewed
+
+### Configure RAG Account (227) — inner wrapper + reorder
+- **Before:** emitted `RAGAccountName`, `Endpoint`, `AccessAPIKey`,
+  `VerifySSLCertificates` as flat `<Step>` children.
+- **Now:** `<VerifySSLCertificates state="False"/>` first, then a
+  `<ConfigureRAGAccount>` wrapper holding the (optional) account fields; empty
+  wrapper when unconfigured.
+- **Skill:** accounts/AI reference.
+- [ ] Reviewed
+
+### Go to Related Record (74) — dropped spurious `<Animation>`
+- **Before:** appended `<Animation value="None"/>` after `<Layout>`, and always
+  emitted `<Layout>` even when empty.
+- **Now:** no `<Animation>` element; `<Layout>` is optional (omitted when unset);
+  `<Table>` remains always-present.
+- **Skill:** navigation reference (documents no Animation for this step).
+- [ ] Reviewed
+
+## Phase 6 — batch migration
+
+### Go to Next Field (4) / Go to Previous Field (5) — id swap fixed
+- **Before:** our POCOs emitted id **5** for "Go to Next Field" and **4** for
+  "Go to Previous Field".
+- **Now:** Next = 4, Previous = 5.
+- **Sources:** both the skill and the inspector `FM_STEP_IDS` catalog agree
+  (4 = Next, 5 = Previous). Confirmed before flipping.
+- [ ] Reviewed
+
+### Trigger Claris Connect Flow (211) — step id 0 → 211
+- **Before:** `XmlId` was left 0 ("canonical id unconfirmed"); the step emitted
+  `<Step id="0" …>`.
+- **Now:** id 211 per the skill's control reference. The rest of the step's XML
+  was already canonical.
+- [ ] Reviewed
+
+### Batch migration — 64 steps to the shape engine
+The bulk of the remaining steps were migrated to the shape-driven renderer in
+one batch. The dominant change is **no longer emitting optional/empty child
+elements** (`<Field/>`, `<Calculation/>`, `<UniversalPathList/>`, dimension
+calcs, etc.) that FileMaker omits from an unconfigured step's canonical form;
+several steps also had element **reorders**, wrapper **nesting** (Add Account →
+`<AddAccount>`, Configure AI Account → `<SetLLMAccount>`, Insert Embedding →
+`<LLMEmbedding>`/`<LLMBulkEmbedding>`), a typo fix (`AccoutName` → `AccountName`
+on Configure AI Account), and the field-id and Trigger-Claris-Connect-Flow id
+fixes above. Every migrated step now round-trips to its skill canonical form
+(the `CanonicalSkillRoundTripTests` suite is the proof); the per-step
+`*Tests.cs` constants were updated to the canonical XML where they encoded the
+old form.
+- [ ] Reviewed (spot-check the per-step diffs in this commit)
+
+### Value types — stop emitting empty optional attributes
+- **Speak / `SpeechOptions`**: emit `WaitForCompletion` always but only the
+  populated `VoiceName`/`VoiceId`/`VoiceCreator` attributes.
+- **Send Event / `SendEventTarget`**: emit the three behaviour booleans always
+  but only the populated `TargetType`/`TargetName`/`id`/`class` attributes; the
+  step no longer emits an empty `<Text/>` element.
+- **Skill:** the canonical `<SpeechOptions>` / `<Event>` forms omit empty
+  optional attributes.
+- [ ] Reviewed
+
+### Second reorder/wrapper batch (16 steps)
+Move/Resize Window, Set Window Title, Convert File, Open Transaction (now emits
+`<Restore>`), Configure Prompt Template (now wraps in `<ConfigurePromptTemplate>`)
+and the data-file / window / object steps were reordered or had optional
+children dropped to match canonical, with their per-step test constants updated.
+- [ ] Reviewed
+
+### Final structural batch — to 99.2% round-tripping
+The remaining hard cases were resolved with targeted fixes (and the engine
+gained `Passthrough` parsing plus `FlagChild` / value-attr-bool / variable-text
+primitives): Insert From Device, Comment (self-closing divider), Perform
+JavaScript, Perform Script on Server with Callback, Set Web Viewer, Save Records
+as Excel, Replace Field Contents (re-emits `<Restore>`; `<SerialNumbers>` gains
+`increment`/`InitialValue`), Import/Export Records, Save Records as PDF (the
+`PDFOptions` value type gained `<PDFSaveType>`, page-range pages and security
+passwords), Speak / Send Event (value types stop emitting empty attributes), and
+Show Custom Dialog (optional title/message/geometry).
+
+**Result: 251 of 253 canonical fixtures round-trip (99.2%)** as of this batch;
+the Save a Copy as XML remodel below closed the gap to 100%.
+- [ ] Reviewed
+
+### Save a Copy as XML (003) — remodelled to the canonical element set
+- **Before:** a generic path/window-name model that could not express the
+  canonical children; tracked as the last `KnownDivergence`.
+- **Now:** the `<Option>` flag, the optional FM 26 `<OutputEntireBinaryData>` /
+  `<SpecifyJSONOptions>` flags, and the optional
+  `<SaXML><JSONOptions><Calculation>` export-options block.
+- **Skill:** files reference.
+- **Result: all 253 canonical fixtures round-trip (100%); `KnownDivergences` is
+  empty.**
+- [ ] Reviewed
+
+## Phase 7 — missing typed coverage
+
+### FM 26 PDF steps (243–247) — new typed POCOs
+- **Before:** Create PDF (243), Append PDF (244), Close PDF (245), Open PDF
+  (246) and Cancel PDF (247) fell through to `RawStep`.
+- **Now:** dedicated typed steps; Create PDF reuses the `PdfDocument` /
+  `PdfSecurity` / `PdfView` value types. Print PDF (242) and the MBS plugin step
+  (186) intentionally remain `RawStep` — their `PlatformData` blobs and
+  file-specific plugin `index` are preserved verbatim, never synthesized.
+- **Skill:** PDF reference.
+- [ ] Reviewed
diff --git a/docs/filemaker-xml-canonical/extract-fixtures.cs b/docs/filemaker-xml-canonical/extract-fixtures.cs
new file mode 100644
index 0000000..76780a0
--- /dev/null
+++ b/docs/filemaker-xml-canonical/extract-fixtures.cs
@@ -0,0 +1,160 @@
+// Generates the canonical-skill round-trip fixtures from the vendored skill
+// markdown into tests/SharpFM.Tests/CanonicalSkill/fixtures/. Run after a
+// refresh (see refresh-canonical.ps1):
+//
+//   dotnet run --file docs/filemaker-xml-canonical/extract-fixtures.cs
+//
+// Each fixture file is one canonical <Step> element; the round-trip test reads
+// id/name from the element's own attributes. The script also reports coverage
+// against the inspector catalog (FM_STEP_IDS.js) — the 217-entry working list.
+
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml.Linq;
+
+var repo = FindRepoRoot();
+var refDir = Path.Combine(repo, "docs", "filemaker-xml-canonical", "skill", "references");
+var outDir = Path.Combine(repo, "tests", "SharpFM.Tests", "CanonicalSkill", "fixtures");
+Directory.CreateDirectory(outDir);
+
+// Step-reference files, plus core.md under a strict guard. worked-example.md
+// (full snippet) and custom-functions.md (different <CustomFunction> root) are
+// excluded. core.md mixes the canonical Set Variable (§3) with disabled-step
+// illustrations (§4) that use multi-step fences and literal "..." placeholders,
+// so for core.md we take only single-<Step> fences with a numeric id and no
+// placeholder text.
+var files = new (string name, bool strict)[]
+{
+    ("steps-control.md", false), ("steps-fields-records.md", false),
+    ("steps-navigation-editing.md", false), ("steps-accounts-ai-misc.md", false),
+    ("steps-windows-files.md", false), ("steps-pdf.md", false), ("steps-plugin.md", false),
+    ("core.md", true),
+};
+
+var headingRx = new Regex(@"^#### (.*?) \((\d+)\)\s*$");
+var fixtures = new List<(int id, string name, string xml)>();
+int skippedBlocks = 0;
+
+foreach (var (file, strict) in files)
+{
+    var lines = File.ReadAllLines(Path.Combine(refDir, file));
+    string? curName = null;
+    bool inFence = false, expectNoOptTable = false;
+    var fence = new List<string>();
+
+    foreach (var raw in lines)
+    {
+        var line = raw.TrimEnd();
+
+        if (!inFence && line.StartsWith("```")) { inFence = true; fence.Clear(); continue; }
+        if (inFence && line.StartsWith("```"))
+        {
+            inFence = false;
+            ProcessFence(fence, curName, strict, ref expectNoOptTable);
+            continue;
+        }
+        if (inFence) { fence.Add(raw); continue; }
+
+        var hm = headingRx.Match(line);
+        if (hm.Success) { curName = hm.Groups[1].Value; expectNoOptTable = false; continue; }
+        if (line.StartsWith("####")) { curName = null; if (!line.Contains("No-option")) expectNoOptTable = false; continue; }
+
+        if (expectNoOptTable && line.StartsWith("|"))
+        {
+            var cells = line.Trim('|').Split('|').Select(c => c.Trim()).ToArray();
+            if (cells.Length >= 2 && int.TryParse(cells[1], out var rid) &&
+                !cells[0].Equals("Step", StringComparison.OrdinalIgnoreCase) && !cells[0].StartsWith("--"))
+            {
+                var xml = $"<Step enable=\"True\" id=\"{rid}\" name=\"{System.Security.SecurityElement.Escape(cells[0])}\"/>";
+                fixtures.Add((rid, cells[0], xml));
+            }
+        }
+    }
+}
+
+void ProcessFence(List<string> body, string? curName, bool strict, ref bool expectNoOptTable)
+{
+    var text = Dedent(body).Trim();
+    if (!text.Contains("<Step")) return;
+
+    XElement wrapper;
+    try { wrapper = XElement.Parse("<r>" + text + "</r>", LoadOptions.PreserveWhitespace); }
+    catch { skippedBlocks++; return; }
+
+    var steps = wrapper.Elements("Step").ToList();
+    if (steps.Count == 0) { skippedBlocks++; return; }
+
+    if (strict && (steps.Count != 1 || wrapper.DescendantNodes().OfType<XText>().Any(t => t.Value.Trim() == "...")))
+    {
+        skippedBlocks++;
+        return;
+    }
+
+    foreach (var step in steps)
+    {
+        var idAttr = step.Attribute("id")?.Value;
+        var nameAttr = step.Attribute("name")?.Value ?? curName ?? "";
+        if (idAttr is null) { skippedBlocks++; continue; }
+        if (!int.TryParse(idAttr, out var id)) { expectNoOptTable = true; continue; }
+        fixtures.Add((id, nameAttr, step.ToString(SaveOptions.None)));
+    }
+}
+
+static string Dedent(List<string> lines)
+{
+    var nonEmpty = lines.Where(l => l.Trim().Length > 0).ToList();
+    if (nonEmpty.Count == 0) return string.Empty;
+    int min = nonEmpty.Min(l => l.Length - l.TrimStart().Length);
+    return string.Join("\n", lines.Select(l => l.Length >= min ? l[min..] : l));
+}
+
+foreach (var f in Directory.GetFiles(outDir, "*.xml")) File.Delete(f);
+var byId = fixtures.GroupBy(f => f.id).OrderBy(g => g.Key);
+int written = 0, variants = 0;
+foreach (var grp in byId)
+{
+    var distinct = grp.GroupBy(f => Normalize(f.xml)).Select(g => g.First()).ToList();
+    for (int i = 0; i < distinct.Count; i++)
+    {
+        var f = distinct[i];
+        var suffix = distinct.Count > 1 ? $"-{i + 1}" : "";
+        var path = Path.Combine(outDir, $"{f.id:000}-{Slug(f.name)}{suffix}.xml");
+        File.WriteAllText(path, f.xml.Replace("\r\n", "\n").TrimEnd() + "\n");
+        written++;
+        if (distinct.Count > 1) variants++;
+    }
+}
+
+static string Normalize(string xml) => Regex.Replace(xml, @"\s+", " ").Trim();
+
+static string Slug(string name)
+{
+    var sb = new StringBuilder();
+    bool upNext = true;
+    foreach (var ch in name)
+    {
+        if (char.IsLetterOrDigit(ch)) { sb.Append(upNext ? char.ToUpper(ch) : ch); upNext = false; }
+        else upNext = true;
+    }
+    var s = sb.ToString();
+    return s.Length == 0 ? "Step" : s;
+}
+
+var fixtureIds = fixtures.Select(f => f.id).Distinct().ToHashSet();
+Console.WriteLine($"Fixtures written: {written} (across {byId.Count()} step ids, {variants} variant files)");
+Console.WriteLine($"Skipped illustrative blocks: {skippedBlocks}");
+
+var catalogJs = File.ReadAllText(Path.Combine(repo, "docs", "filemaker-xml-canonical", "inspector", "FM_STEP_IDS.js"));
+var catalog = Regex.Matches(catalogJs, @"(?m)^\s*(\d+):\s*\{name:'(.*?)',cat:'(.*?)'\}")
+    .Select(m => (id: int.Parse(m.Groups[1].Value), name: m.Groups[2].Value)).ToList();
+var missing = catalog.Where(c => !fixtureIds.Contains(c.id)).OrderBy(c => c.id).ToList();
+Console.WriteLine($"Catalog ids without a fixture ({missing.Count}): " +
+    string.Join(", ", missing.Select(m => $"{m.id} {m.name}")));
+
+static string FindRepoRoot()
+{
+    var dir = new DirectoryInfo(Environment.CurrentDirectory);
+    while (dir is not null && !File.Exists(Path.Combine(dir.FullName, "SharpFM.sln")))
+        dir = dir.Parent;
+    return dir?.FullName ?? throw new InvalidOperationException("SharpFM.sln not found above the working directory.");
+}
diff --git a/docs/filemaker-xml-canonical/inspector/FM_STEP_IDS.js b/docs/filemaker-xml-canonical/inspector/FM_STEP_IDS.js
new file mode 100644
index 0000000..2b9e1d8
--- /dev/null
+++ b/docs/filemaker-xml-canonical/inspector/FM_STEP_IDS.js
@@ -0,0 +1,222 @@
+// Extracted verbatim from clockwork-inspector.html.
+// Source: andykear/FileMaker-XML-inspector-open-source — Andrew Kear / Clockwork Creative Technology.
+// Licensed CC BY 4.0. See ../LICENSE.md.
+const FM_STEP_IDS = {
+  1: {name:'Perform Script',cat:'control'},
+  3: {name:'Save a Copy as XML',cat:'files'},
+  4: {name:'Go to Next Field',cat:'navigation'},
+  5: {name:'Go to Previous Field',cat:'navigation'},
+  6: {name:'Go to Layout',cat:'navigation'},
+  7: {name:'New Record/Request',cat:'records'},
+  8: {name:'Duplicate Record/Request',cat:'records'},
+  9: {name:'Delete Record/Request',cat:'records'},
+  10: {name:'Delete All Records',cat:'records'},
+  11: {name:'Insert from Index',cat:'fields'},
+  12: {name:'Insert from Last Visited',cat:'fields'},
+  13: {name:'Insert Current Date',cat:'fields'},
+  14: {name:'Insert Current Time',cat:'fields'},
+  16: {name:'Go to Record/Request/Page',cat:'navigation'},
+  17: {name:'Go to Field',cat:'navigation'},
+  18: {name:'Check Selection',cat:'spelling'},
+  19: {name:'Check Record',cat:'spelling'},
+  20: {name:'Check Found Set',cat:'spelling'},
+  21: {name:'Unsort Records',cat:'foundsets'},
+  22: {name:'Enter Find Mode',cat:'navigation'},
+  23: {name:'Show All Records',cat:'foundsets'},
+  24: {name:'Modify Last Find',cat:'foundsets'},
+  25: {name:'Omit Record',cat:'foundsets'},
+  26: {name:'Omit Multiple Records',cat:'foundsets'},
+  27: {name:'Show Omitted Only',cat:'foundsets'},
+  28: {name:'Perform Find',cat:'foundsets'},
+  29: {name:'Show/Hide Toolbars',cat:'windows'},
+  30: {name:'View As',cat:'windows'},
+  31: {name:'Adjust Window',cat:'windows'},
+  32: {name:'Open Help',cat:'navigation'},
+  33: {name:'Open File',cat:'files'},
+  34: {name:'Close File',cat:'files'},
+  35: {name:'Import Records',cat:'records'},
+  36: {name:'Export Records',cat:'records'},
+  37: {name:'Save a Copy as',cat:'files'},
+  38: {name:'Open Manage Database',cat:'navigation'},
+  39: {name:'Sort Records',cat:'foundsets'},
+  40: {name:'Relookup Field Contents',cat:'fields'},
+  41: {name:'Enter Preview Mode',cat:'navigation'},
+  42: {name:'Print Setup',cat:'files'},
+  43: {name:'Print',cat:'files'},
+  44: {name:'Exit Application',cat:'misc'},
+  45: {name:'Undo/Redo',cat:'editing'},
+  46: {name:'Cut',cat:'editing'},
+  47: {name:'Copy',cat:'editing'},
+  48: {name:'Paste',cat:'editing'},
+  49: {name:'Clear',cat:'editing'},
+  50: {name:'Select All',cat:'editing'},
+  51: {name:'Revert Record/Request',cat:'records'},
+  55: {name:'Enter Browse Mode',cat:'navigation'},
+  56: {name:'Insert Picture',cat:'fields'},
+  57: {name:'Send Event',cat:'misc'},
+  60: {name:'Insert Current User Name',cat:'fields'},
+  61: {name:'Insert Text',cat:'fields'},
+  62: {name:'Pause/Resume Script',cat:'control'},
+  63: {name:'Send Mail',cat:'misc'},
+  64: {name:'Send DDE Execute',cat:'misc'},
+  65: {name:'Dial Phone',cat:'misc'},
+  66: {name:'Speak',cat:'misc'},
+  67: {name:'Perform AppleScript',cat:'misc'},
+  68: {name:'If',cat:'control'},
+  69: {name:'Else',cat:'control'},
+  70: {name:'End If',cat:'control'},
+  71: {name:'Loop',cat:'control'},
+  72: {name:'Exit Loop If',cat:'control'},
+  73: {name:'End Loop',cat:'control'},
+  74: {name:'Go to Related Record',cat:'navigation'},
+  75: {name:'Commit Records/Requests',cat:'records'},
+  76: {name:'Set Field',cat:'fields'},
+  77: {name:'Insert Calculated Result',cat:'fields'},
+  79: {name:'Freeze Window',cat:'windows'},
+  80: {name:'Refresh Window',cat:'windows'},
+  81: {name:'Scroll Window',cat:'windows'},
+  82: {name:'New File',cat:'files'},
+  83: {name:'Change Password',cat:'accounts'},
+  84: {name:'Set Multi-User',cat:'files'},
+  85: {name:'Allow User Abort',cat:'control'},
+  86: {name:'Set Error Capture',cat:'control'},
+  87: {name:'Show Custom Dialog',cat:'misc'},
+  88: {name:'Open Script Workspace',cat:'navigation'},
+  89: {name:'# (comment)',cat:'control'},
+  90: {name:'Halt Script',cat:'control'},
+  91: {name:'Replace Field Contents',cat:'fields'},
+  92: {name:'Show/Hide Text Ruler',cat:'windows'},
+  93: {name:'Beep',cat:'misc'},
+  94: {name:'Set Use System Formats',cat:'files'},
+  95: {name:'Recover File',cat:'files'},
+  96: {name:'Save a Copy as Add-on Package',cat:'misc'},
+  97: {name:'Set Zoom Level',cat:'windows'},
+  98: {name:'Copy All Records/Requests',cat:'records'},
+  99: {name:'Go to Portal Row',cat:'navigation'},
+  101: {name:'Copy Record/Request',cat:'records'},
+  102: {name:'Flush Cache to Disk',cat:'misc'},
+  103: {name:'Exit Script',cat:'control'},
+  104: {name:'Delete Portal Row',cat:'records'},
+  105: {name:'Open Settings',cat:'navigation'},
+  106: {name:'Correct Word',cat:'spelling'},
+  107: {name:'Spelling Options',cat:'spelling'},
+  108: {name:'Select Dictionaries',cat:'spelling'},
+  109: {name:'Edit User Dictionary',cat:'spelling'},
+  111: {name:'Open URL',cat:'misc'},
+  112: {name:'Open Manage Value Lists',cat:'navigation'},
+  113: {name:'Open Sharing',cat:'navigation'},
+  114: {name:'Open File Options',cat:'navigation'},
+  115: {name:'Allow Formatting Bar',cat:'misc'},
+  116: {name:'Set Next Serial Value',cat:'fields'},
+  117: {name:'Execute SQL',cat:'misc'},
+  118: {name:'Open Hosts',cat:'navigation'},
+  119: {name:'Move/Resize Window',cat:'windows'},
+  120: {name:'Arrange All Windows',cat:'windows'},
+  121: {name:'Close Window',cat:'windows'},
+  122: {name:'New Window',cat:'windows'},
+  123: {name:'Select Window',cat:'windows'},
+  124: {name:'Set Window Title',cat:'windows'},
+  125: {name:'Else If',cat:'control'},
+  126: {name:'Constrain Found Set',cat:'foundsets'},
+  127: {name:'Extend Found Set',cat:'foundsets'},
+  128: {name:'Perform Find/Replace',cat:'editing'},
+  129: {name:'Open Find/Replace',cat:'navigation'},
+  130: {name:'Set Selection',cat:'editing'},
+  131: {name:'Insert File',cat:'fields'},
+  132: {name:'Export Field Contents',cat:'fields'},
+  133: {name:'Open Record/Request',cat:'records'},
+  134: {name:'Add Account',cat:'accounts'},
+  135: {name:'Delete Account',cat:'accounts'},
+  136: {name:'Reset Account Password',cat:'accounts'},
+  137: {name:'Enable Account',cat:'accounts'},
+  138: {name:'Re-Login',cat:'accounts'},
+  139: {name:'Convert File',cat:'files'},
+  140: {name:'Open Manage Data Sources',cat:'navigation'},
+  141: {name:'Set Variable',cat:'control'},
+  142: {name:'Install Menu Set',cat:'misc'},
+  143: {name:'Save Records as Excel',cat:'records'},
+  144: {name:'Save Records as PDF',cat:'records'},
+  145: {name:'Go to Object',cat:'navigation'},
+  146: {name:'Set Web Viewer',cat:'misc'},
+  147: {name:'Set Field By Name',cat:'fields'},
+  148: {name:'Install OnTimer Script',cat:'control'},
+  149: {name:'Open Edit Saved Finds',cat:'navigation'},
+  150: {name:'Perform Quick Find',cat:'foundsets'},
+  151: {name:'Open Manage Layouts',cat:'navigation'},
+  152: {name:'Save Records as Snapshot Link',cat:'records'},
+  154: {name:'Sort Records by Field',cat:'foundsets'},
+  155: {name:'Find Matching Records',cat:'foundsets'},
+  156: {name:'Open Manage Containers',cat:'navigation'},
+  157: {name:'Install Plug-In File',cat:'misc'},
+  158: {name:'Insert PDF',cat:'fields'},
+  159: {name:'Insert Audio/Video',cat:'fields'},
+  160: {name:'Insert from URL',cat:'fields'},
+  161: {name:'Insert from Device',cat:'fields'},
+  164: {name:'Perform Script on Server',cat:'control'},
+  165: {name:'Open Manage Themes',cat:'navigation'},
+  166: {name:'Show/Hide Menubar',cat:'windows'},
+  167: {name:'Refresh Object',cat:'misc'},
+  168: {name:'Set Layout Object Animation',cat:'control'},
+  169: {name:'Close Popover',cat:'navigation'},
+  172: {name:'Open Upload to Host',cat:'navigation'},
+  174: {name:'Enable Touch Keyboard',cat:'misc'},
+  175: {name:'Perform JavaScript in Web Viewer',cat:'misc'},
+  177: {name:'AVPlayer Play',cat:'misc'},
+  178: {name:'AVPlayer Set Playback State',cat:'misc'},
+  179: {name:'AVPlayer Set Options',cat:'misc'},
+  180: {name:'Refresh Portal',cat:'misc'},
+  181: {name:'Get Folder Path',cat:'misc'},
+  182: {name:'Truncate Table',cat:'records'},
+  183: {name:'Open Favorites',cat:'navigation'},
+  185: {name:'Configure Region Monitor Script',cat:'configure'},
+  186: {name:'MBS Plugin',cat:'plugin'},
+  187: {name:'Configure Local Notification',cat:'configure'},
+  188: {name:'Get File Exists',cat:'files'},
+  189: {name:'Get File Size',cat:'files'},
+  190: {name:'Create Data File',cat:'files'},
+  191: {name:'Open Data File',cat:'files'},
+  192: {name:'Write to Data File',cat:'files'},
+  193: {name:'Read from Data File',cat:'files'},
+  194: {name:'Get Data File Position',cat:'files'},
+  195: {name:'Set Data File Position',cat:'files'},
+  196: {name:'Close Data File',cat:'files'},
+  197: {name:'Delete File',cat:'files'},
+  199: {name:'Rename File',cat:'files'},
+  200: {name:'Set Error Logging',cat:'control'},
+  201: {name:'Configure NFC Reading',cat:'configure'},
+  202: {name:'Configure Machine Learning Model',cat:'ai'},
+  203: {name:'Execute FileMaker Data API',cat:'misc'},
+  205: {name:'Open Transaction',cat:'control'},
+  206: {name:'Commit Transaction',cat:'control'},
+  207: {name:'Revert Transaction',cat:'control'},
+  208: {name:'Set Session Identifier',cat:'misc'},
+  209: {name:'Set Dictionary',cat:'spelling'},
+  210: {name:'Perform Script on Server with Callback',cat:'control'},
+  211: {name:'Trigger Claris Connect Flow',cat:'control'},
+  212: {name:'Configure AI Account',cat:'ai'},
+  213: {name:'Fine-Tune Model',cat:'ai'},
+  214: {name:'Perform SQL Query by Natural Language',cat:'ai'},
+  215: {name:'Insert Embedding',cat:'ai'},
+  216: {name:'Insert Embedding in Found Set',cat:'ai'},
+  217: {name:'Set AI Call Logging',cat:'ai'},
+  218: {name:'Perform Semantic Find',cat:'ai'},
+  219: {name:'Perform RAG Action',cat:'ai'},
+  220: {name:'Generate Response from Model',cat:'ai'},
+  221: {name:'Perform Find by Natural Language',cat:'ai'},
+  222: {name:'Configure Regression Model',cat:'ai'},
+  223: {name:'Set Revert Transaction on Error',cat:'control'},
+  225: {name:'Save Records as JSONL',cat:'records'},
+  226: {name:'Configure Prompt Template',cat:'ai'},
+  227: {name:'Configure RAG Account',cat:'ai'},
+  228: {name:'Go to List of Records',cat:'navigation'},
+  237: {name:'Flush Web Viewer Cookies',cat:'misc'},
+  238: {name:'Configure Persistent Data',cat:'configure'},
+  240: {name:'Insert Image Captions in Found Set',cat:'ai'},
+  241: {name:'Insert Image Caption',cat:'ai'},
+  242: {name:'Print PDF',cat:'files'},
+  243: {name:'Create PDF',cat:'files'},
+  244: {name:'Append PDF',cat:'files'},
+  245: {name:'Close PDF',cat:'files'},
+  246: {name:'Open PDF',cat:'files'},
+  247: {name:'Cancel PDF',cat:'files'},
+};
\ No newline at end of file
diff --git a/docs/filemaker-xml-canonical/inspector/extractStepText.js b/docs/filemaker-xml-canonical/inspector/extractStepText.js
new file mode 100644
index 0000000..748315a
--- /dev/null
+++ b/docs/filemaker-xml-canonical/inspector/extractStepText.js
@@ -0,0 +1,200 @@
+// Extracted verbatim from clockwork-inspector.html.
+// Source: andykear/FileMaker-XML-inspector-open-source — Andrew Kear / Clockwork Creative Technology.
+// Licensed CC BY 4.0. See ../LICENSE.md.
+// extractStepText(step) — converts one <Step> XML element into a
+// human-readable line matching the FileMaker Script Workspace display
+// format as closely as possible without a full decompiler.
+// Covers the ~25 most common step types specifically; everything else
+// falls back to the step name from FM_STEP_IDS.
+
+// ── v2.0: FM26 DDR_INFO TEXT INDEX ───────────────────────────
+//
+// When the FM26 export is made with "Include details for analysis tools"
+// ticked (Has_DDR_INFO="True"), each catalog file carries a DDR_INFO
+// footer whose ObjectList holds pre-rendered display text — FileMaker's
+// own rendering of every script step and calculation — in elements named
+// after the owning object's UUID with a leading underscore:
+//
+//   <_F6D9DD73-... hash="..." datatype="StepText">Set Error Capture [On]</_...>
+//
+// Structural elements point at these via <DDRREF kind="StepText">_UUID</DDRREF>.
+// We index per-document (WeakMap) so the diff engine can hold two files
+// with the same step UUIDs but different rendered text without collision.
+window.__ddrTextByDoc = window.__ddrTextByDoc || new WeakMap();
+
+function buildDDRTextIndex(doc, root) {
+  const map = new Map();
+  const counts = { step_text: 0, calc_text: 0, other: 0 };
+  for (const ddr of root.querySelectorAll(':scope > DDR_INFO')) {
+    // Children are container elements (Script, Calculation, …) holding
+    // ObjectLists; entry tag names start with an underscore + UUID.
+    for (const entry of ddr.getElementsByTagName('*')) {
+      if (entry.tagName.charCodeAt(0) !== 95) continue; // '_'
+      const dt = entry.getAttribute('datatype') || '';
+      map.set(entry.tagName, entry.textContent || '');
+      if (dt === 'StepText') counts.step_text++;
+      else if (/Calc/i.test(dt)) counts.calc_text++;
+      else counts.other++;
+    }
+  }
+  window.__ddrTextByDoc.set(doc, map);
+  return { available: map.size > 0, entries: map.size, ...counts };
+}
+
+function extractStepText(step) {
+    // v2.0: prefer FileMaker's OWN rendering when the export carries
+    // DDR_INFO (FM26 "Include details for analysis tools"). The DDRREF
+    // child's text content is the underscore-prefixed UUID key into the
+    // per-document index built by buildDDRTextIndex. Falls through to
+    // the hand-built renderer when absent — pre-FM26 files, exports made
+    // without the option, or entries the index doesn't resolve.
+    const ddrMap = window.__ddrTextByDoc && window.__ddrTextByDoc.get(step.ownerDocument);
+    if (ddrMap && ddrMap.size) {
+        const ref = step.querySelector(':scope > DDRREF[kind="StepText"]');
+        if (ref) {
+            const key = (ref.textContent || '').trim();
+            const txt = ddrMap.get(key);
+            if (txt) {
+                const en = step.getAttribute('enable') !== 'False';
+                return (en ? '' : '// ') + txt;
+            }
+        }
+    }
+    const idStr  = step.getAttribute('id') || '';
+    const stepId = parseInt(idStr, 10);
+    const dict   = FM_STEP_IDS[stepId];
+    const name   = dict ? dict.name : (step.getAttribute('name') || ('Step ' + idStr));
+    const enabled = step.getAttribute('enable') !== 'False';
+    const prefix  = enabled ? '' : '// ';
+
+    // Helper: get first Calculation text content, trimmed and capped
+    function calc(sel) {
+        const el = step.querySelector(sel || 'Calculation');
+        if (!el) return '';
+        let t = (el.textContent || '').trim();
+        if (t.length > 120) t = t.slice(0, 117) + '\u2026';
+        return t;
+    }
+
+    // Helper: get attribute from a child element
+    function childAttr(sel, attrName) {
+        const el = step.querySelector(sel);
+        return el ? (el.getAttribute(attrName) || '') : '';
+    }
+
+    switch (stepId) {
+        // ── Control flow ─────────────────────────────────────
+        case 68:  { const c = calc(); return prefix + 'If [ ' + (c || '\u2026') + ' ]'; }
+        case 125: { const c = calc(); return prefix + 'Else If [ ' + (c || '\u2026') + ' ]'; }
+        case 69:  return prefix + 'Else';
+        case 70:  return prefix + 'End If';
+        case 71:  return prefix + 'Loop';
+        case 72:  { const c = calc(); return prefix + 'Exit Loop If [ ' + (c || '\u2026') + ' ]'; }
+        case 73:  return prefix + 'End Loop';
+        case 90:  return prefix + 'Halt Script';
+        case 91:  { const c = calc('Result > Calculation') || calc(); return prefix + 'Exit Script [ ' + c + ' ]'; }
+        case 62:  return prefix + 'Pause/Resume Script';
+
+        // ── Variables ────────────────────────────────────────
+        case 141: {
+            const varName = (step.querySelector('Name') || {}).textContent || '';
+            const val     = calc('Value > Calculation');
+            const rep     = calc('Repetition > Calculation');
+            let s = prefix + 'Set Variable [ ' + (varName.trim() || '?');
+            if (val)                                s += ' ; ' + val;
+            if (rep && rep !== '1' && rep !== '')  s += ' ; rep: ' + rep;
+            return s + ' ]';
+        }
+
+        // ── Fields ───────────────────────────────────────────
+        case 76: {
+            const fr  = step.querySelector('FieldReference');
+            const tor = fr ? fr.querySelector('TableOccurrenceReference') : null;
+            const fld = fr ? (fr.getAttribute('name') || '?') : '?';
+            const tbl = tor ? (tor.getAttribute('name') || '') : '';
+            const c   = calc();
+            return prefix + 'Set Field [ ' + (tbl ? tbl + '::' : '') + fld + ' ; ' + (c || '\u2026') + ' ]';
+        }
+        case 147: {
+            const c = calc();
+            return prefix + 'Set Field By Name [ ' + (c || '\u2026') + ' ]';
+        }
+
+        // ── Scripts ──────────────────────────────────────────
+        case 1:
+        case 164:
+        case 210: {
+            const sr     = step.querySelector('ScriptReference');
+            const target = sr ? (sr.getAttribute('name') || '?') : '?';
+            const param  = calc();
+            const label  = stepId === 1   ? 'Perform Script'
+                         : stepId === 164 ? 'Perform Script on Server'
+                         :                  'Perform Script on Server with Callback';
+            return prefix + label + ' [ ' + target + (param ? ' ; ' + param : '') + ' ]';
+        }
+
+        // ── Layouts ──────────────────────────────────────────
+        case 6: {
+            const lr    = step.querySelector('LayoutReference');
+            const lname = lr
+                ? (lr.getAttribute('name') || (lr.getAttribute('id') === '0' ? '(by calculation)' : '?'))
+                : '?';
+            return prefix + 'Go to Layout [ ' + lname + ' ]';
+        }
+        case 74: return prefix + 'Go to Related Records';
+
+        // ── Error / abort ────────────────────────────────────
+        case 86: {
+            const state = childAttr('Set', 'state');
+            return prefix + 'Set Error Capture [ ' + (state === 'True' ? 'On' : 'Off') + ' ]';
+        }
+        case 85: {
+            const state = childAttr('Set', 'state');
+            return prefix + 'Allow User Abort [ ' + (state === 'True' ? 'On' : 'Off') + ' ]';
+        }
+
+        // ── Records ──────────────────────────────────────────
+        case 7:  return prefix + 'New Record/Request';
+        case 8:  return prefix + 'Duplicate Record/Request';
+        case 9:  return prefix + 'Delete Record/Request';
+        case 75: {
+            const ni     = step.querySelector('NoInteract');
+            const dialog = ni ? (ni.getAttribute('state') === 'True' ? 'No dialog' : 'With dialog') : '';
+            return prefix + 'Commit Records/Requests' + (dialog ? ' [ ' + dialog + ' ]' : '');
+        }
+        case 28:  return prefix + 'Perform Find';
+        case 39:  return prefix + 'Sort Records';
+        case 182: return prefix + 'Truncate Table';
+
+        // ── Windows ──────────────────────────────────────────
+        case 122: return prefix + 'New Window';
+        case 121: return prefix + 'Close Window';
+        case 123: return prefix + 'Select Window';
+
+        // ── Data / network ───────────────────────────────────
+        case 160: {
+            const c = calc('URL > Calculation') || calc();
+            return prefix + 'Insert from URL [ ' + (c || '\u2026') + ' ]';
+        }
+        case 111: {
+            const c = calc('URL > Calculation') || calc();
+            return prefix + 'Open URL [ ' + (c || '\u2026') + ' ]';
+        }
+        case 87: return prefix + 'Show Custom Dialog';
+        case 63: return prefix + 'Send Mail';
+        case 35: return prefix + 'Import Records';
+        case 36: return prefix + 'Export Records';
+
+        // ── Comments / whitespace ────────────────────────────
+        case 89: {
+            const c = (step.textContent || '').trim().replace(/\s+/g, ' ');
+            return '# ' + (c.slice(0, 100) || '');
+        }
+
+        // ── Fallback: step name + any calc hint ───────────────
+        default: {
+            const anyCalc = calc();
+            return prefix + name + (anyCalc ? ' [ ' + anyCalc + ' ]' : '');
+        }
+    }
+}
diff --git a/docs/filemaker-xml-canonical/refresh-canonical.ps1 b/docs/filemaker-xml-canonical/refresh-canonical.ps1
new file mode 100644
index 0000000..250eaa7
--- /dev/null
+++ b/docs/filemaker-xml-canonical/refresh-canonical.ps1
@@ -0,0 +1,66 @@
+#!/usr/bin/env pwsh
+# Re-syncs the vendored FileMaker XML references from upstream and regenerates
+# step-catalog.json. Review the diff before committing — upstream version bumps
+# may add steps or change canonical shapes, which the audit tests will surface.
+#
+# Sources (both CC BY 4.0, Andrew Kear / Clockwork Creative Technology):
+#   - andykear/FileMaker-XMLsnippet-Claude-Skill   -> skill/
+#   - andykear/FileMaker-XML-inspector-open-source -> inspector/
+#
+# Extraction is content-marker based, not line-number based, so it survives
+# upstream edits.
+
+[CmdletBinding()]
+param(
+    [string]$SkillRepo     = 'https://github.com/andykear/FileMaker-XMLsnippet-Claude-Skill',
+    [string]$InspectorRepo = 'https://github.com/andykear/FileMaker-XML-inspector-open-source'
+)
+
+$ErrorActionPreference = 'Stop'
+$here = $PSScriptRoot
+$tmp  = Join-Path ([System.IO.Path]::GetTempPath()) ("fm-xml-refresh-" + [guid]::NewGuid().ToString('N'))
+New-Item -ItemType Directory -Force -Path $tmp | Out-Null
+
+try {
+    # ── Skill ────────────────────────────────────────────────────────────
+    $skillSrc = Join-Path $tmp 'skill'
+    git clone --depth 1 $SkillRepo $skillSrc
+    $skillDest = Join-Path $here 'skill'
+    New-Item -ItemType Directory -Force -Path (Join-Path $skillDest 'references') | Out-Null
+    Copy-Item (Join-Path $skillSrc 'SKILL.md')  (Join-Path $skillDest 'SKILL.md') -Force
+    Copy-Item (Join-Path $skillSrc 'README.md') (Join-Path $skillDest 'README.upstream.md') -Force
+    Copy-Item (Join-Path $skillSrc 'references/*.md') (Join-Path $skillDest 'references') -Force
+
+    # ── Inspector ────────────────────────────────────────────────────────
+    $insSrc = Join-Path $tmp 'inspector'
+    git clone --depth 1 $InspectorRepo $insSrc
+    # Normalize CRLF -> LF so the content-marker regexes below match reliably.
+    $html = (Get-Content (Join-Path $insSrc 'clockwork-inspector.html') -Raw) -replace "`r`n", "`n"
+    $insDest = Join-Path $here 'inspector'
+    New-Item -ItemType Directory -Force -Path $insDest | Out-Null
+
+    $header = @'
+// Extracted verbatim from clockwork-inspector.html.
+// Source: andykear/FileMaker-XML-inspector-open-source — Andrew Kear / Clockwork Creative Technology.
+// Licensed CC BY 4.0. See ../LICENSE.md.
+
+'@
+
+    # FM_STEP_IDS: from 'const FM_STEP_IDS = {' to the matching '};'
+    $catMatch = [regex]::Match($html, '(?s)const FM_STEP_IDS = \{.*?\n\};')
+    if (-not $catMatch.Success) { throw 'FM_STEP_IDS block not found in inspector HTML.' }
+    Set-Content (Join-Path $insDest 'FM_STEP_IDS.js') ($header + $catMatch.Value) -NoNewline
+
+    # extractStepText: the DDR comment block through the end of the function
+    # (closing brace at column 0).
+    $fnMatch = [regex]::Match($html, '(?s)// extractStepText\(step\).*?\nfunction extractStepText\(step\) \{.*?\n\}\n')
+    if (-not $fnMatch.Success) { throw 'extractStepText function not found in inspector HTML.' }
+    Set-Content (Join-Path $insDest 'extractStepText.js') ($header + $fnMatch.Value) -NoNewline
+
+    $catEntries = [regex]::Matches($catMatch.Value, "(?m)^\s*(\d+):\s*\{name:'").Count
+    Write-Host "Vendored FM_STEP_IDS.js ($catEntries entries) and extractStepText.js."
+    Write-Host 'Done. Review the diff before committing.'
+}
+finally {
+    Remove-Item -Recurse -Force $tmp -ErrorAction SilentlyContinue
+}
diff --git a/docs/filemaker-xml-canonical/skill/README.upstream.md b/docs/filemaker-xml-canonical/skill/README.upstream.md
new file mode 100644
index 0000000..729d583
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/README.upstream.md
@@ -0,0 +1,150 @@
+# FileMaker Script XML Specification
+
+[![Stars](https://img.shields.io/github/stars/andykear/FileMaker-XMLsnippet-Claude-Skill?style=social)](https://github.com/andykear/FileMaker-XMLsnippet-Claude-Skill)
+[![License](https://img.shields.io/badge/license-CC%20BY%204.0-green)](https://creativecommons.org/licenses/by/4.0/)
+
+Reverse-engineered specification of FileMaker's undocumented `fmxmlsnippet` clipboard format. Every step ID, element ordering rule, and silent failure mode, established through empirical round-trip testing against production FileMaker solutions.
+
+Developed by Andrew Kear of [Clockwork Creative Technology](https://www.clockworkct.co.uk) and shared openly with the FileMaker/Claris community.
+
+---
+
+## Why this exists
+
+FileMaker's Script Workspace accepts pasted scripts in a specific XML format. Claris has never published a specification for it. Get the XML wrong and FileMaker accepts it silently, dropping data without any error message.
+
+This specification documents what the paste handler actually accepts: 220 step IDs, canonical XML skeletons for every step, the element ordering constraints that cause silent drops when violated, and the calculation slot binding rules that cause multi-slot steps to misbind.
+
+---
+
+## What it catches
+
+The specification documents several classes of silent failure that are invisible in the Script Workspace after paste:
+
+**Set Variable name drop.** If the variable name element is emitted as a single-letter tag instead of the canonical four-letter `Name` form, FileMaker pastes the step with no variable name. No error. No warning. You find out when the script runs.
+
+**Calculation slot misbinding.** Install OnTimer Script, Perform JavaScript in Web Viewer, and other steps with multiple calculation slots silently bind a calculation to the wrong internal slot when elements are in the wrong order. The script appears to work. The calculation runs in the wrong context.
+
+**Element ordering.** Several steps require child elements in a specific order. The XML is valid either way. Only one order produces the correct paste result.
+
+These are not edge cases. They are the default failure mode when any tool, human or AI, generates FileMaker script XML without knowing the paste handler rules.
+
+---
+
+## Packaged as a Claude Skill
+
+The specification is packaged as a [Claude](https://claude.ai) skill with progressive loading: the model reads core rules plus only the step categories each task needs. This keeps token usage proportional to task complexity.
+
+Once installed, Claude uses the specification automatically when generating or reviewing FileMaker script XML. The structural rules are handled deterministically. The model handles the logic.
+
+**Tested with Claude. Model agnostic by design.** The deterministic approach means any capable model with the specification in context should produce reliable output. Claude is the only model Clockwork has tested against; others have reported success.
+
+## Beyond Claude
+
+The specification is packaged here as a Claude skill, but the format rules are model-agnostic. The reference files are plain markdown, readable by any LLM or human. If you're building tools that generate FileMaker script XML, the spec is yours to integrate.
+
+---
+
+## FM 26 support (v1.12)
+
+v1.12 adds full FileMaker Pro 2026 support with 10 new steps and updates to existing steps, all round-trip verified:
+
+**New steps:** PDF Files category (Create PDF, Open PDF, Append PDF, Print PDF, Close PDF, Cancel PDF), Configure Persistent Data, Insert Image Caption, Insert Image Captions in Found Set, Flush Web Viewer Cache.
+
+**Updated steps:** Save Records as PDF (three PDFSaveType modes, source and appearance enumerations), Show Custom Dialog (size and position calculations), Configure AI Account (all five provider variants: OpenAI, Anthropic, Google, xAI, Groq).
+
+**New in FM 26:** DisableStepCollapsed universal element documented. Error codes 605-608 and 829-833. 16 Open menu steps added to the routing index.
+
+---
+
+## What's in the box
+
+```
+SKILL.md                            — Claude skill definition + routing index
+references/
+  core.md                           — Paste rules, conventions, Set Variable,
+                                      silent failures, appendices (§1-7, A, B, C)
+  steps-control.md                  — §8.1 Control
+  steps-navigation-editing.md       — §8.3-8.4
+  steps-fields-records.md           — §8.5-8.7
+  steps-windows-files.md            — §8.8-8.9
+  steps-accounts-ai-misc.md         — §8.2, §8.10-8.14
+  steps-pdf.md                      — §8.15 PDF Files (FM 26)
+  steps-plugin.md                   — §9 Plugin steps (MBS)
+  custom-functions.md               — §11 Custom Functions
+  worked-example.md                 — §10 Worked example (optional)
+```
+
+---
+
+## Installation
+
+1. Download the zip from the [Releases](../../releases) page
+2. Extract to get `SKILL.md` and the `references/` folder
+3. Upload to your Claude organisation's skills library, preserving the folder structure
+
+Upgrading from v1.11: replace all files. The `references/steps-pdf.md` file is new; all other files are updated in place.
+
+Upgrading from v1.10.x: remove the old single `references/filemaker_xml_rules.md` and replace with the current file set.
+
+---
+
+## Usage
+
+Once installed, Claude applies the specification automatically when you ask for FileMaker scripts or fmxmlsnippet XML. No special prompt needed.
+
+**Generate a script:**
+> "Write a FileMaker script that loops through the found set and sets a flag field"
+
+**Review existing XML:**
+> Paste your fmxmlsnippet and ask Claude to review it for paste handler errors
+
+**With schema context:**
+> Attach your DDR and Claude will use real field, layout, and script names from your solution. You can also attach a DDR exported using [Clockwork Inspector](https://github.com/andykear/FileMaker-XML-inspector-open-source).
+
+---
+
+## Pasting into FileMaker
+
+The Script Workspace accepts `fmxmlsnippet type="FMObjectList"` via clipboard paste in FileMaker's internal clipboard format, not plain text. This skill has been tested with the **MBS Plugin** in FileMaker 2024 and 2025. Paste handlers in FileMaker Pro 2026 remain compatible.
+
+---
+
+## Companion repos
+
+Five open-source resources for the FileMaker/Claris community:
+
+[FileMaker Script XML Skill](https://github.com/andykear/FileMaker-XMLsnippet-Claude-Skill) — script steps for the Script Workspace
+
+[FileMaker Layout XML Skill](https://github.com/andykear/FileMaker-XMLsnippet-Layout-Claude-Skill) — layout objects for Layout mode
+
+[FileMaker Field Definitions XML Skill](https://github.com/andykear/FileMaker-XML-field-definitions) — field definitions for Manage Database
+
+[FileMaker XML Inspector](https://github.com/andykear/FileMaker-XML-inspector-open-source) — browser-based Save as XML analyser
+
+[FileMaker XML Scrubber](https://github.com/andykear/FileMaker-XML-scrubber) — redacts credentials before sharing with AI tools
+
+---
+
+## Licence
+
+[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) — free to use, share, and adapt with attribution.
+
+---
+
+## Contributing
+
+Found a step that doesn't round-trip? Native export that contradicts the spec? Open an issue or PR. The specification improves through community round-trip testing. That's how it was built.
+
+---
+
+## Version history
+
+| Version | Notes |
+|---------|-------|
+| 1.12 | FM 26 (FileMaker Pro 2026) support. 10 new steps: PDF Files category (Create PDF, Open PDF, Append PDF, Print PDF, Close PDF, Cancel PDF), Configure Persistent Data, Insert Image Caption, Insert Image Captions in Found Set, Flush Web Viewer Cache. Updated steps: Save Records as PDF, Show Custom Dialog, Configure AI Account. New elements: DisableStepCollapsed. Error codes 605-608, 829-833. 16 new Open menu steps. |
+| 1.11 | Progressive loading restructure: spec split into core rules plus on-demand step category files with a routing index. Simple tasks load around 55% fewer reference tokens than v1.10, typical tasks 30-35% fewer. All steps remain fully documented. |
+| 1.10.4 | Added support for custom functions. Fixes an installation path issue affecting all previous versions. |
+| 1.10.3 | Removed changelog, validation suite, and step index appendices to reduce token load. Public release. |
+| 1.10.2 | Removed pre-release version history narrative. |
+| 1.10 | First complete version. All AI steps (212-228) added. Placeholder-ID pattern documented. |
diff --git a/docs/filemaker-xml-canonical/skill/SKILL.md b/docs/filemaker-xml-canonical/skill/SKILL.md
new file mode 100644
index 0000000..a27527b
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/SKILL.md
@@ -0,0 +1,140 @@
+---
+name: filemaker-xml
+description: >
+  Use this skill whenever the user wants to work with FileMaker script XML or custom function XML.
+  This includes: generating FileMaker XML from a description, pseudocode, or
+  script steps; analysing or reviewing existing FileMaker XML for errors or
+  silent-failure risks; converting scripts between formats; or any task where
+  the output must be paste-ready XML for the FileMaker Script Workspace or Manage Custom Functions dialog.
+  Trigger any time the user mentions FileMaker scripts, fmxmlsnippet, Set
+  Variable XML, script step XML, custom function XML, or asks to produce XML that can be pasted
+  into FileMaker. Always use this skill — do not attempt FileMaker XML tasks
+  from memory alone, as the format has undocumented paste-handler rules that
+  cause silent failures without this reference.
+---
+
+# FileMaker Script & Custom Function XML Skill
+
+## Overview
+
+This skill enables Claude to correctly **analyse** and **generate** FileMaker
+Script Workspace XML — the `fmxmlsnippet type="FMObjectList"` format that
+FileMaker accepts via clipboard paste.
+
+The format has a lenient XML parser but a strict paste handler. Structural
+deviations that look fine as XML can cause steps to paste with silently missing
+data (e.g. Set Variable pastes with no variable name). The reference files in
+this skill are the authoritative reverse-engineered spec for what the paste
+handler actually accepts.
+
+---
+
+## Mandatory reading — progressive loading
+
+The specification (v1.12) is split so a task loads only the sections it
+needs. The rules are:
+
+1. **Always read `references/core.md` first.** Not optional. It contains
+   the paste format requirements, common conventions, the Set Variable
+   canonical structure, and the silent-failure modes that apply to every
+   step. Skipping it reintroduces the from-memory failure mode this
+   skill exists to prevent.
+2. **Always read `references/steps-control.md`.** Control steps (If,
+   Loop, Perform Script, Exit Script, Comment, transactions) appear in
+   virtually every script.
+3. **Then read only the step category files containing the steps the
+   task needs**, using the routing index below. When reviewing XML someone else
+   produced, route by the `name` attributes on the `<Step>` elements
+   in the snippet.
+4. Custom function tasks: read `references/custom-functions.md`
+   (plus core.md — the wrapper differs but the conventions apply).
+5. MBS or other plugin steps: read `references/steps-plugin.md`.
+6. `references/worked-example.md` is optional background, not required
+   for any task.
+
+When reviewing XML someone else produced, route by the step `id`
+attributes present in the snippet.
+
+Do not rely on training data for FileMaker XML structure — always consult
+the reference files. The format contains non-obvious quirks (e.g. a
+trailing space in the `Configure RAG Account ` step name) that only
+appear in the spec.
+
+---
+
+## Routing index
+
+Set Variable (141) is documented in `core.md` §3 (its canonical
+structure is a silent-failure trap, so it lives with the core rules).
+
+**`steps-control.md`** — Allow User Abort, Comment, Commit Transaction, Else, Else If, End If, End Loop, Exit Loop If, Exit Script, Halt Script, If, Install OnTimer Script, Loop, Open Transaction, Pause/Resume Script, Perform Script, Perform Script on Server, Perform Script on Server with Callback, Revert Transaction, Set Error Capture, Set Error Logging, Set Layout Object Animation, Set Revert Transaction on Error, Set Variable, Trigger Claris Connect Flow
+
+**`steps-navigation-editing.md`** — Clear, Close Popover, Copy, Cut, Enter Browse Mode, Enter Find Mode, Enter Preview Mode, Go to Field, Go to Layout, Go to List of Records, Go to Next Field, Go to Object, Go to Portal Row, Go to Previous Field, Go to Record/Request/Page, Go to Related Record, Paste, Perform Find/Replace, Select All, Set Selection, Undo/Redo
+
+**`steps-fields-records.md`** — Commit Records/Requests, Constrain Found Set, Copy All Records/Requests, Copy Record/Request, Delete All Records, Delete Portal Row, Delete Record/Request, Duplicate Record/Request, Export Field Contents, Export Records, Extend Found Set, Find Matching Records, Import Records, Insert Audio/Video, Insert Calculated Result, Insert Current Date, Insert Current Time, Insert Current User Name, Insert File, Insert from Device, Insert from Index, Insert from Last Visited, Insert from URL, Insert PDF, Insert Picture, Insert Text, Modify Last Find, New Record/Request, Omit Multiple Records, Omit Record, Open Record/Request, Perform Find, Perform Quick Find, Relookup Field Contents, Replace Field Contents, Revert Record/Request, Save Records as Excel, Save Records as JSONL, Save Records as PDF, Save Records as Snapshot Link, Set Field, Set Field By Name, Set Next Serial Value, Show All Records, Show Omitted Only, Sort Records, Sort Records by Field, Truncate Table, Unsort Records
+
+**`steps-windows-files.md`** — Adjust Window, Arrange All Windows, Close Data File, Close File, Close Window, Convert File, Create Data File, Delete File, Freeze Window, Get Data File Position, Get File Exists, Get File Size, Move/Resize Window, New File, New Window, Open Data File, Open File, Print, Print Setup, Read from Data File, Recover File, Refresh Window, Rename File, Save a Copy as, Save a Copy as XML, Scroll Window, Select Window, Set Data File Position, Set Multi-User, Set Use System Formats, Set Window Title, Set Zoom Level, Show/Hide Menubar, Show/Hide Text Ruler, Show/Hide Toolbars, View As, Write to Data File
+
+**`steps-accounts-ai-misc.md`** — Add Account, Allow Formatting Bar, AVPlayer Play, AVPlayer Set Options, AVPlayer Set Playback State, Beep, Change Password, Check Found Set, Check Record, Check Selection, Configure AI Account, Configure Local Notification, Configure Machine Learning Model, Configure NFC Reading, Configure Persistent Data, Configure Prompt Template, Configure RAG Account, Configure Region Monitor Script, Configure Regression Model, Correct Word, Delete Account, Dial Phone, Edit User Dictionary, Enable Account, Enable Touch Keyboard, Execute FileMaker Data API, Execute SQL, Exit Application, Fine-Tune Model, Flush Cache to Disk, Flush Web Viewer Cookies, Generate Response from Model, Get Folder Path, Insert Embedding, Insert Embedding in Found Set, Insert Image Caption, Insert Image Captions in Found Set, Install Menu Set, Install Plug-In File, Open URL, Perform AppleScript, Perform Find by Natural Language, Perform JavaScript in Web Viewer, Perform RAG Action, Perform Semantic Find, Perform SQL Query by Natural Language, Re-Login, Refresh Object, Refresh Portal, Reset Account Password, Save a Copy as Add-on Package, Select Dictionaries, Send DDE Execute, Send Event, Send Mail, Set AI Call Logging, Set Dictionary, Set Session Identifier, Set Web Viewer, Show Custom Dialog, Speak, Spelling Options
+
+**`steps-pdf.md`** — Append PDF, Cancel PDF, Close PDF, Create PDF, Open PDF, Print PDF
+
+**`steps-plugin.md`** — all MBS and other plugin steps (External step structure, §9)
+
+**`custom-functions.md`** — custom function definitions (§11): skeleton, attributes, parameters, recursion
+
+---
+
+## Task: Analysing existing XML
+
+When the user provides FileMaker XML to review:
+
+1. Read `core.md`, then the category files for the step ids present.
+2. Check against the silent-failure modes (core.md §7):
+   - **7.1** — `Name` element emitted as single-letter tag (Set Variable loses variable name)
+   - **7.2** — compact/single-line form instead of expanded child form
+   - **7.3** — wrong element order within a `<Step>`
+3. Check wrapper: must be `<?xml version="1.0" encoding="UTF-8"?>` + `<fmxmlsnippet type="FMObjectList">`.
+4. Check indentation: two spaces, no tabs.
+5. Check CDATA: all calculation content must be in `<Calculation><![CDATA[...]]></Calculation>`.
+6. For each step, verify the canonical skeleton matches the spec for that step ID/name.
+7. Report issues clearly, quoting the offending XML fragment and explaining the paste-time consequence.
+8. Offer a corrected version.
+
+---
+
+## Task: Generating XML
+
+When the user wants to generate FileMaker XML from a description or pseudocode:
+
+1. Read `core.md` and `steps-control.md`, then the category files for
+   the steps the task needs (routing index above).
+2. Look up each step's canonical skeleton in its category file.
+3. Apply the core.md §1 paste format requirements throughout:
+   - Wrap in `<?xml version="1.0" encoding="UTF-8"?>\n<fmxmlsnippet type="FMObjectList">...\n</fmxmlsnippet>`
+   - Two-space indent, no tabs
+   - CDATA for all calculations
+   - Expanded (not compact) child forms
+   - Correct element order per spec
+4. For schema references (table names, field names, layout names, script names):
+   - If the user has provided a DDR or explicit IDs, use those.
+   - Otherwise use the **placeholder-ID pattern**: `id="1"` everywhere, with `name` attributes matching the user's names. FileMaker will resolve real IDs on paste. (core.md §5)
+5. Emit the variable-name element for Set Variable and any other step that requires it using the correct four-letter form `Name` (capital N, lowercase a-m-e) as documented in core.md §3 and §5. Be aware of the rendering trap described in §7.4 — the tag must be the full word, not a single letter.
+6. Use ASCII comparison operators (`<>`, `<=`, `>=`) rather than Unicode equivalents — safer for transport (core.md §5).
+7. Output the complete XML inside a code block with `xml` syntax highlighting.
+8. After the XML, briefly note any assumptions made (e.g. placeholder IDs used, repetition defaulted to 1).
+
+---
+
+## Key conventions (quick reference — always verify against core.md)
+
+| Convention | Rule |
+|---|---|
+| Wrapper | `fmxmlsnippet type="FMObjectList"` |
+| Indent | 2 spaces, never tabs |
+| Calculations | `<Calculation><![CDATA[expr]]></Calculation>` |
+| Variable name tag | four-letter `Name` element, capital N (core.md §3) |
+| Schema IDs without DDR | `id="1"` + matching `name` attribute (placeholder-ID pattern) |
+| Comparison operators | ASCII: `<>` not `≠`, `<=` not `≤`, `>=` not `≥` |
+| Disabled steps | `enable="False"` on the `<Step>` element |
+| Comment divider (blank) | Self-closing `<Step enable="True" id="89" name="Comment"/>` |
diff --git a/docs/filemaker-xml-canonical/skill/references/core.md b/docs/filemaker-xml-canonical/skill/references/core.md
new file mode 100644
index 0000000..1e5af1c
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/references/core.md
@@ -0,0 +1,607 @@
+# Canonical XML Format for FileMaker Script Steps
+
+Part of the FileMaker Script XML Skill, v1.12.
+Verified against FileMaker Pro 2026 on macOS.
+
+**Author:** Andrew Kear, Clockwork Creative Technology
+**Version:** 1.11
+**Date:** June 2026
+**Verified against:** FileMaker Pro 2025 on macOS
+**Licence:** [Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/)
+— free to use, share, and adapt with attribution.
+
+---
+
+## Why this exists
+
+FileMaker's Script Workspace pastes scripts from the clipboard in an
+undocumented XML format. The XML parser is lenient but the paste
+handler is not: structurally valid XML can paste with elements
+silently dropped or rebound to the wrong slot (the classic case is a
+Set Variable step pasting with no variable name). This specification
+is a reverse-engineered reference for what the paste handler actually
+accepts, built entirely by round-trip testing: generate, paste, save,
+copy back out, diff against native output. Where FileMaker's native
+emission contains quirks (typos, trailing spaces, cryptic numeric
+attributes), they are preserved exactly, because deviation from the
+native form is precisely what triggers the silent failures.
+
+## How this specification is organised
+
+From v1.11 the specification is split for progressive loading: this
+file holds the rules that apply to every task, and step skeletons live
+in category files read on demand. The routing index in SKILL.md maps
+every step to its file. Section numbers are unchanged from earlier
+versions, so cross references such as "see Section 8.5" mean the file
+holding that section.
+
+Step skeletons in the category files show FileMaker's native minimal
+output; configured variants appear inline and all have been verified
+by round-trip testing. Every generated snippet must be wrapped in the
+XML declaration and `fmxmlsnippet` element specified in Section 1.
+
+---
+
+## Scope
+
+**This document covers:** the structural XML format that
+`fmxmlsnippet type="FMObjectList"` clipboards must follow to paste
+cleanly into the FileMaker Script Workspace. It documents
+canonical skeletons for every script step (~180), verified
+configured forms for the steps most commonly used in real
+automation, and three known silent-failure modes.
+
+**This document does not cover:** layout objects, theme XML,
+FileMaker's full DDR (Database Design Report) format, runtime
+behaviour of any step, or what an LLM should *do* with this
+information beyond following it as a structural specification.
+
+**Verified environment:** FileMaker Pro 2025 on macOS. The same
+format is expected to work in FileMaker 19 onward and on Windows,
+but cross-version and cross-platform testing has not been performed.
+Reports of differences are welcome.
+
+---
+## 1. Paste format requirements
+
+Output must match FileMaker's native Copy format exactly. The following
+requirements are non-negotiable.
+
+1. **Wrapper.** Wrap all output in an XML declaration followed by
+   `<fmxmlsnippet type="FMObjectList">`.
+
+   ```
+   <?xml version="1.0" encoding="UTF-8"?>
+   <fmxmlsnippet type="FMObjectList">
+     ...steps...
+   </fmxmlsnippet>
+   ```
+
+2. **Indentation.** Two-space indent throughout. Never tabs.
+
+3. **Element order.** Child elements within each `<Step>` must appear
+   in the order FileMaker emits them. Reordering is not safe.
+
+4. **Calculations.** All calculation content is wrapped in CDATA
+   inside a `<Calculation>` element:
+   `<Calculation><![CDATA[expression]]></Calculation>`.
+
+5. **Tag names.** Emit canonical tag names in full. Do not abbreviate
+   or collapse.
+
+6. **Expanded forms.** Elements with child `<Calculation>` nodes
+   (`<Value>`, `<Repetition>`, `<Name>`, `<Message>`, `<Height>`,
+   `<Width>`, etc.) must appear in expanded form, with the child
+   `<Calculation>` on its own indented line. Compact single-line forms
+   are not safe.
+
+## 2. Why exact matching matters
+
+The FileMaker XML parser is lenient: any well-formed XML parses. The
+Script Workspace paste handler, however, is whitespace- and
+format-sensitive for several step types. When output drifts from
+FileMaker's native format, individual child elements can be silently
+dropped during paste — the step pastes without error, but with missing
+data.
+
+Set Variable is the most sensitive case. Non-native formatting causes
+the `<Name>` element to be dropped, producing a Set Variable step with
+no variable name assigned. Round-trip testing confirms that matching
+FileMaker's native indentation and expanded child form preserves the
+`<Name>` element reliably; deviations do not.
+
+Generators must therefore emit FileMaker's exact native format rather
+than any compact or normalised equivalent.
+
+## 3. Set Variable: canonical structure
+
+> **Rendering-trap warning (read first).** The variable-name element
+> in Set Variable is the literal four-letter tag spelled `N-a-m-e` —
+> capital N followed by lowercase a, m, e — written in source as
+> `<Name>...</Name>`. The four ASCII bytes are `0x4E 0x61 0x6D 0x65`.
+>
+> If your rendering of this document collapses the tag to a single
+> letter (so that the canonical form below appears as `<n>...</n>`
+> rather than `<Name>...</Name>`), your rendering layer is
+> stripping inner content from anything resembling an HTML element
+> with this spelling. Trust the byte-level form from a plaintext
+> source, not the rendered display. Emitting the single-letter form
+> is the silent-failure trigger described in Section 7.1 — every Set
+> Variable step pastes with no variable name. See Section 7.4 for the
+> full mechanics of this rendering-corruption failure mode.
+
+```
+  <Step enable="True" id="141" name="Set Variable">
+    <Value>
+      <Calculation><![CDATA[expression]]></Calculation>
+    </Value>
+    <Repetition>
+      <Calculation><![CDATA[1]]></Calculation>
+    </Repetition>
+    <Name>$variable_name</Name>
+  </Step>
+```
+
+Requirements:
+
+- Two-space indent from `<Step>` downward. No tabs.
+- `<Value>` and `<Repetition>` each on their own line, with the child
+  `<Calculation>` indented beneath on a new line, and each closing tag
+  on its own line.
+- `<Name>` is the last child, one indent level deeper than `<Step>`.
+- The variable-name element is the literal four-letter tag `<Name>` (capital N, lowercase a-m-e; bytes `0x4E 0x61 0x6D 0x65`). Never the single letter `<n>`, never an intuited expansion like `<VariableName>`. See the rendering-trap warning above.
+- CDATA content may be single- or multi-line. Once the container
+  structure is correct, calculation content does not affect paste.
+
+## 4. Disabled steps
+
+Any step may be disabled by setting `enable="False"` on the `<Step>`
+tag. Structure is otherwise identical — all child elements are
+preserved. The Script Workspace displays disabled steps with a `//`
+prefix.
+
+```
+  <Step enable="False" id="21" name="Unsort Records"/>
+  <Step enable="False" id="76" name="Set Field">
+    <Calculation><![CDATA["anything"]]></Calculation>
+    <Field table="tbl" id="N" name="fld"/>
+  </Step>
+```
+
+Flow-control steps (`If`, `Else If`, `Else`, `End If`, `Loop`,
+`End Loop`) accept `enable="False"` on the same terms. FileMaker does
+not "repair" disabled control structures or enforce pairing — a
+disabled `If` and disabled `End If` wrapping enabled body steps round-
+trips intact, and the body steps execute unconditionally because the
+disabled `If` is dropped from execution flow. This is the canonical
+way to preserve commented-out conditional wrappers from earlier
+revisions.
+
+```
+  <Step enable="False" id="68" name="If">
+    <Restore state="False"/>
+    <Calculation><![CDATA[some_disabled_condition]]></Calculation>
+  </Step>
+  <Step enable="True" id="76" name="Set Field">
+    ...
+  </Step>
+  <Step enable="False" id="70" name="End If"/>
+```
+
+Round-trip verified: paste, save, reopen — the disabled flow-control
+markers persist exactly as emitted, and the body steps run as if
+unwrapped.
+
+## 5. Common child-element conventions
+
+The following patterns recur across many step types:
+
+- `<NoInteract state="True"/>` — equivalent to "With dialog: Off" in
+  the UI for record operations, finds, exports, etc.
+- `<Option state="False"/>` — equivalent to "With dialog: Off" for
+  steps where `<NoInteract>` does not apply.
+- `<Restore state="True|False"/>` — indicates whether saved settings
+  are restored (find requests, GTRR options, sort orders, print
+  settings, import/export formats).
+- `<SelectAll state="True|False"/>` — in insert and paste steps,
+  controls whether the entire field is replaced (`True`) or content
+  is inserted at the cursor (`False`).
+- `<UniversalPathList type="Embedded"/>` — file-path container used by
+  Insert File, Insert PDF, Insert Picture, Insert Audio/Video, and
+  Fine-Tune Model. When paths are set, populated variants hold a list
+  of paths.
+- `<LayoutDestination value="OriginalLayout|CurrentLayout|SelectedLayout"/>` —
+  target layout selector for steps that reference a layout.
+- The four-letter `<Name>` tag (bytes `0x4E 0x61 0x6D 0x65`,
+  capital N + lowercase a-m-e) is the canonical wrapper for any
+  user-supplied identifier — variable names (Set Variable, Section 3),
+  new-window names (Go to Related Record, Section 8.3; New Window,
+  Section 8.8), close-by-name targets (Close Window, Section 8.8). The
+  same tag spelling, the same nesting (CDATA `<Calculation>` for
+  contexts that accept an expression; plain text for Set Variable's
+  variable-name body). Never the single-letter form `<n>` — that is
+  the silent-drop trigger documented in Section 7.4.
+- Enumerated values appear as `<Element value="X"/>`.
+- Boolean states appear as `<Element state="True|False"/>`.
+
+### XML escaping in plain-text content
+
+Most calculation content is wrapped in CDATA, where XML special
+characters need no escaping. Find-mode `<Text>` elements and other
+plain-text element bodies (notably `<Text>` inside comments and find
+criteria) are *not* CDATA, so XML escaping is required:
+
+- `>` becomes `&gt;`
+- `<` becomes `&lt;`
+- `&` becomes `&amp;`
+
+For example, a find criterion of `>=$earliest_date` is encoded as
+`<Text>&gt;=$earliest_date</Text>` inside the `<Criteria>` element.
+
+### Comparison operator forms in calculations
+
+FileMaker accepts both ASCII (`<>`, `<=`, `>=`) and Unicode (`≠`,
+`≤`, `≥`) forms of the comparison operators inside CDATA calculation
+content. Native Copy emits the Unicode glyphs; the paste handler
+accepts either form, and the file does not canonicalise on save —
+ASCII forms round-trip unchanged.
+
+The two forms are interchangeable for paste correctness, but they are
+not equivalent for transport:
+
+- The Unicode glyphs are multi-byte under UTF-8 (`≠` is `0xE2 0x89
+  0xA0`). Pipelines that touch the XML between generation and paste —
+  shell `tr`/`sed` invoked with the wrong locale, log truncation,
+  LLM tokenisers that split on byte boundaries, copy-paste through
+  legacy clipboards — can corrupt or strip them silently.
+- The ASCII forms are single-byte and survive any such pipeline
+  intact.
+
+Generators that emit XML for downstream consumption (LLM output, build
+artefacts, transmitted snippets) should prefer the ASCII forms even
+though FM's own Copy emits Unicode. Generators that read FM-emitted
+XML and pass it through unchanged should preserve whatever form they
+received.
+
+### Field references vs. variable targets
+
+Steps that write to a destination (Set Field, Insert from URL, Insert
+Calculated Result, Insert Text, etc.) emit different `<Field>` forms
+depending on the target type:
+
+- **Field target** uses the structured form:
+  `<Field table="TableOccurrence" id="N" name="field_name"/>`
+- **Variable target** uses a plain-text body:
+  `<Field>$variable_name</Field>`
+
+The element name is the same (`<Field>`), only the contents differ.
+This appears across any step where the target can be either a field
+or a script variable.
+
+### Runtime dependencies not enforced by the XML format
+
+Pasted XML pastes if its structure is valid; the resulting script
+will *run* correctly only if the recipient file contains every
+referenced object. The format does not validate these references at
+paste time, and several categories of reference fail silently or
+opaquely at runtime rather than at paste. Generators should treat
+these as a pre-flight checklist when producing XML for an unknown
+target file.
+
+- **Schema references by ID and name.** `<Field>`, `<Table>`,
+  `<Layout>`, `<Script>`, `<CustomMenuSet>`, and similar elements
+  carry both an `id` attribute and a `name` attribute. FileMaker
+  resolves these by ID first, falling back to name when the ID has no
+  match. A pasted reference whose ID does not exist in the recipient
+  file produces a "missing reference" indicator on the step but does
+  not prevent paste.
+
+  In practice, name-fallback is reliable enough to be a primary
+  generation strategy, not a degraded path. Round-trip testing
+  confirms that XML emitted with placeholder `id="1"` on every schema
+  reference pastes cleanly when the names match objects in the
+  recipient file: FileMaker resolves each reference by name on paste,
+  populates the real ID on save, and re-emits the resolved form on the
+  next Copy. No missing-reference warnings, no manual repair.
+
+  This is the **placeholder-ID pattern**: generators without DDR
+  access (LLM script writers, code-generation utilities operating
+  against an unknown recipient file, migration tools moving scripts
+  between similar files) can emit `id="1"` (or any non-zero placeholder)
+  uniformly and rely on name resolution. The only requirements are:
+  every name attribute must exactly match the corresponding object's
+  name in the recipient file (case-sensitive, whitespace-sensitive,
+  trailing-space-sensitive), and the recipient must contain the named
+  object. Generators that *do* have DDR access should still emit real
+  IDs to skip the resolution step entirely; generators that do not
+  should not block on it.
+
+- **Custom functions in calculations.** Custom function calls inside
+  CDATA calculation content (for example, `MyHelper ( $x )`) appear
+  as plain text indistinguishable from built-in function calls. The
+  XML carries no custom-function signature or dependency declaration.
+  If the recipient file lacks the named custom function, the step
+  pastes silently and produces an evaluation error at runtime. This
+  is the most opaque failure mode in the format.
+
+- **Plugin availability.** Plugin steps (the MBS step at id 186 and
+  equivalent steps from other plugins) require the plugin to be
+  installed and enabled on the machine running the script. The `index`
+  attribute on plugin steps is also file-specific (see the MBS entry
+  in Section 9 for details).
+
+- **Host-specific runtime context.** Calculations using
+  `Get ( HostName )`, `Get ( AccountName )`, `Get ( PrivilegeSetName )`,
+  external data source references, and similar context-dependent
+  functions evaluate against the runtime environment, not against
+  anything in the XML. A script generated for one host may behave
+  differently or fail when run against another.
+
+- **External data source references.** Steps referencing an external
+  FileMaker file (via Perform Script's external file syntax, GTRR
+  to an external occurrence, etc.) carry the data source name but
+  not the file's location. The recipient file must have a Manage
+  External Data Sources entry resolving the named source.
+
+The spec describes what produces *paste-clean* XML. Producing
+*runtime-correct* scripts additionally requires the generator to
+either validate references against a known recipient file's DDR
+before generation, or to clearly mark generated scripts as requiring
+post-paste verification of referenced objects.
+
+## 6. Conditional elements
+
+### 6.0 FM 26 universal elements
+
+**DisableStepCollapsed.** FileMaker 2026 adds
+`<DisableStepCollapsed state="False"/>` to every step in native Copy
+output. This supports the collapsible disabled-block feature in the
+Script Workspace. The element is not required for paste — FM 26
+accepts XML without it and adds it on re-export. Generators may omit
+it. The skeletons in this spec omit it for clarity.
+
+**Window UUID selection.** Close Window (121), Select Window (123),
+Move/Resize Window (119), and Set Window Title (124) now accept a
+UUID in the `<Name>` calculation as well as a window name. At
+runtime, FM searches by name first, then falls back to UUID matching.
+The XML format is unchanged: `<Window value="ByName"/>` with `<Name>`
+containing a `<Calculation>` child. No structural change.
+
+Minimal skeletons in the step reference below show what FileMaker emits
+for an unconfigured or default step. Additional child elements appear
+only when the corresponding option is configured. Common examples:
+
+- Go to Related Record emits `<Name>` only when "Show in new window"
+  is enabled and a window name is set. Dimension elements
+  (`<Height>`, `<Width>`, `<DistanceFromTop>`, `<DistanceFromLeft>`)
+  appear only when dimensions are set in the dialog, independent of
+  window state.
+- Perform Script on Server emits `<Calculation>` only when a parameter
+  is set.
+- Show Custom Dialog emits `<Message>` and `<Buttons>` only when
+  configured; the default skeleton is self-closing.
+
+## 7. Known silent-failure modes
+
+These three patterns paste without error in FileMaker but produce
+broken steps. They are the primary reason this specification exists.
+Each was discovered by round-trip testing — the failure mode is not
+visible from the XML alone.
+
+### 7.1 Set Variable `<Name>` element dropped
+
+**Trigger:** Set Variable (id 141) emitted with non-canonical
+indentation, tab characters, or compact `<Value>`/`<Repetition>`
+form.
+
+**Symptom:** Step pastes successfully and appears in the Script
+Workspace, but the variable name is blank: `Set Variable [ ; Value: ... ]`.
+
+**Fix:** Use exactly the structure documented in Section 3 — 2-space
+indent, expanded `<Value>` and `<Repetition>` blocks with
+`<Calculation>` on its own line, `<Name>` as the last child.
+
+### 7.2 Perform JavaScript in Web Viewer parameters dropped
+
+**Trigger:** Perform JavaScript in Web Viewer (id 175) emitted with
+parameters as flat `<Parameter>` elements (the obvious-but-wrong
+form) instead of FileMaker's actual structure.
+
+**Symptom:** Step pastes successfully with object name and function
+name visible, but no parameters are passed. The JavaScript function
+is called with no arguments.
+
+**Fix:** Wrap parameters in a `<Parameters Count="N">` container with
+`<P>` children — the `<P>` element name is the canonical form, not
+`<Parameter>`. See Section 8.14 for the verified structure.
+
+### 7.3 Install OnTimer Script interval bound to wrong slot
+
+**Trigger:** Install OnTimer Script (id 148) emitted with the
+interval as a top-level `<Calculation>` instead of wrapped in an
+`<Interval>` element.
+
+**Symptom:** Step pastes successfully and appears in the Script
+Workspace as if the interval value is a script parameter. The actual
+timer interval is unset and the timer never fires at the intended
+rate.
+
+**Fix:** Wrap the interval in an `<Interval>` element containing the
+`<Calculation>` child. See Section 8.1 for the verified structure.
+
+### 7.4 Spec-rendering corruption of the canonical Name tag
+
+**Trigger:** This document is consumed by an LLM (or human) through a
+markdown processor — or any rendering layer — that strips inner content
+from anything resembling an HTML element with the spelling N-a-m-e.
+The four-letter canonical tag for variable names, window names, and
+similar elements then appears as a single letter `<n>` throughout the
+document. The reader trusts the rendering, intuits that `<n>` is the
+literal canonical form, and emits the single-letter version in
+generated XML.
+
+**Symptom:** Functionally identical to Section 7.1, but multiplied
+across every step that uses the four-letter tag. Every Set Variable
+pastes with no variable name. Every Close Window By Name pastes with
+no window name. Every GTRR-with-new-window-name pastes with no window
+name. The XML is structurally valid and the steps appear in the Script
+Workspace; the silent drop is uniform and silent.
+
+This failure mode is upstream of FileMaker entirely. It is produced by
+the spec's delivery channel, not by FileMaker's paste handler. From
+the generator's point of view it is indistinguishable from 7.1 —
+structurally valid XML that drops critical content on paste — so the
+defensive posture is the same.
+
+**Fix.** Verify the byte-level form of the tag from a plaintext or
+hex source before generation. The four ASCII bytes are
+`0x4E 0x61 0x6D 0x65`: capital N followed by lowercase a, m, e. When
+referencing the tag in any prompt, specification, or comment passed
+to an LLM, prefer the hyphen-spelled form (`N-a-m-e`) or the explicit
+byte sequence; both survive markdown rendering layers that strip the
+backtick-quoted tag form. The single-letter form `<n>` should appear
+in generator code only as a counterexample with a comment marking it
+as wrong.
+
+**Defensive construction pattern.** The tag must never appear as a
+literal in source code that flows through markdown, JSX, HTML
+templating, or any LLM context window. Rendering layers that strip
+content from `Name`-spelled HTML elements will silently corrupt
+literal occurrences. The safe pattern is to construct the tag from
+its byte values at runtime, so the tag exists only in process memory,
+never in source:
+
+```python
+# Python example — applies equivalently to any language that
+# supports character-code construction.
+NAME_OPEN  = "<" + chr(0x4E) + chr(0x61) + chr(0x6D) + chr(0x65) + ">"
+NAME_CLOSE = "</" + chr(0x4E) + chr(0x61) + chr(0x6D) + chr(0x65) + ">"
+
+# Use NAME_OPEN / NAME_CLOSE in emitted XML.
+# The tag NEVER appears as a literal in this source file.
+```
+
+Generators that adopt this pattern are immune to Section 7.4
+corruption regardless of how the spec, prompts, or build artefacts
+are rendered downstream. Generators that emit the tag as a literal
+string (e.g. `xml += "<Name>" + var + "</Name>"`) are vulnerable any
+time that source file passes through a rendering layer — including
+when it is itself sent as context to an LLM. Code review for any
+FM-XML generator should treat literal occurrences of the four-letter
+tag in source as a bug class to be eliminated, not just commented.
+
+**Where this tag appears in the spec.** Section 3 (Set Variable
+variable name), Section 8.3 (Go to Related Record new-window name),
+Section 8.8 (New Window name; Close Window By Name window name).
+Each of those sections must be read with this rendering trap in mind.
+
+**Why this is in Section 7 rather than a separate appendix.** The
+other three failure modes in this section produce structurally valid
+XML that pastes with silent content drops. So does this one. The fact
+that the cause is a rendering layer rather than FileMaker's paste
+handler is irrelevant from the generator's perspective: the symptom,
+the diagnostic, and the fix posture are identical. Round-trip every
+new step type that uses this tag before treating its structure as
+verified.
+
+### Pattern across all four
+
+Each silent-failure case involves an element name or wrapper where
+the FileMaker-canonical form is shorter or less obvious than what an
+LLM or a developer would intuit: `<Name>` (not `<VariableName>`),
+`<P>` (not `<Parameter>`), `<Interval>` wrapper (not bare
+`<Calculation>`). When FileMaker's paste handler encounters a
+calculation with no expected wrapper, it appears to bind the
+calculation to a default slot rather than reject the step. Generators
+that infer structure from related steps will hit these failures
+predictably.
+
+This list is not exhaustive. Other silent-failure cases may exist in
+step types that have not yet been round-trip tested in their fully
+configured form, and Section 7.4 in particular is likely to be re-
+discovered any time this spec is re-rendered through a new processor.
+The defensive posture is: when adding support for a new step type,
+generate a minimal version, paste it, drill into the step in the
+Script Workspace, and confirm every configured option displays as
+expected before treating the structure as verified. For tags affected
+by Section 7.4, additionally verify the byte-level form of the
+generated XML against the literal byte sequence, not the rendered
+display.
+## Appendix A: Open observations
+
+### A.1 NewWndStyles bit values and extended attributes
+
+Three distinct `Styles` attribute values have been observed on
+`<NewWndStyles>` elements:
+
+- `Styles="983554"` — emitted on configured Go to Related Record steps
+  taken from production scripts. Round-trip verified as the default
+  value for any configured GTRR (with or without new-window options)
+  whose window-style attributes (`Style`, `Close`, `Minimize`,
+  `Maximize`, `Resize`) are unmodified from FM's defaults. Generators
+  emitting GTRR steps without explicit window-style configuration
+  should use this value — it round-trips unchanged through Copy/Paste/
+  save cycles.
+- `Styles="3606018"` — emitted on default or unconfigured Go to Related
+  Record, New Window, and Go to List of Records steps.
+- `Styles="1076299266"` — emitted on a New Window step configured with
+  a window name and additional window-style options
+  (DimParentWindow=No, Toolbars=Yes, MenuBar=Yes).
+
+The meaning of the differing bits has not been established. The values
+are candidates for systematic bit-flag decomposition: toggling
+individual window-style options in the dialog and comparing the
+resulting numeric `Styles` values would identify each bit's role.
+
+`<NewWndStyles>` may also carry additional attributes beyond the
+common set (`Style`, `Close`, `Minimize`, `Maximize`, `Resize`). The
+following have been observed in configured steps:
+
+- `DimParentWindow="No|Yes"` — corresponds to "Dim parent window"
+  option
+- `Toolbars="Yes|No"` — corresponds to whether toolbars are shown in
+  the new window
+- `MenuBar="Yes|No"` — corresponds to whether the menu bar is shown
+
+These optional attributes appear when the corresponding options are
+configured in the step's dialog. Their relationship to the numeric
+`Styles` value is not yet mapped.
+
+---
+
+## Appendix B: Preserved quirks in FileMaker's native output
+
+The following irregularities appear in FileMaker's own Copy output and
+must be preserved verbatim in generated XML. They are FileMaker's
+behaviour, not errors in this document.
+
+### B.1 Configure AI Account — misspelled element (FM 2025 only)
+
+Step 212 emitted `<SetLLMAccout/>` in FM 2025 (missing the `n` in
+`Account`). FM 26 corrected this to `<SetLLMAccount/>`. Generators
+targeting FM 26 should use the corrected spelling. Generators
+targeting FM 2025 should use the misspelled form.
+
+### B.2 Configure RAG Account — trailing space in step name
+
+Step 227 emits `name="Configure RAG Account "` with a trailing space
+inside the attribute value. The trailing space is part of FileMaker's
+native output and must be preserved.
+
+---
+
+## Appendix C: FM 26 PDF error codes
+
+| Code | Meaning | Steps |
+|------|---------|-------|
+| 605 | Container field is empty | Print PDF |
+| 606 | Container data is not a PDF | Print PDF |
+| 607 | Password missing or incorrect for encrypted PDF | Print PDF |
+| 608 | PDF security settings prevent printing | Print PDF |
+| 829 | No PDF file is open to append to | Append PDF |
+| 830 | PDF file not found or invalid format | Open PDF |
+| 831 | Invalid PDF password | Open PDF, Append PDF |
+| 832 | PDF security settings prevent modification | Open PDF |
+| 833 | PDF file is already opened | Create PDF, Open PDF |
+
+---
diff --git a/docs/filemaker-xml-canonical/skill/references/custom-functions.md b/docs/filemaker-xml-canonical/skill/references/custom-functions.md
new file mode 100644
index 0000000..69e8402
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/references/custom-functions.md
@@ -0,0 +1,100 @@
+# Custom Functions (§11)
+
+Part of the Canonical XML Format for FileMaker Script Steps, v1.12.
+Read `core.md` first.
+
+## 11. Custom Functions
+
+### 11.1 Overview
+
+Custom functions use the same `fmxmlsnippet type="FMObjectList"` wrapper as script steps. The paste target is the Manage Custom Functions dialog (not the Script Workspace). Multiple functions can be included in a single snippet and will all paste in one operation.
+
+### 11.2 Canonical skeleton
+
+**No parameters:**
+```xml
+<CustomFunction id="1" functionArity="0" visible="True" parameters="" name="CF_Name">
+  <Calculation><![CDATA[expression]]></Calculation>
+</CustomFunction>
+```
+
+**With parameters:**
+```xml
+<CustomFunction id="1" functionArity="2" visible="True" parameters="input;multiplier" name="CF_Name">
+  <Calculation><![CDATA[input * multiplier]]></Calculation>
+</CustomFunction>
+```
+
+### 11.3 Attributes
+
+| Attribute | Values | Notes |
+|---|---|---|
+| `id` | any integer | Ignored on paste — FileMaker assigns its own sequential ID. Use `id="1"` as placeholder. |
+| `functionArity` | integer | Must match the number of parameters exactly. |
+| `visible` | `"True"` / `"False"` | `"True"` = All accounts. `"False"` = Full access accounts only. |
+| `parameters` | string | Semicolon-separated parameter names. Empty string `""` for zero parameters. |
+| `name` | string | If a CF with this name already exists in the target file, FileMaker pastes it as a new CF with an auto-incremented name suffix (e.g. `CF_Test 2`). It does not overwrite. |
+
+### 11.4 Parameters
+
+Parameters are semicolon-separated in the `parameters` attribute — not comma-separated:
+
+```xml
+<CustomFunction id="1" functionArity="3" visible="True" parameters="input;multiplier;offset" name="CF_Name">
+```
+
+`functionArity` must equal the parameter count exactly.
+
+### 11.5 Recursion
+
+Recursive calls are plain text inside the CDATA body — no special element or attribute required:
+
+```xml
+<CustomFunction id="1" functionArity="1" visible="True" parameters="n" name="CF_Factorial">
+  <Calculation><![CDATA[If ( n <= 1 ; 1 ; n * CF_Factorial ( n - 1 ) )]]></Calculation>
+</CustomFunction>
+```
+
+### 11.6 Calculation body
+
+The `<Calculation>` child follows the same CDATA convention as script steps. Multi-line bodies, comments (`//` and `/* ... */`), and fully commented-out bodies all round-trip intact. FileMaker treats the body as opaque text.
+
+**Commented-out body (verified round-trip):**
+```xml
+<CustomFunction id="1" functionArity="1" visible="True" parameters="text" name="CF_Name">
+  <Calculation><![CDATA[/* entire body commented out
+for later use */]]></Calculation>
+</CustomFunction>
+```
+
+### 11.7 Schema references in the body
+
+Custom function bodies are opaque CDATA — the paste handler performs no schema resolution on field references, table names, or calls to other custom functions within the body. A function referencing `MyTable::MyField` or calling `AnotherCF()` will paste successfully into any file regardless of whether that schema or function exists. Runtime errors surface only when the function is evaluated, not at paste time.
+
+This is a significant difference from script steps, where field and layout references are structured XML elements that FileMaker resolves against the recipient schema on paste.
+
+### 11.8 Multiple functions in one snippet
+
+Any number of `<CustomFunction>` elements may appear in a single snippet. All paste in one operation:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<fmxmlsnippet type="FMObjectList">
+  <CustomFunction id="1" functionArity="1" visible="True" parameters="n" name="CF_Factorial">
+    <Calculation><![CDATA[If ( n <= 1 ; 1 ; n * CF_Factorial ( n - 1 ) )]]></Calculation>
+  </CustomFunction>
+  <CustomFunction id="2" functionArity="0" visible="True" parameters="" name="CF_Today">
+    <Calculation><![CDATA[Get ( CurrentDate )]]></Calculation>
+  </CustomFunction>
+</fmxmlsnippet>
+```
+
+Round-trip verified at scale: 24 functions pasted in a single snippet, all IDs reassigned sequentially from 1.
+
+### 11.9 Known behaviour and limitations
+
+- FileMaker ignores the `id` attribute on paste and assigns its own sequential IDs.
+- Name conflicts result in a new CF being created with an auto-incremented suffix — not an overwrite.
+- No silent-failure modes identified. The format is substantially simpler than script steps with no element-ordering traps.
+- `functionArity` mismatch (value does not match actual parameter count) — behaviour untested; avoid.
+- Add-on and cross-file field references in the body will paste without error but will fail at evaluation time if the referenced schema is not present in the target file.
diff --git a/docs/filemaker-xml-canonical/skill/references/steps-accounts-ai-misc.md b/docs/filemaker-xml-canonical/skill/references/steps-accounts-ai-misc.md
new file mode 100644
index 0000000..b506ed7
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/references/steps-accounts-ai-misc.md
@@ -0,0 +1,826 @@
+# Step Reference — Configure, Accounts, AI, Spelling, Menus, Miscellaneous (§8.2, §8.10–8.14)
+
+Part of the Canonical XML Format for FileMaker Script Steps, v1.12.
+Read `core.md` first: the paste format requirements, conventions and
+silent failure modes there apply to every step below.
+
+### 8.2 Configure (mobile and hardware)
+
+#### Configure Local Notification (187)
+```
+  <Step enable="True" id="187" name="Configure Local Notification">
+    <Action value="Queue"/>
+  </Step>
+```
+
+#### Configure NFC Reading (201)
+```
+  <Step enable="True" id="201" name="Configure NFC Reading">
+    <Action value="Read"/>
+  </Step>
+```
+
+#### Configure Region Monitor Script (185)
+```
+  <Step enable="True" id="185" name="Configure Region Monitor Script">
+    <MonitorType value="iBeacon"/>
+  </Step>
+```
+
+#### Configure Persistent Data (238)
+
+Sets or deletes an entry in the per-file persistent data store
+(Draco Catalog). Entries survive file close, Data Migration Tool,
+and session restarts. Read values with `GetPersistentData()` and
+`ListPersistentDataIDs()`.
+
+Options: `Name` (required text), `Instance ID` (optional text
+calculation), `Value` (expression, data type preserved) or
+`Delete Entry`. An unspecified Instance ID is treated the same as
+an empty string. Deleting a nonexistent entry returns error 10.
+
+Unconfigured:
+```
+  <Step enable="True" id="238" name="Configure Persistent Data">
+    <Option state="False"/>
+  </Step>
+```
+
+Set mode (round-trip verified):
+```
+  <Step enable="True" id="238" name="Configure Persistent Data">
+    <Option state="False"/>
+    <Value>
+      <Calculation><![CDATA[value expression]]></Calculation>
+    </Value>
+    <InstanceId>
+      <Calculation><![CDATA["instance id"]]></Calculation>
+    </InstanceId>
+    <Name>"entry name"</Name>
+  </Step>
+```
+
+Delete mode (round-trip verified):
+```
+  <Step enable="True" id="238" name="Configure Persistent Data">
+    <Option state="True"/>
+    <InstanceId>
+      <Calculation><![CDATA["instance id"]]></Calculation>
+    </InstanceId>
+    <Name>"entry name"</Name>
+  </Step>
+```
+
+Notes:
+- `<Option state="False"/>` = Set. `<Option state="True"/>` = Delete.
+- **`<Name>` is plain text, not a Calculation wrapper.** Content
+  includes literal quotes when a quoted string is entered. This is an
+  inconsistency: `<Value>` and `<InstanceId>` both use
+  `<Calculation><![CDATA[...]]></Calculation>` but `<Name>` does not.
+  Generators must emit `<Name>` as plain text, not CDATA-wrapped.
+  This may be a silent-failure trap.
+- Element order (Set): `Option` → `Value` → `InstanceId` → `Name`.
+- Element order (Delete): `Option` → `InstanceId` → `Name`.
+
+---
+
+### 8.10 Accounts
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| Delete Account | 135 |
+
+#### Add Account (134)
+```
+  <Step enable="True" id="134" name="Add Account">
+    <ChgPwdOnNextLogin value="False"/>
+    <AddAccount>
+      <AccountType>FileMaker</AccountType>
+    </AddAccount>
+  </Step>
+```
+
+#### Change Password (83)
+```
+  <Step enable="True" id="83" name="Change Password">
+    <NoInteract state="False"/>
+  </Step>
+```
+
+#### Enable Account (137)
+```
+  <Step enable="True" id="137" name="Enable Account">
+    <AccountOperation value="Activate"/>
+  </Step>
+```
+
+#### Re-Login (138)
+```
+  <Step enable="True" id="138" name="Re-Login">
+    <NoInteract state="True"/>
+  </Step>
+```
+
+With explicit credentials (each as a Calculation expression):
+```
+  <Step enable="True" id="138" name="Re-Login">
+    <NoInteract state="True"/>
+    <AccountName>
+      <Calculation><![CDATA["account name"]]></Calculation>
+    </AccountName>
+    <Password>
+      <Calculation><![CDATA["password expression"]]></Calculation>
+    </Password>
+  </Step>
+```
+
+Both `<AccountName>` and `<Password>` are calculation containers, so
+the values can be field references, variables, or computed expressions
+rather than hardcoded strings. Hardcoded credentials in the XML are
+visible to anyone who can edit the script.
+
+#### Reset Account Password (136)
+```
+  <Step enable="True" id="136" name="Reset Account Password">
+    <ChgPwdOnNextLogin value="False"/>
+  </Step>
+```
+
+---
+
+### 8.11 AI
+
+AI steps carry a distinctive sub-element naming the AI operation type
+(for example `<LLMRequestWithTools>`, `<LLMSemanticFind>`). Minimal
+skeletons show this sub-element in its empty form.
+
+#### Configure AI Account (212)
+
+`<LLMType>` enumeration (all round-trip verified):
+
+| Provider | LLMType value |
+|---|---|
+| OpenAI | `ChatGPT` |
+| Anthropic | `Anthropic` |
+| Cohere | `Cohere` |
+| Google Gemini | `Google` |
+| Custom | `Other` |
+
+Unconfigured:
+```
+  <Step enable="True" id="212" name="Configure AI Account">
+    <LLMType value="ChatGPT"/>
+    <SetLLMAccount/>
+  </Step>
+```
+
+Predefined providers (round-trip verified):
+```
+  <Step enable="True" id="212" name="Configure AI Account">
+    <LLMType value="ChatGPT"/>
+    <SetLLMAccount>
+      <AccountName>
+        <Calculation><![CDATA["account name"]]></Calculation>
+      </AccountName>
+      <AccessAPIKey>
+        <Calculation><![CDATA["api key"]]></Calculation>
+      </AccessAPIKey>
+    </SetLLMAccount>
+  </Step>
+```
+
+Custom provider (round-trip verified):
+```
+  <Step enable="True" id="212" name="Configure AI Account">
+    <VerifySSLCertificates state="False"/>
+    <LLMType value="Other"/>
+    <SetLLMAccount>
+      <AccountName>
+        <Calculation><![CDATA["account name"]]></Calculation>
+      </AccountName>
+      <Endpoint>
+        <Calculation><![CDATA["https://server.example.com/llm/v1/"]]></Calculation>
+      </Endpoint>
+      <AccessAPIKey>
+        <Calculation><![CDATA["api key"]]></Calculation>
+      </AccessAPIKey>
+    </SetLLMAccount>
+  </Step>
+```
+
+Custom adds `<VerifySSLCertificates>` as a direct Step child before
+`<LLMType>`, and `<Endpoint>` inside `<SetLLMAccount>` between
+`AccountName` and `AccessAPIKey`.
+
+Note: FM 26 corrected the inner element spelling from `SetLLMAccout`
+(FM 2025) to `SetLLMAccount`. See Appendix B. Generators targeting
+FM 26 should use the corrected spelling.
+
+#### Configure Machine Learning Model (202)
+```
+  <Step enable="True" id="202" name="Configure Machine Learning Model">
+    <ConfigureCoreML>Uninstall</ConfigureCoreML>
+  </Step>
+```
+
+#### Configure Prompt Template (226)
+```
+  <Step enable="True" id="226" name="Configure Prompt Template">
+    <Option state="False"/>
+    <ConfigurePromptTemplate>
+      <ModelProvider>ChatGPT</ModelProvider>
+      <RequestType>SQLQuery</RequestType>
+    </ConfigurePromptTemplate>
+  </Step>
+```
+
+#### Configure RAG Account (227)
+```
+  <Step enable="True" id="227" name="Configure RAG Account ">
+    <VerifySSLCertificates state="False"/>
+    <ConfigureRAGAccount/>
+  </Step>
+```
+
+The `name` attribute contains a trailing space (`"Configure RAG Account "`)
+in FileMaker's native output. See Appendix B.
+
+#### Configure Regression Model (222)
+```
+  <Step enable="True" id="222" name="Configure Regression Model">
+    <LLMTrain>
+      <LLMTrainAction>LLMTrainTrainModel</LLMTrainAction>
+      <LLMAlgorithm>LLMTrainAlgForest</LLMAlgorithm>
+    </LLMTrain>
+  </Step>
+```
+
+#### Fine-Tune Model (213)
+```
+  <Step enable="True" id="213" name="Fine-Tune Model">
+    <Option state="False"/>
+    <UniversalPathList type="Embedded"/>
+    <Table id="0" name=""/>
+    <FineTuneLLM>
+      <DataSource>DataTable</DataSource>
+    </FineTuneLLM>
+  </Step>
+```
+
+#### Generate Response from Model (220)
+```
+  <Step enable="True" id="220" name="Generate Response from Model">
+    <Option state="False"/>
+    <SelectAll state="False"/>
+    <Stream state="False"/>
+    <Set state="True"/>
+    <LinkAvail state="False"/>
+    <Restore state="False"/>
+    <UniversalPathList type="Embedded"/>
+    <LLMRequestWithTools/>
+  </Step>
+```
+
+#### Insert Embedding (215)
+```
+  <Step enable="True" id="215" name="Insert Embedding">
+    <LLMEmbedding/>
+  </Step>
+```
+
+#### Insert Embedding in Found Set (216)
+```
+  <Step enable="True" id="216" name="Insert Embedding in Found Set">
+    <LLMBulkEmbedding/>
+  </Step>
+```
+
+#### Perform Find by Natural Language (221)
+```
+  <Step enable="True" id="221" name="Perform Find by Natural Language">
+    <Option state="False"/>
+    <SelectAll state="True"/>
+    <LLMCreateFind>
+      <Action>Query</Action>
+    </LLMCreateFind>
+  </Step>
+```
+
+#### Perform RAG Action (219)
+```
+  <Step enable="True" id="219" name="Perform RAG Action">
+    <RAGSpace>
+      <RAGSpaceAction>Add</RAGSpaceAction>
+      <DataSource>FromText</DataSource>
+    </RAGSpace>
+  </Step>
+```
+
+#### Perform Semantic Find (218)
+```
+  <Step enable="True" id="218" name="Perform Semantic Find">
+    <LLMSemanticFind>
+      <Query type="1"/>
+      <Records type="1"/>
+    </LLMSemanticFind>
+  </Step>
+```
+
+#### Perform SQL Query by Natural Language (214)
+```
+  <Step enable="True" id="214" name="Perform SQL Query by Natural Language">
+    <Option state="False"/>
+    <Stream state="False"/>
+    <UniversalPathList type="Embedded"/>
+    <PerformSQLQuerybyNaturalLanguage>
+      <OptionsSelectionType>By List</OptionsSelectionType>
+      <Action>Query</Action>
+      <TablesSelectionType>By List</TablesSelectionType>
+      <TableAliases/>
+    </PerformSQLQuerybyNaturalLanguage>
+  </Step>
+```
+
+#### Set AI Call Logging (217)
+```
+  <Step enable="True" id="217" name="Set AI Call Logging">
+    <Set state="False"/>
+    <LLMDebugLog/>
+  </Step>
+```
+
+#### Insert Image Caption (241)
+
+Sends an image to a captioning model and inserts the returned text
+into a field or variable. Claris AI Model Server only.
+
+Options: `Account Name`, `Model`, `Input` (expression returning
+container data), `Target` (field or variable, required).
+
+```
+  <Step enable="True" id="241" name="Insert Image Caption">
+    <LLMEmbedding/>
+  </Step>
+```
+
+Reuses the `<LLMEmbedding/>` inner element from Insert Embedding (215).
+
+#### Insert Image Captions in Found Set (240)
+
+Batch version: for every record in the found set, sends an image
+from a source field to a captioning model and inserts the caption
+into a target field. Claris AI Model Server only.
+
+Options: `Account Name`, `Model`, `Source Field` (container),
+`Target Field` (text), `Replace target contents`,
+`Continue on error`, `Parameters` (JSON with `MaxRecPerCall`
+default 20, range 1-500).
+
+```
+  <Step enable="True" id="240" name="Insert Image Captions in Found Set">
+    <LLMBulkEmbedding/>
+  </Step>
+```
+
+Reuses the `<LLMBulkEmbedding/>` inner element from Insert Embedding
+in Found Set (216).
+
+---
+
+### 8.12 Spelling
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| Check Found Set | 20 |
+| Check Record | 19 |
+| Correct Word | 106 |
+| Edit User Dictionary | 109 |
+| Select Dictionaries | 108 |
+
+#### Check Selection (18)
+```
+  <Step enable="True" id="18" name="Check Selection">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Set Dictionary (209)
+```
+  <Step enable="True" id="209" name="Set Dictionary">
+    <MainDictionary value="US English"/>
+  </Step>
+```
+
+#### Spelling Options (107)
+```
+  <Step enable="True" id="107" name="Spelling Options"/>
+```
+
+---
+
+### 8.13 Open Menu
+
+These steps open built-in dialogs and take no parameters.
+
+```
+  <Step enable="True" id="149" name="Open Edit Saved Finds"/>
+  <Step enable="True" id="183" name="Open Favorites"/>
+  <Step enable="True" id="114" name="Open File Options"/>
+  <Step enable="True" id="129" name="Open Find/Replace"/>
+  <Step enable="True" id="32"  name="Open Help"/>
+  <Step enable="True" id="118" name="Open Hosts"/>
+  <Step enable="True" id="156" name="Open Manage Containers"/>
+  <Step enable="True" id="140" name="Open Manage Data Sources"/>
+  <Step enable="True" id="38"  name="Open Manage Database"/>
+  <Step enable="True" id="151" name="Open Manage Layouts"/>
+  <Step enable="True" id="165" name="Open Manage Themes"/>
+  <Step enable="True" id="112" name="Open Manage Value Lists"/>
+  <Step enable="True" id="88"  name="Open Script Workspace"/>
+  <Step enable="True" id="105" name="Open Settings"/>
+  <Step enable="True" id="113" name="Open Sharing"/>
+  <Step enable="True" id="172" name="Open Upload to Host"/>
+```
+
+---
+
+### 8.14 Miscellaneous
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| AVPlayer Set Options | 179 |
+| Beep | 93 |
+| Exit Application | 44 |
+| Flush Cache to Disk | 102 |
+| Flush Web Viewer Cookies | 237 |
+| Install Plug-In File | 157 |
+| Refresh Portal | 180 |
+| Set Session Identifier | 208 |
+
+#### Allow Formatting Bar (115)
+```
+  <Step enable="True" id="115" name="Allow Formatting Bar">
+    <Set state="False"/>
+  </Step>
+```
+
+#### AVPlayer Play (177)
+```
+  <Step enable="True" id="177" name="AVPlayer Play">
+    <Source value="Object"/>
+  </Step>
+```
+
+#### AVPlayer Set Playback State (178)
+```
+  <Step enable="True" id="178" name="AVPlayer Set Playback State">
+    <PlaybackState value="Stopped"/>
+  </Step>
+```
+
+#### Dial Phone (65)
+```
+  <Step enable="True" id="65" name="Dial Phone">
+    <NoInteract state="True"/>
+  </Step>
+```
+
+#### Enable Touch Keyboard (174)
+```
+  <Step enable="True" id="174" name="Enable Touch Keyboard">
+    <ShowHide value="Show"/>
+  </Step>
+```
+
+#### Execute FileMaker Data API (203)
+```
+  <Step enable="True" id="203" name="Execute FileMaker Data API">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Execute SQL (117)
+```
+  <Step enable="True" id="117" name="Execute SQL">
+    <NoInteract state="True"/>
+  </Step>
+```
+
+#### Get Folder Path (181)
+```
+  <Step enable="True" id="181" name="Get Folder Path">
+    <AllowFolderCreation state="False"/>
+  </Step>
+```
+
+#### Install Menu Set (142)
+```
+  <Step enable="True" id="142" name="Install Menu Set">
+    <UseAsFileDefault state="False"/>
+    <CustomMenuSet id="1" name="[Standard FileMaker Menus]"/>
+  </Step>
+```
+
+#### Open URL (111)
+```
+  <Step enable="True" id="111" name="Open URL">
+    <NoInteract state="True"/>
+    <Option state="False"/>
+  </Step>
+```
+
+#### Perform AppleScript (67)
+```
+  <Step enable="True" id="67" name="Perform AppleScript">
+    <ContentType value="Text"/>
+  </Step>
+```
+
+#### Perform JavaScript in Web Viewer (175)
+```
+  <Step enable="True" id="175" name="Perform JavaScript in Web Viewer"/>
+```
+
+Configured with object name, function name, and parameters. Element
+order is fixed: `ObjectName` → `FunctionName` → optional `Parameters`.
+Parameters use a non-obvious nested structure: a `<Parameters>`
+wrapper with a `Count` attribute, containing one `<P>` child per
+argument, each wrapping a `<Calculation>`.
+```
+  <Step enable="True" id="175" name="Perform JavaScript in Web Viewer">
+    <ObjectName>
+      <Calculation><![CDATA["myWebViewer"]]></Calculation>
+    </ObjectName>
+    <FunctionName>
+      <Calculation><![CDATA["updateData"]]></Calculation>
+    </FunctionName>
+    <Parameters Count="3">
+      <P>
+        <Calculation><![CDATA["first arg"]]></Calculation>
+      </P>
+      <P>
+        <Calculation><![CDATA[42]]></Calculation>
+      </P>
+      <P>
+        <Calculation><![CDATA[$variable_arg]]></Calculation>
+      </P>
+    </Parameters>
+  </Step>
+```
+
+Notes:
+
+- The `Count` attribute on `<Parameters>` must match the number of
+  `<P>` children. Whether FileMaker validates this on paste or trusts
+  the count is not yet established.
+- The `<P>` element name is the exact canonical form. Generators
+  emitting `<Parameter>` (the longer, more obvious name) will have
+  the entire parameter list silently dropped on paste — same failure
+  class as the Set Variable `<Name>` issue. This is a verified
+  silent-failure mode.
+- Without parameters, omit the `<Parameters>` wrapper entirely.
+
+#### Refresh Object (167)
+```
+  <Step enable="True" id="167" name="Refresh Object"/>
+```
+
+With object name:
+```
+  <Step enable="True" id="167" name="Refresh Object">
+    <ObjectName>
+      <Calculation><![CDATA["object name"]]></Calculation>
+    </ObjectName>
+  </Step>
+```
+
+#### Save a Copy as Add-on Package (96)
+```
+  <Step enable="True" id="96" name="Save a Copy as Add-on Package">
+    <LinkAvail state="False"/>
+  </Step>
+```
+
+#### Send DDE Execute (64)
+```
+  <Step enable="True" id="64" name="Send DDE Execute">
+    <ContentType value="File"/>
+  </Step>
+```
+
+#### Send Event (57)
+```
+  <Step enable="True" id="57" name="Send Event">
+    <ContentType value="File"/>
+    <Event CopyResultToClipboard="False" WaitForCompletion="False" BringTargetToForeground="False"/>
+  </Step>
+```
+
+#### Send Mail (63)
+```
+  <Step enable="True" id="63" name="Send Mail">
+    <NoInteract state="True"/>
+    <MultipleEmails state="False"/>
+    <SendViaSMTP state="False"/>
+    <SendViaOAuthAuthentication state="False"/>
+    <SMTPEncryptionType type="SMTPEncryptionNone"/>
+    <SMTPAuthenticationType type="SMTPAuthenticationNone"/>
+    <OAuthProvider type="OAuthProviderGoogle"/>
+  </Step>
+```
+
+#### Set Web Viewer (146)
+
+Default minimal:
+```
+  <Step enable="True" id="146" name="Set Web Viewer">
+    <Action value="Reset"/>
+  </Step>
+```
+
+`<Action>` enumeration values: `Reset`, `Reload`, `GoForward`,
+`GoBack`, `GoToURL`. Element order is fixed: `Action` → optional
+`ObjectName` → optional `URL`.
+
+**Reset** — no target needed:
+```
+  <Step enable="True" id="146" name="Set Web Viewer">
+    <Action value="Reset"/>
+  </Step>
+```
+
+**Reload, GoForward, GoBack** — targets a Web Viewer object by name:
+```
+  <Step enable="True" id="146" name="Set Web Viewer">
+    <Action value="Reload"/>
+    <ObjectName>
+      <Calculation><![CDATA["myWebViewer"]]></Calculation>
+    </ObjectName>
+  </Step>
+```
+
+**GoToURL** — adds a `<URL>` element with a `custom` attribute:
+```
+  <Step enable="True" id="146" name="Set Web Viewer">
+    <Action value="GoToURL"/>
+    <ObjectName>
+      <Calculation><![CDATA["myWebViewer"]]></Calculation>
+    </ObjectName>
+    <URL custom="False">
+      <Calculation><![CDATA["https://example.com/test"]]></Calculation>
+    </URL>
+  </Step>
+```
+
+The `custom="False"` attribute on `<URL>` corresponds to a toggle in
+the Set Web Viewer dialog (likely "custom web address" versus a
+preset URL source). Generators should emit `custom="False"` to match
+FileMaker's canonical output. The `<URL>` element wraps a
+`<Calculation>` for the URL expression.
+
+#### Show Custom Dialog (87)
+```
+  <Step enable="True" id="87" name="Show Custom Dialog"/>
+```
+
+Configured steps emit children in fixed order: optional `<Title>` →
+`<Message>` → optional `<Height>` → `<Width>` → `<DistanceFromTop>` →
+`<DistanceFromLeft>` → `<Buttons>`. `<Title>` and `<Message>` each
+wrap a `<Calculation>`. `<Buttons>` always contains exactly three
+`<Button>` slots — unused slots are self-closing.
+`CommitState="True"` on a button indicates that the button commits
+the pending record; it is not a "default button" indicator.
+
+**FM 26: Size and position** (round-trip verified). `<Height>`,
+`<Width>`, `<DistanceFromTop>`, and `<DistanceFromLeft>` are optional
+calculation elements specifying dialog size and position in points.
+They sit between `<Message>` and `<Buttons>`. All are optional —
+unspecified values use defaults. FileMaker Go does not support size
+and position.
+```
+  <Step enable="True" id="87" name="Show Custom Dialog">
+    <Title>
+      <Calculation><![CDATA["Dialog Title"]]></Calculation>
+    </Title>
+    <Message>
+      <Calculation><![CDATA["Message text"]]></Calculation>
+    </Message>
+    <Height>
+      <Calculation><![CDATA[200]]></Calculation>
+    </Height>
+    <Width>
+      <Calculation><![CDATA[400]]></Calculation>
+    </Width>
+    <DistanceFromTop>
+      <Calculation><![CDATA[100]]></Calculation>
+    </DistanceFromTop>
+    <DistanceFromLeft>
+      <Calculation><![CDATA[100]]></Calculation>
+    </DistanceFromLeft>
+    <Buttons>
+      <Button CommitState="True">
+        <Calculation><![CDATA["OK"]]></Calculation>
+      </Button>
+      <Button CommitState="False">
+        <Calculation><![CDATA["Cancel"]]></Calculation>
+      </Button>
+      <Button CommitState="False"/>
+    </Buttons>
+  </Step>
+```
+
+**Single OK (alert) — OK commits:**
+```
+  <Step enable="True" id="87" name="Show Custom Dialog">
+    <Message>
+      <Calculation><![CDATA["message text"]]></Calculation>
+    </Message>
+    <Buttons>
+      <Button CommitState="True">
+        <Calculation><![CDATA["OK"]]></Calculation>
+      </Button>
+      <Button CommitState="False"/>
+      <Button CommitState="False"/>
+    </Buttons>
+  </Step>
+```
+
+**With title (error or notice dialog):**
+```
+  <Step enable="True" id="87" name="Show Custom Dialog">
+    <Title>
+      <Calculation><![CDATA["Error"]]></Calculation>
+    </Title>
+    <Message>
+      <Calculation><![CDATA["Unable to mount fileserver"]]></Calculation>
+    </Message>
+    <Buttons>
+      <Button CommitState="False">
+        <Calculation><![CDATA["OK"]]></Calculation>
+      </Button>
+      <Button CommitState="False"/>
+      <Button CommitState="False"/>
+    </Buttons>
+  </Step>
+```
+
+**Two-button choice (neither commits):**
+```
+    <Buttons>
+      <Button CommitState="False">
+        <Calculation><![CDATA["No"]]></Calculation>
+      </Button>
+      <Button CommitState="False">
+        <Calculation><![CDATA["Yes"]]></Calculation>
+      </Button>
+      <Button CommitState="False"/>
+    </Buttons>
+```
+
+The clicked button is reported by `Get ( LastMessageChoice )` as
+1, 2, or 3.
+
+#### Speak (66)
+```
+  <Step enable="True" id="66" name="Speak">
+    <SpeechOptions WaitForCompletion="True" VoiceId="0"/>
+  </Step>
+```
+
+---
+
diff --git a/docs/filemaker-xml-canonical/skill/references/steps-control.md b/docs/filemaker-xml-canonical/skill/references/steps-control.md
new file mode 100644
index 0000000..31e5b31
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/references/steps-control.md
@@ -0,0 +1,244 @@
+# Step Reference — Control (§8.1)
+
+Part of the Canonical XML Format for FileMaker Script Steps, v1.12.
+Read `core.md` first: the paste format requirements, conventions and
+silent failure modes there apply to every step below.
+
+### 8.1 Control
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| End If | 70 |
+| End Loop | 73 |
+| Halt Script | 90 |
+| Commit Transaction | 206 |
+
+#### If (68)
+```
+  <Step enable="True" id="68" name="If">
+    <Restore state="False"/>
+    <Calculation><![CDATA[condition]]></Calculation>
+  </Step>
+```
+
+#### Else If (125)
+Identical structure to If:
+```
+  <Step enable="True" id="125" name="Else If">
+    <Restore state="False"/>
+    <Calculation><![CDATA[condition]]></Calculation>
+  </Step>
+```
+
+#### Else (69)
+```
+  <Step enable="True" id="69" name="Else">
+    <Restore state="False"/>
+  </Step>
+```
+
+#### Loop (71)
+```
+  <Step enable="True" id="71" name="Loop">
+    <Restore state="False"/>
+    <FlushType value="Always"/>
+  </Step>
+```
+
+#### Exit Loop If (72)
+```
+  <Step enable="True" id="72" name="Exit Loop If">
+    <Calculation><![CDATA[condition]]></Calculation>
+  </Step>
+```
+
+#### Exit Script (103)
+```
+  <Step enable="True" id="103" name="Exit Script"/>
+```
+
+With return value:
+```
+  <Step enable="True" id="103" name="Exit Script">
+    <Calculation><![CDATA[return value]]></Calculation>
+  </Step>
+```
+
+#### Pause/Resume Script (62)
+```
+  <Step enable="True" id="62" name="Pause/Resume Script">
+    <PauseTime value="Indefinitely"/>
+  </Step>
+```
+
+#### Install OnTimer Script (148)
+
+Cancel-all form (no children):
+```
+  <Step enable="True" id="148" name="Install OnTimer Script"/>
+```
+
+Configured with a script reference and an interval. The interval
+must be wrapped in an `<Interval>` element containing a
+`<Calculation>` child. Element order: `Interval` → `Script`.
+```
+  <Step enable="True" id="148" name="Install OnTimer Script">
+    <Interval>
+      <Calculation><![CDATA[5]]></Calculation>
+    </Interval>
+    <Script id="N" name="script name"/>
+  </Step>
+```
+
+The interval is in seconds. The `<Calculation>` content can be a
+literal number or any expression that evaluates to a number.
+
+**Silent-drop warning.** If the `<Calculation>` for the interval is
+emitted as a direct child of `<Step>` rather than wrapped in
+`<Interval>`, FileMaker pastes the step without error but binds the
+calculation to the wrong internal slot. The step then appears in the
+Script Workspace as if it has a script parameter set, but the actual
+interval is unset — the timer will never fire at the intended rate.
+This is a verified silent-failure mode similar to the Set Variable
+`<Name>` and Perform JavaScript `<P>` cases.
+
+#### Open Transaction (205)
+```
+  <Step enable="True" id="205" name="Open Transaction">
+    <Option state="False"/>
+    <ESSForceCommit state="False"/>
+    <SkipAutoEntry state="False"/>
+    <Restore state="False"/>
+  </Step>
+```
+
+#### Revert Transaction (207)
+```
+  <Step enable="True" id="207" name="Revert Transaction">
+    <Option state="False"/>
+  </Step>
+```
+
+#### Set Revert Transaction on Error (223)
+```
+  <Step enable="True" id="223" name="Set Revert Transaction on Error">
+    <Set state="False"/>
+  </Step>
+```
+
+#### Perform Script (1)
+```
+  <Step enable="True" id="1" name="Perform Script">
+    <Script id="N" name="script name"/>
+  </Step>
+```
+
+#### Perform Script on Server (164)
+
+Without parameter:
+```
+  <Step enable="True" id="164" name="Perform Script on Server">
+    <WaitForCompletion state="True"/>
+    <Script id="N" name="script name"/>
+  </Step>
+```
+
+With parameter:
+```
+  <Step enable="True" id="164" name="Perform Script on Server">
+    <WaitForCompletion state="True"/>
+    <Calculation><![CDATA[parameter expression]]></Calculation>
+    <Script id="N" name="script name"/>
+  </Step>
+```
+
+#### Perform Script on Server with Callback (210)
+```
+  <Step enable="True" id="210" name="Perform Script on Server with Callback">
+    <CallbackScriptState value="Continue"/>
+    <CallbackScript/>
+  </Step>
+```
+
+#### Set Error Capture (86)
+```
+  <Step enable="True" id="86" name="Set Error Capture">
+    <Set state="True"/>
+  </Step>
+```
+
+#### Set Error Logging (200)
+```
+  <Step enable="True" id="200" name="Set Error Logging">
+    <Option state="False"/>
+  </Step>
+```
+
+#### Set Variable (141)
+See Section 3.
+
+#### Allow User Abort (85)
+```
+  <Step enable="True" id="85" name="Allow User Abort">
+    <Set state="False"/>
+  </Step>
+```
+
+#### Set Layout Object Animation (168)
+```
+  <Step enable="True" id="168" name="Set Layout Object Animation">
+    <Set state="True"/>
+  </Step>
+```
+
+#### Trigger Claris Connect Flow (211)
+```
+  <Step enable="True" id="211" name="Trigger Claris Connect Flow">
+    <NoInteract state="True"/>
+    <DontEncodeURL state="False"/>
+    <SelectAll state="True"/>
+    <VerifySSLCertificates state="False"/>
+    <Flow>flow identifier</Flow>
+    <CURLOptions>
+      <Calculation><![CDATA["--request POST --header \"Content-Type: application/json\" --data "]]></Calculation>
+    </CURLOptions>
+    <Text>payload</Text>
+  </Step>
+```
+
+Unconfigured steps emit `&lt;unknown&gt;` in the `<Flow>` and `<Text>`
+elements.
+
+#### Comment (89)
+```
+  <Step enable="True" id="89" name="# (comment)"/>
+```
+
+With text:
+```
+  <Step enable="True" id="89" name="# (comment)">
+    <Text>comment text</Text>
+  </Step>
+```
+
+The self-closing form (no `<Text>` child, not an empty `<Text/>`) is
+the canonical form for the bare divider lines that punctuate most
+production scripts. Round-trip verified: a blank `# ` line in the
+Script Workspace emits as the self-closing form on Copy, and an
+empty `<Text/>` body is not the equivalent — generators should emit
+the self-closing form for divider lines.
+
+---
+
diff --git a/docs/filemaker-xml-canonical/skill/references/steps-fields-records.md b/docs/filemaker-xml-canonical/skill/references/steps-fields-records.md
new file mode 100644
index 0000000..05fc8ed
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/references/steps-fields-records.md
@@ -0,0 +1,619 @@
+# Step Reference — Fields, Records and Found Sets (§8.5–8.7)
+
+Part of the Canonical XML Format for FileMaker Script Steps, v1.12.
+Read `core.md` first: the paste format requirements, conventions and
+silent failure modes there apply to every step below.
+
+### 8.5 Fields
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| Set Field By Name | 147 |
+
+#### Export Field Contents (132)
+```
+  <Step enable="True" id="132" name="Export Field Contents">
+    <CreateDirectories state="True"/>
+    <AutoOpen state="False"/>
+    <CreateEmail state="False"/>
+  </Step>
+```
+
+#### Insert Audio/Video (159)
+```
+  <Step enable="True" id="159" name="Insert Audio/Video">
+    <UniversalPathList type="Embedded"/>
+  </Step>
+```
+
+#### Insert Calculated Result (77)
+```
+  <Step enable="True" id="77" name="Insert Calculated Result">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Insert Current Date (13)
+```
+  <Step enable="True" id="13" name="Insert Current Date">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Insert Current Time (14)
+```
+  <Step enable="True" id="14" name="Insert Current Time">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Insert Current User Name (60)
+```
+  <Step enable="True" id="60" name="Insert Current User Name">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Insert File (131)
+```
+  <Step enable="True" id="131" name="Insert File">
+    <UniversalPathList type="Embedded"/>
+    <DialogOptions asFile="True" enable="False">
+      <Storage type="UserChoice"/>
+      <Compress type="UserChoice"/>
+      <FilterList/>
+    </DialogOptions>
+  </Step>
+```
+
+#### Insert from Device (161)
+```
+  <Step enable="True" id="161" name="Insert from Device">
+    <InsertFrom value="Camera"/>
+    <DeviceOptions>
+      <Camera choice="Back"/>
+      <Resolution choice="Full"/>
+      <LightMode choice="Auto"/>
+    </DeviceOptions>
+  </Step>
+```
+
+FM 26 adds `<LightMode>` inside `<DeviceOptions>` for controlling
+the device flash. Enumeration: `Auto`, `On`, `Off`.
+
+#### Insert from Index (11)
+```
+  <Step enable="True" id="11" name="Insert from Index">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Insert from Last Visited (12)
+```
+  <Step enable="True" id="12" name="Insert from Last Visited">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Insert from URL (160)
+```
+  <Step enable="True" id="160" name="Insert from URL">
+    <NoInteract state="True"/>
+    <DontEncodeURL state="False"/>
+    <SelectAll state="True"/>
+    <VerifySSLCertificates state="False"/>
+  </Step>
+```
+
+Configured with a target variable, URL, and cURL options. Element
+order is fixed: `NoInteract` → `DontEncodeURL` → `SelectAll` →
+`VerifySSLCertificates` → `CURLOptions` (optional) → `Calculation`
+(the URL) → `Text` → `Field`.
+```
+  <Step enable="True" id="160" name="Insert from URL">
+    <NoInteract state="True"/>
+    <DontEncodeURL state="False"/>
+    <SelectAll state="True"/>
+    <VerifySSLCertificates state="False"/>
+    <CURLOptions>
+      <Calculation><![CDATA[$curl]]></Calculation>
+    </CURLOptions>
+    <Calculation><![CDATA[$endpoint]]></Calculation>
+    <Text/>
+    <Field>$result</Field>
+  </Step>
+```
+
+Notes:
+
+- The URL is held in a top-level `<Calculation>` element, not wrapped
+  in a `<URL>` element.
+- `<CURLOptions>` is optional and contains a `<Calculation>` child.
+- `<Text/>` is typically empty in URL-fetch usage (its purpose is the
+  POST/PUT body for some configurations, otherwise self-closing).
+- `<Field>` carries the target. For a variable target, the body is
+  the variable name as plain text: `<Field>$result</Field>`. For a
+  field target, the structured reference form applies:
+  `<Field table="TableOccurrence" id="N" name="field_name"/>`.
+
+#### Insert PDF (158)
+```
+  <Step enable="True" id="158" name="Insert PDF">
+    <UniversalPathList type="Embedded"/>
+  </Step>
+```
+
+#### Insert Picture (56)
+```
+  <Step enable="True" id="56" name="Insert Picture">
+    <UniversalPathList type="Embedded"/>
+  </Step>
+```
+
+#### Insert Text (61)
+```
+  <Step enable="True" id="61" name="Insert Text">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Relookup Field Contents (40)
+```
+  <Step enable="True" id="40" name="Relookup Field Contents">
+    <NoInteract state="True"/>
+  </Step>
+```
+
+#### Replace Field Contents (91)
+```
+  <Step enable="True" id="91" name="Replace Field Contents">
+    <NoInteract state="True"/>
+    <Restore state="False"/>
+    <With value="None"/>
+    <SerialNumbers PerformAutoEnter="False" UpdateEntryOptions="False" increment="0" InitialValue="" UseEntryOptions="False"/>
+  </Step>
+```
+
+FM 26 adds `PerformAutoEnter` and `UseEntryOptions` attributes to
+`<SerialNumbers>`. The `increment` and `InitialValue` attributes are
+only present in serial number replacement mode; they may be absent in
+other modes.
+
+`<With>` values: `None`, `CurrentContents` (FM 26). Other expected
+values for serial number and calculation modes not yet documented.
+
+#### Set Field (76)
+```
+  <Step enable="True" id="76" name="Set Field"/>
+```
+
+Configured:
+```
+  <Step enable="True" id="76" name="Set Field">
+    <Calculation><![CDATA[expression]]></Calculation>
+    <Field table="TableOccurrence" id="N" name="field_name"/>
+  </Step>
+```
+
+#### Set Next Serial Value (116)
+```
+  <Step enable="True" id="116" name="Set Next Serial Value"/>
+```
+
+---
+
+### 8.6 Records
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| Copy All Records/Requests | 98 |
+| Copy Record/Request | 101 |
+| Duplicate Record/Request | 8 |
+| New Record/Request | 7 |
+| Open Record/Request | 133 |
+
+#### Commit Records/Requests (75)
+```
+  <Step enable="True" id="75" name="Commit Records/Requests">
+    <NoInteract state="True"/>
+    <Option state="False"/>
+    <ESSForceCommit state="False"/>
+  </Step>
+```
+
+#### Delete All Records (10)
+```
+  <Step enable="True" id="10" name="Delete All Records">
+    <NoInteract state="False"/>
+  </Step>
+```
+
+#### Delete Portal Row (104)
+```
+  <Step enable="True" id="104" name="Delete Portal Row">
+    <NoInteract state="False"/>
+  </Step>
+```
+
+#### Delete Record/Request (9)
+```
+  <Step enable="True" id="9" name="Delete Record/Request">
+    <NoInteract state="False"/>
+  </Step>
+```
+
+#### Export Records (36)
+```
+  <Step enable="True" id="36" name="Export Records">
+    <NoInteract state="True"/>
+    <CreateDirectories state="True"/>
+    <Restore state="False"/>
+    <AutoOpen state="False"/>
+    <CreateEmail state="False"/>
+  </Step>
+```
+
+#### Import Records (35)
+```
+  <Step enable="True" id="35" name="Import Records">
+    <NoInteract state="True"/>
+    <Restore state="False"/>
+    <VerifySSLCertificates state="False"/>
+  </Step>
+```
+
+#### Revert Record/Request (51)
+```
+  <Step enable="True" id="51" name="Revert Record/Request">
+    <NoInteract state="True"/>
+  </Step>
+```
+
+#### Save Records as Excel (143)
+```
+  <Step enable="True" id="143" name="Save Records as Excel">
+    <NoInteract state="True"/>
+    <CreateDirectories state="True"/>
+    <Restore state="False"/>
+    <AutoOpen state="False"/>
+    <CreateEmail state="False"/>
+    <SaveType value="BrowsedRecords"/>
+    <UseFieldNames state="False"/>
+  </Step>
+```
+
+#### Save Records as JSONL (225)
+```
+  <Step enable="True" id="225" name="Save Records as JSONL">
+    <Option state="False"/>
+    <CreateDirectories state="False"/>
+    <FineTuneFormat state="False"/>
+    <AutoOpen state="False"/>
+    <CreateEmail state="False"/>
+    <SaveAsJSONL/>
+  </Step>
+```
+
+#### Save Records as PDF (144)
+
+Now also part of the "PDF Files" category in FM 26 Script Workspace.
+See §8.15 (`steps-pdf.md`) for the related Create/Open/Append/Close/
+Cancel/Print PDF steps.
+
+Unconfigured (FM 26):
+```
+  <Step enable="True" id="144" name="Save Records as PDF">
+    <NoInteract state="True"/>
+    <Option state="False"/>
+    <CreateDirectories state="True"/>
+    <Restore state="False"/>
+    <AutoOpen state="False"/>
+    <CreateEmail state="False"/>
+    <PDFOptions source="RecordsBeingBrowsed">
+      <PDFSaveType>File</PDFSaveType>
+      <Document>
+        <Pages AllPages="True">
+          <NumberFrom>
+            <Calculation><![CDATA[1]]></Calculation>
+          </NumberFrom>
+          <PageRange>
+            <From>
+              <Calculation><![CDATA[1]]></Calculation>
+            </From>
+            <To>
+              <Calculation><![CDATA[1]]></Calculation>
+            </To>
+          </PageRange>
+        </Pages>
+      </Document>
+      <Security allowScreenReader="True" enableCopying="True" controlEditing="AnyExceptExtractingPages" controlPrinting="HighResolution" requireControlEditPassword="False" requireOpenPassword="False"/>
+      <View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage"/>
+    </PDFOptions>
+  </Step>
+```
+
+FM 26 adds `<PDFSaveType>` inside `<PDFOptions>` (all round-trip
+verified):
+
+| PDFSaveType | Save to mode | Target elements |
+|-------------|-------------|-----------------|
+| `File` | File path | `<UniversalPathList>` as Step child |
+| `Target` | Container field or variable | `<Text/>` + `<Field>` as Step children |
+| `Append` | Currently open PDF | No path/target elements; requires prior Create PDF or Open PDF |
+
+`<PDFOptions>` attributes (all round-trip verified):
+
+| Attribute | Values | Notes |
+|-----------|--------|-------|
+| `source` | `RecordsBeingBrowsed`, `CurrentRecord`, `BlankRecord` | |
+| `appearance` | `AsFormatted`, `WithBoxes`, `WithUnderlines`, `WithPlaceholderText` | BlankRecord only; absent for other source values |
+
+Configured with Specify options (round-trip verified):
+```
+  <Step enable="True" id="144" name="Save Records as PDF">
+    <NoInteract state="True"/>
+    <Option state="True"/>
+    <CreateDirectories state="True"/>
+    <Restore state="True"/>
+    <AutoOpen state="False"/>
+    <CreateEmail state="False"/>
+    <UniversalPathList>file:"filename.pdf"</UniversalPathList>
+    <Calculation><![CDATA[1]]></Calculation>
+    <PDFOptions source="RecordsBeingBrowsed">
+      <PDFSaveType>File</PDFSaveType>
+      <Document>
+        <Title>
+          <Calculation><![CDATA[title]]></Calculation>
+        </Title>
+        <Subject>
+          <Calculation><![CDATA[subject]]></Calculation>
+        </Subject>
+        <Author>
+          <Calculation><![CDATA[author]]></Calculation>
+        </Author>
+        <Keywords>
+          <Calculation><![CDATA[keywords]]></Calculation>
+        </Keywords>
+        <Pages AllPages="True">
+          <NumberFrom>
+            <Calculation><![CDATA[1]]></Calculation>
+          </NumberFrom>
+        </Pages>
+      </Document>
+      <Security allowScreenReader="True" enableCopying="True" controlEditing="InsertingDeletingRotatingPages" controlPrinting="LowResolution" requireControlEditPassword="True" requireOpenPassword="True">
+        <OpenPassword>
+          <Calculation><![CDATA[password]]></Calculation>
+        </OpenPassword>
+        <ControlPassword>
+          <Calculation><![CDATA[password]]></Calculation>
+        </ControlPassword>
+      </Security>
+      <View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage"/>
+    </PDFOptions>
+  </Step>
+```
+
+Notes:
+- Bare `<Calculation>` between `<UniversalPathList>` and `<PDFOptions>` appears when Restore is True with options configured.
+- `<PageRange>` drops out when configured with `AllPages="True"` and Restore.
+- When Append mode, Document and Initial View settings are ignored at runtime (but present in XML).
+
+#### Save Records as Snapshot Link (152)
+```
+  <Step enable="True" id="152" name="Save Records as Snapshot Link">
+    <CreateDirectories state="True"/>
+    <CreateEmail state="False"/>
+    <SaveType value="BrowsedRecords"/>
+  </Step>
+```
+
+#### Truncate Table (182)
+```
+  <Step enable="True" id="182" name="Truncate Table">
+    <NoInteract state="False"/>
+    <BaseTable id="-1" name="&lt;Current Table&gt;"/>
+  </Step>
+```
+
+---
+
+### 8.7 Found Sets
+
+All find-mode steps share a `<Query>` structure when configured. Each
+`<RequestRow>` represents one find request with operation
+`Include` (find) or `Exclude` (omit). Multiple `<Criteria>` elements
+within one RequestRow combine with AND; multiple RequestRows combine
+with OR.
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| Modify Last Find | 24 |
+| Omit Record | 25 |
+| Perform Quick Find | 150 |
+| Show All Records | 23 |
+| Show Omitted Only | 27 |
+
+#### Constrain Found Set (126)
+```
+  <Step enable="True" id="126" name="Constrain Found Set">
+    <Option state="False"/>
+    <Restore state="False"/>
+  </Step>
+```
+
+FM 26 adds "Find without indexes" option. In the XML this is
+`<Option state="True"/>` — the existing element toggled. No new
+element. May improve performance on small found sets with indexed
+criteria fields.
+
+With saved find criteria:
+```
+  <Step enable="True" id="126" name="Constrain Found Set">
+    <Option state="False"/>
+    <Restore state="True"/>
+    <Query>
+      <RequestRow operation="Include">
+        <Criteria>
+          <Field table="TableOccurrence" id="N" name="field_name"/>
+          <Text>=</Text>
+        </Criteria>
+      </RequestRow>
+    </Query>
+  </Step>
+```
+
+The `<Text>` element holds the find criterion exactly as typed in find
+mode (`=` for exact-empty, `>100`, `Jones`, `//` for today, etc.).
+
+#### Extend Found Set (127)
+```
+  <Step enable="True" id="127" name="Extend Found Set">
+    <Restore state="False"/>
+  </Step>
+```
+
+#### Find Matching Records (155)
+```
+  <Step enable="True" id="155" name="Find Matching Records">
+    <FindMatchingRecordsByField value="FindMatchingReplace"/>
+  </Step>
+```
+
+#### Omit Multiple Records (26)
+```
+  <Step enable="True" id="26" name="Omit Multiple Records">
+    <NoInteract state="True"/>
+  </Step>
+```
+
+#### Perform Find (28)
+```
+  <Step enable="True" id="28" name="Perform Find">
+    <Restore state="False"/>
+  </Step>
+```
+
+With saved find criteria, the structure matches Constrain Found Set —
+a `<Query>` containing one or more `<RequestRow>` elements. Multiple
+`<Criteria>` within a single RequestRow combine with AND:
+```
+  <Step enable="True" id="28" name="Perform Find">
+    <Restore state="True"/>
+    <Query>
+      <RequestRow operation="Include">
+        <Criteria>
+          <Field table="TableOccurrence" id="N" name="field_a"/>
+          <Text>==$variable</Text>
+        </Criteria>
+        <Criteria>
+          <Field table="TableOccurrence" id="N" name="field_b"/>
+          <Text>*</Text>
+        </Criteria>
+      </RequestRow>
+    </Query>
+  </Step>
+```
+
+The `<Text>` element holds the find criterion as typed in find mode.
+Common values: `*` (non-empty), `=` (empty), `==value` (exact match),
+`//` (today), `>=value` (range). Comparison operators must be XML-
+escaped inside `<Text>`: `>` becomes `&gt;`, `<` becomes `&lt;`,
+`&` becomes `&amp;`. For example, `>=$earliest_date` is encoded as
+`&gt;=$earliest_date`.
+
+#### Sort Records (39)
+```
+  <Step enable="True" id="39" name="Sort Records">
+    <NoInteract state="True"/>
+    <Restore state="False"/>
+  </Step>
+```
+
+With a saved sort order, adds a `<SortList>` element. Each sort key
+is a `<Sort>` element wrapping a `<PrimaryField>` which holds the
+structured `<Field>` reference. Sort direction is the `type` attribute
+on `<Sort>`. Multiple sort keys appear as multiple `<Sort>` elements
+in priority order.
+```
+  <Step enable="True" id="39" name="Sort Records">
+    <NoInteract state="True"/>
+    <Restore state="True"/>
+    <SortList Maintain="True" value="True">
+      <Sort type="Ascending">
+        <PrimaryField>
+          <Field table="TableOccurrence" id="N" name="field_a"/>
+        </PrimaryField>
+      </Sort>
+      <Sort type="Ascending">
+        <PrimaryField>
+          <Field table="TableOccurrence" id="N" name="field_b"/>
+        </PrimaryField>
+      </Sort>
+    </SortList>
+  </Step>
+```
+
+`<SortList>` attributes:
+
+- `Maintain="True|False"` — corresponds to "Keep records in sorted
+  order" in the dialog
+- `value="True"` — meaning not yet established; observed as `True` in
+  configured sorts
+
+`<Sort>` `type` attribute observed values: `Ascending`. Other expected
+values (`Descending`, custom value list ordering) have not yet been
+round-tripped. The `<PrimaryField>` wrapper name suggests `<Sort>`
+may also accept other child elements for value-list-based or
+calculation-based sort keys; the structure for those is not yet
+documented.
+
+#### Sort Records by Field (154)
+```
+  <Step enable="True" id="154" name="Sort Records by Field">
+    <SortRecordsByField value="SortAscending"/>
+  </Step>
+```
+
+#### Unsort Records (21)
+```
+  <Step enable="True" id="21" name="Unsort Records"/>
+```
+
+---
+
diff --git a/docs/filemaker-xml-canonical/skill/references/steps-navigation-editing.md b/docs/filemaker-xml-canonical/skill/references/steps-navigation-editing.md
new file mode 100644
index 0000000..b3979e8
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/references/steps-navigation-editing.md
@@ -0,0 +1,292 @@
+# Step Reference — Navigation and Editing (§8.3–8.4)
+
+Part of the Canonical XML Format for FileMaker Script Steps, v1.12.
+Read `core.md` first: the paste format requirements, conventions and
+silent failure modes there apply to every step below.
+
+### 8.3 Navigation
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| Close Popover | 169 |
+| Go to Next Field | 4 |
+| Go to Previous Field | 5 |
+
+#### Enter Browse Mode (55)
+```
+  <Step enable="True" id="55" name="Enter Browse Mode">
+    <Pause state="False"/>
+  </Step>
+```
+
+#### Enter Find Mode (22)
+```
+  <Step enable="True" id="22" name="Enter Find Mode">
+    <Pause state="True"/>
+    <Restore state="False"/>
+  </Step>
+```
+
+#### Enter Preview Mode (41)
+```
+  <Step enable="True" id="41" name="Enter Preview Mode">
+    <Pause state="False"/>
+  </Step>
+```
+
+#### Go to Field (17)
+```
+  <Step enable="True" id="17" name="Go to Field">
+    <SelectAll state="False"/>
+  </Step>
+```
+
+With a target field, adds the structured `<Field>` reference:
+```
+  <Step enable="True" id="17" name="Go to Field">
+    <SelectAll state="False"/>
+    <Field table="TableOccurrence" id="N" name="field_name"/>
+  </Step>
+```
+
+#### Go to Layout (6)
+```
+  <Step enable="True" id="6" name="Go to Layout">
+    <LayoutDestination value="OriginalLayout"/>
+  </Step>
+```
+
+With a specific layout:
+```
+  <Step enable="True" id="6" name="Go to Layout">
+    <LayoutDestination value="SelectedLayout"/>
+    <Layout id="N" name="layout name"/>
+  </Step>
+```
+
+#### Go to List of Records (228)
+```
+  <Step enable="True" id="228" name="Go to List of Records">
+    <ShowInNewWindow state="False"/>
+    <LayoutDestination value="CurrentLayout"/>
+    <NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="3606018"/>
+  </Step>
+```
+
+#### Go to Object (145)
+```
+  <Step enable="True" id="145" name="Go to Object"/>
+```
+
+With object name:
+```
+  <Step enable="True" id="145" name="Go to Object">
+    <ObjectName>
+      <Calculation><![CDATA["object name"]]></Calculation>
+    </ObjectName>
+  </Step>
+```
+
+#### Go to Portal Row (99)
+```
+  <Step enable="True" id="99" name="Go to Portal Row">
+    <NoInteract state="False"/>
+    <SelectAll state="False"/>
+    <RowPageLocation value="First"/>
+  </Step>
+```
+
+`<RowPageLocation>` enumeration matches Go to Record/Request/Page:
+`First`, `Next`, `Previous`, `Last`, `ByCalculation`. For
+`ByCalculation`, add a `<Calculation>` child:
+```
+  <Step enable="True" id="99" name="Go to Portal Row">
+    <NoInteract state="True"/>
+    <SelectAll state="True"/>
+    <RowPageLocation value="ByCalculation"/>
+    <Calculation><![CDATA[$loop_counter]]></Calculation>
+  </Step>
+```
+
+#### Go to Record/Request/Page (16)
+```
+  <Step enable="True" id="16" name="Go to Record/Request/Page">
+    <NoInteract state="False"/>
+    <RowPageLocation value="First"/>
+  </Step>
+```
+
+`<RowPageLocation value="...">` enumeration: `First`, `Next`,
+`Previous`, `Last`, `ByCalculation`. For `Next`, an optional
+`<Exit state="True"/>` element before `<RowPageLocation>` indicates
+"Exit after last". For `ByCalculation`, add a `<Calculation>` child.
+
+#### Go to Related Record (74)
+
+Element order is fixed: `Option` → `MatchAllRecords` →
+`ShowInNewWindow` → `Restore` → `LayoutDestination` → optional
+`Name` → optional dimensions → `NewWndStyles` → `Table` → `Layout`.
+
+`<NewWndStyles>` is always present, regardless of new-window state.
+
+Element semantics — verified by round-trip against production scripts:
+
+- `<Option state="True|False"/>` — "Show only related records" in the
+  GTRR dialog. `True` constrains the destination found set to the
+  related set; `False` shows all records on the destination layout.
+  This is the most consequential GTRR option and the most commonly
+  set; the default in the dialog is `True` for new GTRR steps in most
+  production contexts but `False` in the unconfigured XML emission.
+  Generators that omit this element or set it incorrectly will
+  silently produce the wrong found-set behaviour at runtime — the
+  step pastes and runs, just on the wrong record set.
+- `<MatchAllRecords state="True|False"/>` — "Match found set" in the
+  dialog. `True` matches against the entire found set on the source
+  side; `False` matches only the current record. Almost always
+  `False` in practice.
+- `<ShowInNewWindow state="True|False"/>` — controls the new-window
+  branch. When `True`, the optional `<n>` (window-name calculation)
+  and dimension elements may appear before `<NewWndStyles>`.
+- `<Restore state="True|False"/>` — restore saved sort/find settings
+  attached to the GTRR step. Maps to whether the step has a stored
+  sort order or find criteria from the dialog. Almost always `True`
+  in configured GTRRs even when no specific settings are saved.
+
+**Basic form** — existing window, no custom dimensions:
+```
+  <Step enable="True" id="74" name="Go to Related Record">
+    <Option state="False"/>
+    <MatchAllRecords state="False"/>
+    <ShowInNewWindow state="False"/>
+    <Restore state="True"/>
+    <LayoutDestination value="SelectedLayout"/>
+    <NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="983554"/>
+    <Table id="N" name="table occurrence name"/>
+    <Layout id="N" name="layout name"/>
+  </Step>
+```
+
+**New window** — adds `<Name>` with calculation between
+`<LayoutDestination>` and `<NewWndStyles>`:
+```
+    <ShowInNewWindow state="True"/>
+    <Restore state="True"/>
+    <LayoutDestination value="SelectedLayout"/>
+    <Name>
+      <Calculation><![CDATA["window name"]]></Calculation>
+    </Name>
+    <NewWndStyles .../>
+```
+
+**Custom dimensions** — adds dimension elements between optional
+`<Name>` and `<NewWndStyles>`. Dimensions are independent of new-window
+state:
+```
+    <Height>
+      <Calculation><![CDATA[400]]></Calculation>
+    </Height>
+    <Width>
+      <Calculation><![CDATA[400]]></Calculation>
+    </Width>
+    <DistanceFromTop>
+      <Calculation><![CDATA[400]]></Calculation>
+    </DistanceFromTop>
+    <DistanceFromLeft>
+      <Calculation><![CDATA[400]]></Calculation>
+    </DistanceFromLeft>
+    <NewWndStyles .../>
+```
+
+**Unconfigured GTRR** (no table set):
+```
+  <Step enable="True" id="74" name="Go to Related Record">
+    <Option state="False"/>
+    <MatchAllRecords state="False"/>
+    <ShowInNewWindow state="False"/>
+    <Restore state="False"/>
+    <LayoutDestination value="CurrentLayout"/>
+    <NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="3606018"/>
+    <Table id="0" name=""/>
+  </Step>
+```
+
+---
+
+### 8.4 Editing
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| Select All | 50 |
+| Set Selection | 130 |
+
+#### Clear (49)
+```
+  <Step enable="True" id="49" name="Clear">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Copy (47)
+```
+  <Step enable="True" id="47" name="Copy">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Cut (46)
+```
+  <Step enable="True" id="46" name="Cut">
+    <SelectAll state="True"/>
+  </Step>
+```
+
+#### Paste (48)
+```
+  <Step enable="True" id="48" name="Paste">
+    <NoStyle state="True"/>
+    <SelectAll state="True"/>
+    <LinkAvail state="False"/>
+  </Step>
+```
+
+#### Perform Find/Replace (128)
+```
+  <Step enable="True" id="128" name="Perform Find/Replace">
+    <NoInteract state="False"/>
+    <FindReplaceOperation MatchWholeWords="False" MatchCase="False" WithinOptions="All" AcrossOptions="All" direction="Forward" type="FindNext"/>
+  </Step>
+```
+
+#### Undo/Redo (45)
+```
+  <Step enable="True" id="45" name="Undo/Redo">
+    <UndoRedo value="Undo"/>
+  </Step>
+```
+
+---
+
diff --git a/docs/filemaker-xml-canonical/skill/references/steps-pdf.md b/docs/filemaker-xml-canonical/skill/references/steps-pdf.md
new file mode 100644
index 0000000..395122e
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/references/steps-pdf.md
@@ -0,0 +1,296 @@
+# Step Reference — PDF Files (§8.15)
+
+Part of the Canonical XML Format for FileMaker Script Steps, v1.12.
+Read `core.md` first: the paste format requirements, conventions and
+silent failure modes there apply to every step below.
+
+### 8.15 PDF Files
+
+New in FileMaker 2026. These steps provide a scriptable PDF assembly
+workflow: create or open a PDF in memory, add pages from layouts or
+existing PDFs, then save or discard.
+
+Only one PDF can be open at a time. The in-memory PDF persists until
+closed by Close PDF or discarded by Cancel PDF. Unsaved changes are
+lost if the client session ends or the file that opened the PDF
+closes.
+
+Save Records as PDF (144) is also part of this category in FM 26 and
+can target the currently open PDF via `<PDFSaveType>`. See §8.6 for
+its skeleton; FM 26 changes are noted in §8.6.
+
+#### Create PDF (243)
+
+Creates an empty PDF in memory. Configure document properties,
+security, and initial view via Specify options (same PDF Options
+dialog structure as Save Records as PDF).
+
+Error 833 if a PDF is already open.
+
+Unconfigured:
+```
+  <Step enable="True" id="243" name="Create PDF">
+    <Restore state="False"/>
+    <CreatePDFFile>
+      <Document>
+        <Pages AllPages="True">
+          <NumberFrom>
+            <Calculation><![CDATA[1]]></Calculation>
+          </NumberFrom>
+          <PageRange>
+            <From>
+              <Calculation><![CDATA[1]]></Calculation>
+            </From>
+            <To>
+              <Calculation><![CDATA[1]]></Calculation>
+            </To>
+          </PageRange>
+        </Pages>
+      </Document>
+      <Security allowScreenReader="True" enableCopying="True" controlEditing="AnyExceptExtractingPages" controlPrinting="HighResolution" requireControlEditPassword="False" requireOpenPassword="False"/>
+      <View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage"/>
+    </CreatePDFFile>
+  </Step>
+```
+
+Configured with Specify options (round-trip verified):
+```
+  <Step enable="True" id="243" name="Create PDF">
+    <Restore state="True"/>
+    <Calculation><![CDATA[1]]></Calculation>
+    <CreatePDFFile>
+      <Document>
+        <Title>
+          <Calculation><![CDATA[title expression]]></Calculation>
+        </Title>
+        <Subject>
+          <Calculation><![CDATA[subject expression]]></Calculation>
+        </Subject>
+        <Author>
+          <Calculation><![CDATA[author expression]]></Calculation>
+        </Author>
+        <Keywords>
+          <Calculation><![CDATA[keywords expression]]></Calculation>
+        </Keywords>
+        <Pages AllPages="True">
+          <NumberFrom>
+            <Calculation><![CDATA[1]]></Calculation>
+          </NumberFrom>
+        </Pages>
+      </Document>
+      <Security allowScreenReader="True" enableCopying="True" controlEditing="InsertingDeletingRotatingPages" controlPrinting="LowResolution" requireControlEditPassword="True" requireOpenPassword="True">
+        <OpenPassword>
+          <Calculation><![CDATA[password expression]]></Calculation>
+        </OpenPassword>
+        <ControlPassword>
+          <Calculation><![CDATA[password expression]]></Calculation>
+        </ControlPassword>
+      </Security>
+      <View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage"/>
+    </CreatePDFFile>
+  </Step>
+```
+
+Notes:
+- `<Restore state="True"/>` when Specify options is configured.
+- Bare `<Calculation>` between `<Restore>` and `<CreatePDFFile>` — appears when Restore is True. Purpose not confirmed; observed in both Create PDF and Save Records as PDF.
+- `<PageRange>` drops out when `AllPages="True"` with Restore configured.
+- `<CreatePDFFile>` wraps the same Document/Security/View structure as `<PDFOptions>` in Save Records as PDF.
+- `controlEditing` values: `AnyExceptExtractingPages`, `InsertingDeletingRotatingPages`.
+- `controlPrinting` values: `HighResolution`, `LowResolution`.
+- `<OpenPassword>` and `<ControlPassword>` are children of `<Security>`, not `<Document>`.
+
+#### Open PDF (246)
+
+Opens an existing PDF file in memory for modification.
+
+Options: `From` (File or Source), `Source file` (file path) or
+`Source` (container/variable), `Password` for encrypted PDFs.
+
+Errors: 831 (invalid password), 833 (PDF already open).
+WebDirect: From: File not supported.
+
+Unconfigured:
+```
+  <Step enable="True" id="246" name="Open PDF">
+    <Option state="False"/>
+    <OpenPDFFile>
+      <PDFSaveType>File</PDFSaveType>
+    </OpenPDFFile>
+  </Step>
+```
+
+Configured with file path and password (round-trip verified):
+```
+  <Step enable="True" id="246" name="Open PDF">
+    <Option state="True"/>
+    <UniversalPathList>$variable_or_path</UniversalPathList>
+    <OpenPDFFile>
+      <PDFSaveType>File</PDFSaveType>
+      <OpenPassword>
+        <Calculation><![CDATA[password expression]]></Calculation>
+      </OpenPassword>
+    </OpenPDFFile>
+  </Step>
+```
+
+Notes:
+- `<Option state="True"/>` when From is configured.
+- `<UniversalPathList>` is a direct `<Step>` child, not inside `<OpenPDFFile>`. File paths can use `image:` prefix or be a bare variable name.
+- `<PDFSaveType>` maps to the From option. Observed value: `File`.
+- `<OpenPassword>` is inside `<OpenPDFFile>`, with a Calculation child.
+- Element order: `Option` → `UniversalPathList` → `OpenPDFFile` (containing `PDFSaveType` → `OpenPassword`).
+
+#### Append PDF (244)
+
+Appends all pages from a source PDF to the currently open in-memory
+PDF. The source PDF is not modified.
+
+Options: `From` (File or Source), `Source file` (file path) or
+`Source` (container/variable), `Password` for encrypted source PDFs.
+
+Error 829 if no PDF is open. Error 831 if password is wrong.
+
+Unconfigured:
+```
+  <Step enable="True" id="244" name="Append PDF">
+    <Option state="False"/>
+    <AppendPDFFile>
+      <PDFSaveType>File</PDFSaveType>
+    </AppendPDFFile>
+  </Step>
+```
+
+Configured with file path and password (round-trip verified):
+```
+  <Step enable="True" id="244" name="Append PDF">
+    <Option state="True"/>
+    <UniversalPathList>image:../path/to/file.pdf</UniversalPathList>
+    <AppendPDFFile>
+      <PDFSaveType>File</PDFSaveType>
+      <OpenPassword>
+        <Calculation><![CDATA[password expression]]></Calculation>
+      </OpenPassword>
+    </AppendPDFFile>
+  </Step>
+```
+
+Notes:
+- Identical structure to Open PDF. Same element order, same `<OpenPassword>` inside the wrapper.
+- Source PDF file paths use `image:` prefix (reads an existing file), unlike Close PDF which uses `file:` prefix (writes a file).
+
+#### Print PDF (242)
+
+Prints a PDF directly from a file path, container, or variable
+without displaying it on a layout.
+
+Options: `From` (File or Source), `Source file` / `Source`,
+`Password`, `With dialog`, `Specify print options` (Restore),
+`Save print options to` (container/variable),
+`Use print options from` (container/variable).
+
+Errors: 605 (empty container), 606 (not a PDF), 607 (wrong password),
+608 (security prevents printing).
+
+Not supported on Server, Cloud, Data API, or CWP.
+
+Unconfigured:
+```
+  <Step enable="True" id="242" name="Print PDF">
+    <NoInteract state="True"/>
+    <Option state="False"/>
+    <UsePrintOptionsFromEnabled state="False"/>
+    <SavePrintOptionsToEnabled state="False"/>
+    <Restore state="False"/>
+  </Step>
+```
+
+Configured (round-trip verified). Structure shown with print settings
+blobs omitted for clarity:
+```
+  <Step enable="True" id="242" name="Print PDF">
+    <NoInteract state="True"/>
+    <Option state="True"/>
+    <UsePrintOptionsFromEnabled state="False"/>
+    <SavePrintOptionsToEnabled state="True"/>
+    <Restore state="True"/>
+    <Text/>
+    <Field table="TableOccurrence" id="N" name="field_name"/>
+    <PrintSettings PageNumberingOffset="0" PrintToFile="False" ToPage="1" FromPage="1" AllPages="False" collated="True" NumCopies="1" PrintType="BrowsedRecords">
+      <PlatformData PlatformType="PrNm"><![CDATA[...hex...]]></PlatformData>
+      <PlatformData PlatformType="M_PM"><![CDATA[...hex...]]></PlatformData>
+      <PlatformData PlatformType="M_PD"><![CDATA[...hex...]]></PlatformData>
+      <PlatformData PlatformType="MMod"><![CDATA[...hex...]]></PlatformData>
+      <SavePrintOptionsTo>
+        <Field>$variable</Field>
+      </SavePrintOptionsTo>
+      <Password>
+        <Calculation><![CDATA[password expression]]></Calculation>
+      </Password>
+      <SaveType>File</SaveType>
+    </PrintSettings>
+  </Step>
+```
+
+Notes:
+- `<PrintSettings>` contains opaque `<PlatformData>` blobs (hex-encoded macOS print plist). Generators should not produce these; they are captured from the Print dialog.
+- `<SavePrintOptionsTo>` wraps a `<Field>` element. Variable targets use plain text: `<Field>$variable</Field>`.
+- Password is `<Password>` (not `<OpenPassword>`), inside `<PrintSettings>`.
+- `<SaveType>` inside `<PrintSettings>`: observed values `File`, `Source`.
+- `<Text/>` may appear as an empty element when From is Source mode.
+- Element order at Step level: `NoInteract` → `Option` → `UsePrintOptionsFromEnabled` → `SavePrintOptionsToEnabled` → `Restore` → `Text` → `Field` → `PrintSettings`.
+
+#### Close PDF (245)
+
+Closes the in-memory PDF and saves it to a destination.
+
+Options: `Save to` (File or Target).
+For File: output file path, `Automatically open file`,
+`Create email with file as attachment`, `Create folders`.
+For Target: container field or variable, optional `Filename`.
+
+Error 5 if no PDF is open. Overwrites existing files without error.
+WebDirect: Save to File not supported.
+
+Unconfigured:
+```
+  <Step enable="True" id="245" name="Close PDF">
+    <CreateDirectories state="False"/>
+    <AutoOpen state="False"/>
+    <CreateEmail state="False"/>
+    <ClosePDFFile>
+      <PDFSaveType>File</PDFSaveType>
+    </ClosePDFFile>
+  </Step>
+```
+
+Configured with file path (round-trip verified):
+```
+  <Step enable="True" id="245" name="Close PDF">
+    <CreateDirectories state="False"/>
+    <AutoOpen state="True"/>
+    <CreateEmail state="True"/>
+    <UniversalPathList>file:"filename.pdf"</UniversalPathList>
+    <ClosePDFFile>
+      <PDFSaveType>File</PDFSaveType>
+    </ClosePDFFile>
+  </Step>
+```
+
+Notes:
+- `<UniversalPathList>` is a direct `<Step>` child. File output paths use `file:` prefix.
+- `<CreateDirectories>`, `<AutoOpen>`, `<CreateEmail>` are File-mode options.
+- Element order: `CreateDirectories` → `AutoOpen` → `CreateEmail` → `UniversalPathList` → `ClosePDFFile`.
+
+#### Cancel PDF (247)
+
+Discards the in-memory PDF without saving. No options.
+
+```
+  <Step enable="True" id="247" name="Cancel PDF"/>
+```
+
+Self-closing, no children. No configured variant. Round-trip
+verified.
+
+---
diff --git a/docs/filemaker-xml-canonical/skill/references/steps-plugin.md b/docs/filemaker-xml-canonical/skill/references/steps-plugin.md
new file mode 100644
index 0000000..1ce6e2a
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/references/steps-plugin.md
@@ -0,0 +1,103 @@
+# Step Reference — Plugin Steps (§9)
+
+Part of the Canonical XML Format for FileMaker Script Steps, v1.12.
+Read `core.md` first: the paste format requirements, conventions and
+silent failure modes there apply to every step below.
+
+## 9. Plugin steps
+
+Plugin steps have a distinct structure. The `<Step>` tag carries
+`index` and `Source` attributes, and the body splits into a
+`<PluginStep>` declaration (describing the plugin's parameter shape)
+followed by `<ParameterValues>` containing indexed `<Object>` children
+that hold the actual calculations.
+
+### 9.1 MBS (186) — Monkeybread Plugin
+
+`Source="MBSP"` identifies the plugin. `index="N"` is FileMaker's
+internal plugin registration index, which is file-specific.
+
+```
+  <Step index="2" Source="MBSP" enable="True" id="186" name="MBS">
+    <PluginStep>
+      <Parameter ShowInLine="true" Label="Destination" Type="target"/>
+      <Parameter ID="0" Label="Function" ShowInline="true" DataType="text" Type="calc"/>
+      <Parameter ID="1" Label="P1" ShowInline="true" DataType="text" Type="calc"/>
+      <Parameter ID="2" Label="P2" ShowInline="true" DataType="text" Type="calc"/>
+      <Parameter ID="3" Label="P3" ShowInline="true" DataType="text" Type="calc"/>
+      <Parameter ID="4" Label="P4" ShowInline="true" DataType="text" Type="calc"/>
+      <Parameter ID="5" Label="P5" ShowInline="false" DataType="text" Type="calc"/>
+      <Parameter ID="6" Label="P6" ShowInline="false" DataType="text" Type="calc"/>
+      <Parameter ID="7" Label="P7" ShowInline="false" DataType="text" Type="calc"/>
+      <Parameter ID="8" Label="P8" ShowInline="false" DataType="text" Type="calc"/>
+      <Parameter ID="9" Label="P9" ShowInline="false" DataType="text" Type="calc"/>
+    </PluginStep>
+    <SelectAll state="True"/>
+    <Field/>
+    <ParameterValues>
+      <Object index="0" type="Calc">
+        <Calculation><![CDATA[]]></Calculation>
+      </Object>
+      <Object index="1" type="Calc">
+        <Calculation><![CDATA[]]></Calculation>
+      </Object>
+      <Object index="2" type="Calc">
+        <Calculation><![CDATA[]]></Calculation>
+      </Object>
+      <Object index="3" type="Calc">
+        <Calculation><![CDATA[]]></Calculation>
+      </Object>
+      <Object index="4" type="Calc">
+        <Calculation><![CDATA[]]></Calculation>
+      </Object>
+      <Object index="5" type="Calc">
+        <Calculation><![CDATA[]]></Calculation>
+      </Object>
+      <Object index="6" type="Calc">
+        <Calculation><![CDATA[]]></Calculation>
+      </Object>
+      <Object index="7" type="Calc">
+        <Calculation><![CDATA[]]></Calculation>
+      </Object>
+      <Object index="8" type="Calc">
+        <Calculation><![CDATA[]]></Calculation>
+      </Object>
+      <Object index="9" type="Calc">
+        <Calculation><![CDATA[]]></Calculation>
+      </Object>
+    </ParameterValues>
+  </Step>
+```
+
+Parameter slots:
+
+- Index 0 holds the MBS function name (for example,
+  `"WebView.RunJavaScript"`).
+- Indices 1 through 9 hold function arguments P1 through P9.
+- `<Field/>` is the destination target. It is empty when the result is
+  assigned to a variable, and populated with
+  `<Field table="X" id="N" name="y"/>` when the result is written to
+  a field.
+- `<SelectAll state="True"/>` controls whether the step replaces the
+  entire field when the destination is a field.
+
+When generating MBS steps, the `index` and `Source` attributes on
+`<Step>` are required, and the full `<PluginStep>` declaration with
+all ten parameter entries must be present even when most slots are
+empty. Populated `<Object>` children contain the CDATA calculation for
+the corresponding slot.
+
+**Cross-file paste behaviour.** When MBS XML is pasted into a file
+*without* the MBS plugin installed, FileMaker preserves both the
+`Source` and `index` attributes verbatim and renders the step as a
+"missing plug-in" placeholder displaying the source identifier and
+index value (e.g. `<Unknown external script step from missing plug-in
+( MBSP 0 )>`). Both attributes are retained even when the index is
+implausible (`index="0"`, `index="999"`). Whether the `index`
+attribute must match the recipient file's plugin registration order
+when MBS *is* installed has not been verified — the structural form
+is preserved either way, but the step's resolution to a working MBS
+function is conditional on the plugin's presence and registration
+state.
+
+---
diff --git a/docs/filemaker-xml-canonical/skill/references/steps-windows-files.md b/docs/filemaker-xml-canonical/skill/references/steps-windows-files.md
new file mode 100644
index 0000000..1c4f972
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/references/steps-windows-files.md
@@ -0,0 +1,351 @@
+# Step Reference — Windows and Files (§8.8–8.9)
+
+Part of the Canonical XML Format for FileMaker Script Steps, v1.12.
+Read `core.md` first: the paste format requirements, conventions and
+silent failure modes there apply to every step below.
+
+### 8.8 Windows
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| Freeze Window | 79 |
+
+#### Adjust Window (31)
+```
+  <Step enable="True" id="31" name="Adjust Window">
+    <WindowState value="ResizeToFit"/>
+  </Step>
+```
+
+#### Arrange All Windows (120)
+```
+  <Step enable="True" id="120" name="Arrange All Windows">
+    <WindowArrangement value="TileHorizontally"/>
+  </Step>
+```
+
+#### Close Window (121)
+```
+  <Step enable="True" id="121" name="Close Window">
+    <LimitToWindowsOfCurrentFile state="True"/>
+    <Window value="Current"/>
+  </Step>
+```
+
+Close by name:
+```
+  <Step enable="True" id="121" name="Close Window">
+    <LimitToWindowsOfCurrentFile state="True"/>
+    <Window value="ByName"/>
+    <Name>
+      <Calculation><![CDATA["window name"]]></Calculation>
+    </Name>
+  </Step>
+```
+
+`<Window>` enumeration: `Current`, `ByName`.
+
+#### Move/Resize Window (119)
+```
+  <Step enable="True" id="119" name="Move/Resize Window">
+    <LimitToWindowsOfCurrentFile state="True"/>
+    <Window value="Current"/>
+  </Step>
+```
+
+#### New Window (122)
+
+Default minimal:
+```
+  <Step enable="True" id="122" name="New Window">
+    <LayoutDestination value="CurrentLayout"/>
+    <NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="3606018"/>
+  </Step>
+```
+
+Configured with window name, target layout, and extended window-style
+options:
+```
+  <Step enable="True" id="122" name="New Window">
+    <LayoutDestination value="SelectedLayout"/>
+    <Name>
+      <Calculation><![CDATA["window name"]]></Calculation>
+    </Name>
+    <NewWndStyles DimParentWindow="No" Toolbars="Yes" MenuBar="Yes" Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="1076299266"/>
+    <Layout id="N" name="layout name"/>
+  </Step>
+```
+
+`<NewWndStyles>` may carry additional attributes when window options
+are configured: `DimParentWindow`, `Toolbars`, `MenuBar` are all
+optional and appear when set in the dialog. The `Styles` numeric value
+also changes when these options are toggled. See Appendix A.
+
+#### Refresh Window (80)
+```
+  <Step enable="True" id="80" name="Refresh Window">
+    <Option state="False"/>
+    <FlushSQLData state="False"/>
+  </Step>
+```
+
+#### Scroll Window (81)
+```
+  <Step enable="True" id="81" name="Scroll Window">
+    <ScrollOperation value="Home"/>
+  </Step>
+```
+
+#### Select Window (123)
+```
+  <Step enable="True" id="123" name="Select Window">
+    <LimitToWindowsOfCurrentFile state="True"/>
+    <Window value="Current"/>
+  </Step>
+```
+
+#### Set Window Title (124)
+```
+  <Step enable="True" id="124" name="Set Window Title">
+    <LimitToWindowsOfCurrentFile state="True"/>
+    <Window value="Current"/>
+  </Step>
+```
+
+#### Set Zoom Level (97)
+```
+  <Step enable="True" id="97" name="Set Zoom Level">
+    <Lock state="False"/>
+    <Zoom value="100"/>
+  </Step>
+```
+
+FM 26 Custom calculation (round-trip verified):
+```
+  <Step enable="True" id="97" name="Set Zoom Level">
+    <Lock state="False"/>
+    <Zoom value="ByCalculation"/>
+    <Calculation><![CDATA[zoom percentage expression]]></Calculation>
+  </Step>
+```
+
+`<Zoom>` enumeration: `100`, `75`, `50`, `25`, `150`, `200`, `300`,
+`400`, `ByCalculation`. Custom takes an integer from 25 to 400.
+
+#### Show/Hide Menubar (166)
+```
+  <Step enable="True" id="166" name="Show/Hide Menubar">
+    <Lock state="False"/>
+    <ShowHide value="Hide"/>
+  </Step>
+```
+
+#### Show/Hide Text Ruler (92)
+```
+  <Step enable="True" id="92" name="Show/Hide Text Ruler">
+    <ShowHide value="Show"/>
+  </Step>
+```
+
+#### Show/Hide Toolbars (29)
+```
+  <Step enable="True" id="29" name="Show/Hide Toolbars">
+    <IncludeEditRecordToolbar state="True"/>
+    <Lock state="False"/>
+    <ShowHide value="Hide"/>
+  </Step>
+```
+
+#### View As (30)
+```
+  <Step enable="True" id="30" name="View As">
+    <View value="Cycle"/>
+  </Step>
+```
+
+---
+
+### 8.9 Files
+
+#### No-option steps
+
+Each step in this table takes no options. The canonical form
+for every one of them is the single self-closing line:
+
+```
+  <Step enable="True" id="NN" name="Step Name"/>
+```
+
+with `id` and `name` exactly as listed (names are verbatim,
+including any spacing):
+
+| Step | id |
+|---|---|
+| Close Data File | 196 |
+| Close File | 34 |
+| Delete File | 197 |
+| Get File Exists | 188 |
+| Get Data File Position | 194 |
+| Get File Size | 189 |
+| New File | 82 |
+| Open Data File | 191 |
+| Rename File | 199 |
+| Set Data File Position | 195 |
+
+#### Convert File (139)
+```
+  <Step enable="True" id="139" name="Convert File">
+    <NoInteract state="False"/>
+    <Option state="False"/>
+    <SkipIndexes state="False"/>
+    <VerifySSLCertificates state="False"/>
+  </Step>
+```
+
+#### Create Data File (190)
+```
+  <Step enable="True" id="190" name="Create Data File">
+    <CreateDirectories state="True"/>
+  </Step>
+```
+
+#### Open File (33)
+```
+  <Step enable="True" id="33" name="Open File">
+    <Option state="False"/>
+  </Step>
+```
+
+#### Print (43)
+```
+  <Step enable="True" id="43" name="Print">
+    <NoInteract state="True"/>
+    <Restore state="False"/>
+  </Step>
+```
+
+#### Print Setup (42)
+```
+  <Step enable="True" id="42" name="Print Setup">
+    <NoInteract state="True"/>
+    <Restore state="False"/>
+  </Step>
+```
+
+#### Read from Data File (193)
+```
+  <Step enable="True" id="193" name="Read from Data File">
+    <DataSourceType value="3"/>
+  </Step>
+```
+
+#### Recover File (95)
+```
+  <Step enable="True" id="95" name="Recover File">
+    <NoInteract state="True"/>
+  </Step>
+```
+
+#### Save a Copy as (37)
+```
+  <Step enable="True" id="37" name="Save a Copy as">
+    <CreateDirectories state="True"/>
+    <AutoOpen state="False"/>
+    <CreateEmail state="False"/>
+    <SaveAsType value="Copy"/>
+  </Step>
+```
+
+#### Save a Copy as XML (3)
+
+v1.11 skeleton (pre-FM 26):
+```
+  <Step enable="True" id="3" name="Save a Copy as XML">
+    <Option state="False"/>
+  </Step>
+```
+
+FM 26 expanded (from native Copy output):
+```
+  <Step enable="True" id="3" name="Save a Copy as XML">
+    <Option state="False"/>
+    <OutputEntireBinaryData state="False"/>
+    <SpecifyJSONOptions state="False"/>
+    <SaXML>
+      <JSONOptions>
+        <Calculation><![CDATA[JSONSetElement ( "{}" ;
+  [ "catalogs_included" ; JSONMakeArray (
+  "PersistentStoreCatalog
+  BaseDirectoryCatalog
+  FileAccessCatalog
+  ExternalDataSourceCatalog
+  BaseTableCatalog
+  TableOccurrenceCatalog
+  CustomFunctionsCatalog
+  ValueListCatalog
+  FieldCatalog
+  RelationshipCatalog
+  CustomMenuCatalog
+  CustomMenuSetCatalog
+  ScriptCatalog
+  ThemeCatalog
+  LayoutCatalog
+  LibraryCatalog
+  PrivilegeSetsCatalog
+  ExtendedPrivilegesCatalog
+  AccountsCatalog
+  Metadata"
+  ; " " ; JSONString ) ; JSONArray ] ;
+  [ "include_details" ; False ; JSONBoolean ] ;
+  [ "split_catalogs" ; False ; JSONBoolean ] ;
+  [ "standalone_binarydata" ; False ; JSONBoolean ]
+)]]></Calculation>
+      </JSONOptions>
+    </SaXML>
+  </Step>
+```
+
+FM 26 new elements:
+- `<OutputEntireBinaryData>` — include full binary data for layout
+  objects.
+- `<SpecifyJSONOptions>` — whether JSON catalog selection is
+  configured.
+- `<SaXML>` → `<JSONOptions>` → `<Calculation>` — catalog
+  configuration as a JSONSetElement expression.
+
+#### Set Multi-User (84)
+```
+  <Step enable="True" id="84" name="Set Multi-User">
+    <MultiUser value="True"/>
+  </Step>
+```
+
+#### Set Use System Formats (94)
+```
+  <Step enable="True" id="94" name="Set Use System Formats">
+    <Set state="True"/>
+  </Step>
+```
+
+#### Write to Data File (192)
+```
+  <Step enable="True" id="192" name="Write to Data File">
+    <AppendLineFeed state="True"/>
+    <DataSourceType value="1"/>
+  </Step>
+```
+
+---
+
diff --git a/docs/filemaker-xml-canonical/skill/references/worked-example.md b/docs/filemaker-xml-canonical/skill/references/worked-example.md
new file mode 100644
index 0000000..cd5c0ad
--- /dev/null
+++ b/docs/filemaker-xml-canonical/skill/references/worked-example.md
@@ -0,0 +1,203 @@
+# Worked Example (§10)
+
+Optional reading: a start-to-finish walkthrough of generating a small
+script. Section references point to `core.md` and the step category
+files.
+
+## 10. Worked example: generating a small script
+
+This section walks through producing a short FileMaker script from
+scratch using only the rules in this document. The goal is a script
+that prompts the user for confirmation, performs a find for active
+records, and reports the count.
+
+The script in human-readable form:
+
+```
+Show Custom Dialog [ "Confirm" ; "Search active records?" ]
+If [ Get ( LastMessageChoice ) = 2 ]
+    Exit Script [ Text Result: "" ]
+End If
+Enter Find Mode [ Pause: Off ]
+Set Field [ records::status ; "active" ]
+Perform Find [ ]
+Show Custom Dialog [ "Result" ; "Found " & Get ( FoundCount ) & " records" ]
+```
+
+Generating the XML, step by step:
+
+**Step 1: the wrapper.** Every snippet begins with the XML declaration
+and `fmxmlsnippet` element (Section 1):
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<fmxmlsnippet type="FMObjectList">
+  ...steps go here...
+</fmxmlsnippet>
+```
+
+**Step 2: Show Custom Dialog with title and message** (Section 8.14).
+Three button slots are mandatory; unused slots are self-closing.
+Yes/No choice means neither button commits:
+
+```
+  <Step enable="True" id="87" name="Show Custom Dialog">
+    <Title>
+      <Calculation><![CDATA["Confirm"]]></Calculation>
+    </Title>
+    <Message>
+      <Calculation><![CDATA["Search active records?"]]></Calculation>
+    </Message>
+    <Buttons>
+      <Button CommitState="False">
+        <Calculation><![CDATA["No"]]></Calculation>
+      </Button>
+      <Button CommitState="False">
+        <Calculation><![CDATA["Yes"]]></Calculation>
+      </Button>
+      <Button CommitState="False"/>
+    </Buttons>
+  </Step>
+```
+
+**Step 3: If / Exit Script / End If branch** (Section 8.1). The If
+test reads `LastMessageChoice = 2`, which is the second button (No):
+
+```
+  <Step enable="True" id="68" name="If">
+    <Restore state="False"/>
+    <Calculation><![CDATA[Get ( LastMessageChoice ) = 2]]></Calculation>
+  </Step>
+  <Step enable="True" id="103" name="Exit Script">
+    <Calculation><![CDATA[""]]></Calculation>
+  </Step>
+  <Step enable="True" id="70" name="End If"/>
+```
+
+**Step 4: Enter Find Mode** (Section 8.3):
+
+```
+  <Step enable="True" id="22" name="Enter Find Mode">
+    <Pause state="False"/>
+    <Restore state="False"/>
+  </Step>
+```
+
+**Step 5: Set Field with structured field reference** (Section 8.5,
+plus the field-vs-variable target convention in Section 5). The
+`records::status` field needs a real `id` value from the recipient
+file's DDR — placeholder `N` shown here:
+
+```
+  <Step enable="True" id="76" name="Set Field">
+    <Calculation><![CDATA["active"]]></Calculation>
+    <Field table="records" id="N" name="status"/>
+  </Step>
+```
+
+**Step 6: Perform Find** with no saved criteria (it will find against
+whatever criteria are entered in find mode by the previous Set Field):
+
+```
+  <Step enable="True" id="28" name="Perform Find">
+    <Restore state="False"/>
+  </Step>
+```
+
+**Step 7: Show Custom Dialog reporting the count.** Single OK button
+with CommitState="True" (it commits the implicit pending record
+state):
+
+```
+  <Step enable="True" id="87" name="Show Custom Dialog">
+    <Title>
+      <Calculation><![CDATA["Result"]]></Calculation>
+    </Title>
+    <Message>
+      <Calculation><![CDATA["Found " & Get ( FoundCount ) & " records"]]></Calculation>
+    </Message>
+    <Buttons>
+      <Button CommitState="True">
+        <Calculation><![CDATA["OK"]]></Calculation>
+      </Button>
+      <Button CommitState="False"/>
+      <Button CommitState="False"/>
+    </Buttons>
+  </Step>
+```
+
+**Step 8: assemble the wrapper around the steps.** The complete
+output:
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<fmxmlsnippet type="FMObjectList">
+  <Step enable="True" id="87" name="Show Custom Dialog">
+    <Title>
+      <Calculation><![CDATA["Confirm"]]></Calculation>
+    </Title>
+    <Message>
+      <Calculation><![CDATA["Search active records?"]]></Calculation>
+    </Message>
+    <Buttons>
+      <Button CommitState="False">
+        <Calculation><![CDATA["No"]]></Calculation>
+      </Button>
+      <Button CommitState="False">
+        <Calculation><![CDATA["Yes"]]></Calculation>
+      </Button>
+      <Button CommitState="False"/>
+    </Buttons>
+  </Step>
+  <Step enable="True" id="68" name="If">
+    <Restore state="False"/>
+    <Calculation><![CDATA[Get ( LastMessageChoice ) = 2]]></Calculation>
+  </Step>
+  <Step enable="True" id="103" name="Exit Script">
+    <Calculation><![CDATA[""]]></Calculation>
+  </Step>
+  <Step enable="True" id="70" name="End If"/>
+  <Step enable="True" id="22" name="Enter Find Mode">
+    <Pause state="False"/>
+    <Restore state="False"/>
+  </Step>
+  <Step enable="True" id="76" name="Set Field">
+    <Calculation><![CDATA["active"]]></Calculation>
+    <Field table="records" id="N" name="status"/>
+  </Step>
+  <Step enable="True" id="28" name="Perform Find">
+    <Restore state="False"/>
+  </Step>
+  <Step enable="True" id="87" name="Show Custom Dialog">
+    <Title>
+      <Calculation><![CDATA["Result"]]></Calculation>
+    </Title>
+    <Message>
+      <Calculation><![CDATA["Found " & Get ( FoundCount ) & " records"]]></Calculation>
+    </Message>
+    <Buttons>
+      <Button CommitState="True">
+        <Calculation><![CDATA["OK"]]></Calculation>
+      </Button>
+      <Button CommitState="False"/>
+      <Button CommitState="False"/>
+    </Buttons>
+  </Step>
+</fmxmlsnippet>
+```
+
+**Notes on what could go wrong:**
+
+- The `id="N"` for the `records::status` field is a placeholder. A
+  real generator must either know the recipient file's DDR or accept
+  that pasted scripts will display as missing references until the
+  field is rebound. See Section 5 ("Runtime dependencies not enforced
+  by the XML format").
+- Two-space indentation must be used throughout. A single tab
+  character anywhere in the output may trigger a silent failure on
+  paste.
+- The `Get ( FoundCount )` calculation in the final dialog runs at
+  evaluation time, not at paste time — the dialog will report the
+  current found count whenever the script runs.
+
+---
diff --git a/src/SharpFM.Model/Scripting/FmScript.cs b/src/SharpFM.Model/Scripting/FmScript.cs
index 04cb7a5..9c07e48 100644
--- a/src/SharpFM.Model/Scripting/FmScript.cs
+++ b/src/SharpFM.Model/Scripting/FmScript.cs
@@ -234,14 +234,16 @@ private List<string> ApplyUpdate(ScriptStepOperation op)
 
     /// <summary>
     /// Convert a caller's param map into the ordered HR-token form each step's
-    /// FromDisplay factory expects. Iterates the step's metadata in declared
-    /// order, formatting each match as <c>"HrLabel: value"</c> when the param
-    /// has a label and as a raw positional value when it doesn't (e.g.
+    /// FromDisplay factory expects. Iterates the shape's display slots in
+    /// display order, formatting each match as <c>"HrLabel: value"</c> when the
+    /// slot has a label and as a raw positional value when it doesn't (e.g.
     /// <c>SetVariableStep.Name</c>, <c>IfStep.Condition</c> — these go straight
     /// into <c>&lt;Name&gt;</c> / <c>&lt;Calculation&gt;</c> without prefix).
+    /// Keys may address a slot by its bound property, its XML element, or its
+    /// display label, so pre-cutover param names keep working.
     /// </summary>
     /// <remarks>
-    /// The previous implementation labeled every non-empty key, which caused
+    /// An earlier implementation labeled every non-empty key, which caused
     /// positional params to receive a <c>"Name: $foo"</c> string verbatim into
     /// XML — structurally valid but semantically broken under FileMaker.
     /// </remarks>
@@ -254,15 +256,16 @@ private static string[] SynthesizeHrParams(
         var consumedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
         var result = new List<string>(map.Count);
 
-        foreach (var paramMeta in metadata.Params)
+        foreach (var node in Shapes.ShapeHrView.HrNodes(metadata.Shape))
         {
-            var matchedKey = FindMatchingKey(map, paramMeta.Name);
+            var matchedKey = map.Keys.FirstOrDefault(k =>
+                !consumedKeys.Contains(k) && Shapes.ShapeHrView.MatchesName(node, k));
             if (matchedKey is null) continue;
 
             consumedKeys.Add(matchedKey);
             var value = map[matchedKey];
-            result.Add(paramMeta.HrLabel is not null
-                ? $"{paramMeta.HrLabel}: {value}"
+            result.Add(node.HrLabel is not null
+                ? $"{node.HrLabel}: {value}"
                 : value);
         }
 
@@ -278,16 +281,6 @@ private static string[] SynthesizeHrParams(
         return result.ToArray();
     }
 
-    private static string? FindMatchingKey(IReadOnlyDictionary<string, string> map, string paramName)
-    {
-        foreach (var (k, _) in map)
-        {
-            if (string.Equals(k, paramName, StringComparison.OrdinalIgnoreCase))
-                return k;
-        }
-        return null;
-    }
-
     private List<string> ApplyRemove(ScriptStepOperation op)
     {
         if (ValidateStepIndex(op.Index) is { } err) return [err];
diff --git a/src/SharpFM.Model/Scripting/Registry/ParamMetadata.cs b/src/SharpFM.Model/Scripting/Registry/ParamMetadata.cs
deleted file mode 100644
index f378ef7..0000000
--- a/src/SharpFM.Model/Scripting/Registry/ParamMetadata.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System.Collections.Generic;
-
-namespace SharpFM.Model.Scripting.Registry;
-
-/// <summary>
-/// Typed description of a single script-step parameter, owned by the
-/// parent POCO's <see cref="StepMetadata"/>. Each POCO populates only
-/// the fields relevant to its own wire shape; consumers (completion,
-/// validation) read whatever's present.
-/// </summary>
-public sealed record ParamMetadata
-{
-    /// <summary>Short canonical identifier for the parameter.</summary>
-    public required string Name { get; init; }
-
-    /// <summary>XML element name emitted for this parameter.</summary>
-    public required string XmlElement { get; init; }
-
-    /// <summary>
-    /// Parameter type classifier — e.g. "boolean", "enum",
-    /// "calculation", "text". Informs display formatting and
-    /// intellisense behaviour.
-    /// </summary>
-    public required string Type { get; init; }
-
-    /// <summary>
-    /// Optional XML attribute name (e.g. "state", "value") when the
-    /// parameter's value lives on an attribute rather than element text.
-    /// </summary>
-    public string? XmlAttr { get; init; }
-
-    /// <summary>Human-readable label shown in display text and completion.</summary>
-    public string? HrLabel { get; init; }
-
-    /// <summary>Tooltip text for hover UIs, drawn from upstream snippet comments.</summary>
-    public string? Description { get; init; }
-
-    /// <summary>Closed set of permissible values for enum / boolean params.</summary>
-    public IReadOnlyList<string>? ValidValues { get; init; }
-
-    /// <summary>Default value emitted when the parameter is omitted.</summary>
-    public string? DefaultValue { get; init; }
-
-    /// <summary>True when the parameter must be present in valid XML.</summary>
-    public bool Required { get; init; }
-}
diff --git a/src/SharpFM.Model/Scripting/Registry/StepMetadata.cs b/src/SharpFM.Model/Scripting/Registry/StepMetadata.cs
index d7efd5c..fc2c420 100644
--- a/src/SharpFM.Model/Scripting/Registry/StepMetadata.cs
+++ b/src/SharpFM.Model/Scripting/Registry/StepMetadata.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Xml.Linq;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Registry;
 
@@ -45,8 +46,14 @@ public sealed record StepMetadata
     /// </summary>
     public StepBlockPair? BlockPair { get; init; }
 
-    /// <summary>Typed descriptions of the step's parameters.</summary>
-    public IReadOnlyList<ParamMetadata> Params { get; init; } = [];
+    /// <summary>
+    /// Ordered declarative description of the step's wire shape — the single
+    /// source of truth that drives XML emission, parsing, validation, and the
+    /// display consumers (param synthesis, script validation, completion via
+    /// <see cref="Shapes.ShapeHrView"/>). Element order in emitted XML matches
+    /// this list, satisfying FileMaker's canonical element-order requirements.
+    /// </summary>
+    public IReadOnlyList<ShapeNode> Shape { get; init; } = [];
 
     /// <summary>Behavioural intelligence — tooltip / lint source.</summary>
     public StepNotes? Notes { get; init; }
diff --git a/src/SharpFM.Model/Scripting/Registry/StepRegistry.cs b/src/SharpFM.Model/Scripting/Registry/StepRegistry.cs
index 7658511..a9921a6 100644
--- a/src/SharpFM.Model/Scripting/Registry/StepRegistry.cs
+++ b/src/SharpFM.Model/Scripting/Registry/StepRegistry.cs
@@ -86,19 +86,6 @@ public static IReadOnlyDictionary<int, StepMetadata> ById
     [ModuleInitializer]
     internal static void ModuleInitialize() => EnsureInitialized();
 
-    /// <summary>
-    /// Surface valid values for a parameter in completion / validation
-    /// contexts. Returns the explicit <see cref="ParamMetadata.ValidValues"/>
-    /// when present; otherwise defaults boolean-like params to
-    /// <c>["On", "Off"]</c>.
-    /// </summary>
-    public static IReadOnlyList<string> GetValidValues(ParamMetadata param)
-    {
-        if (param.ValidValues is { Count: > 0 }) return param.ValidValues;
-        if (param.Type is "boolean" or "flagBoolean" or "flagElement")
-            return new[] { "On", "Off" };
-        return [];
-    }
 
     private static void EnsureInitialized()
     {
diff --git a/src/SharpFM.Model/Scripting/ScriptValidator.cs b/src/SharpFM.Model/Scripting/ScriptValidator.cs
index e499f46..8636586 100644
--- a/src/SharpFM.Model/Scripting/ScriptValidator.cs
+++ b/src/SharpFM.Model/Scripting/ScriptValidator.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting;
 
@@ -100,7 +101,8 @@ public static List<ScriptDiagnostic> Validate(string displayText)
             if (bracketPos >= 0)
             {
                 var parsed = ScriptLineParser.ParseRaw(rawLine);
-                var usedParams = new bool[metadata.Params.Count];
+                var hrSlots = ShapeHrView.HrNodes(metadata.Shape);
+                var usedParams = new bool[hrSlots.Count];
 
                 foreach (var hrParam in parsed.Params)
                 {
@@ -108,36 +110,36 @@ public static List<ScriptDiagnostic> Validate(string displayText)
                     bool matchedLabel = false;
 
                     // First: try labeled match
-                    for (int pi = 0; pi < metadata.Params.Count; pi++)
+                    for (int pi = 0; pi < hrSlots.Count; pi++)
                     {
-                        var catalogParam = metadata.Params[pi];
-                        var label = catalogParam.HrLabel;
+                        var slot = hrSlots[pi];
+                        var label = slot.HrLabel;
                         if (label == null) continue;
                         if (!paramTrimmed.StartsWith(label + ":", StringComparison.OrdinalIgnoreCase))
                             continue;
 
                         var value = paramTrimmed.Substring(label.Length + 1).TrimStart();
-                        ValidateParamValue(value, label, catalogParam, rawLine, lineNum, diagnostics);
+                        ValidateParamValue(value, label, slot, rawLine, lineNum, diagnostics);
                         usedParams[pi] = true;
                         matchedLabel = true;
                         break;
                     }
 
                     // Flag-style match: a bare token that exactly equals
-                    // an unused boolean/flag param's HrLabel is a presence
+                    // an unused boolean/flag slot's HrLabel is a presence
                     // marker (e.g. "Select", "Verify SSL Certificates",
                     // "Append line feed"). Not a value — consume the
-                    // param and skip value validation.
+                    // slot and skip value validation.
                     bool matchedFlag = false;
                     if (!matchedLabel)
                     {
-                        for (int pi = 0; pi < metadata.Params.Count; pi++)
+                        for (int pi = 0; pi < hrSlots.Count; pi++)
                         {
                             if (usedParams[pi]) continue;
-                            var catalogParam = metadata.Params[pi];
-                            if (catalogParam.HrLabel is null) continue;
-                            if (catalogParam.Type is not ("boolean" or "flagBoolean" or "flagElement")) continue;
-                            if (!paramTrimmed.Equals(catalogParam.HrLabel, StringComparison.OrdinalIgnoreCase)) continue;
+                            var slot = hrSlots[pi];
+                            if (slot.HrLabel is null) continue;
+                            if (!IsFlagLike(slot)) continue;
+                            if (!paramTrimmed.Equals(slot.HrLabel, StringComparison.OrdinalIgnoreCase)) continue;
 
                             usedParams[pi] = true;
                             matchedFlag = true;
@@ -145,25 +147,25 @@ public static List<ScriptDiagnostic> Validate(string displayText)
                         }
                     }
 
-                    // Positional match — consume the next available param
-                    // in order. Only validate the value when that param
+                    // Positional match — consume the next available slot
+                    // in order. Only validate the value when that slot
                     // has restricted values (enum/boolean). Non-enum
-                    // params (field, calc, text) accept anything, so we
+                    // slots (field, calc, text) accept anything, so we
                     // must NOT keep searching past them looking for an
                     // enum — that produced false-positive warnings on
                     // field references like "Assets::Selected File".
                     if (!matchedLabel && !matchedFlag && !LooksLikeCalculation(paramTrimmed))
                     {
-                        for (int pi = 0; pi < metadata.Params.Count; pi++)
+                        for (int pi = 0; pi < hrSlots.Count; pi++)
                         {
                             if (usedParams[pi]) continue;
-                            var catalogParam = metadata.Params[pi];
-                            var validValues = StepRegistry.GetValidValues(catalogParam);
+                            var slot = hrSlots[pi];
+                            var validValues = ShapeHrView.DisplayValuesOf(slot);
                             if (validValues.Count > 0
                                 && !validValues.Contains(paramTrimmed, StringComparer.OrdinalIgnoreCase))
                             {
-                                var paramLabel = catalogParam.HrLabel ?? catalogParam.XmlElement;
-                                ValidateParamValue(paramTrimmed, paramLabel, catalogParam, rawLine, lineNum, diagnostics);
+                                var paramLabel = slot.HrLabel ?? ShapeHrView.NameOf(slot);
+                                ValidateParamValue(paramTrimmed, paramLabel, slot, rawLine, lineNum, diagnostics);
                             }
                             usedParams[pi] = true;
                             break;
@@ -188,11 +190,15 @@ public static List<ScriptDiagnostic> Validate(string displayText)
         return diagnostics;
     }
 
+    /// <summary>A slot whose display domain is exactly On/Off — its bare HrLabel is a presence marker.</summary>
+    private static bool IsFlagLike(ShapeNode slot) =>
+        ShapeHrView.DisplayValuesOf(slot) is ["On", "Off"];
+
     private static void ValidateParamValue(
-        string value, string label, ParamMetadata catalogParam,
+        string value, string label, ShapeNode slot,
         string rawLine, int lineNum, List<ScriptDiagnostic> diagnostics)
     {
-        var validValues = StepRegistry.GetValidValues(catalogParam);
+        var validValues = ShapeHrView.DisplayValuesOf(slot);
         if (validValues.Count > 0 && !validValues.Contains(value, StringComparer.OrdinalIgnoreCase))
         {
             var bracketStart = rawLine.IndexOf('[');
diff --git a/src/SharpFM.Model/Scripting/Serialization/ShapeReflection.cs b/src/SharpFM.Model/Scripting/Serialization/ShapeReflection.cs
new file mode 100644
index 0000000..dfa36e9
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Serialization/ShapeReflection.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Concurrent;
+using System.Reflection;
+
+namespace SharpFM.Model.Scripting.Serialization;
+
+/// <summary>
+/// Cached property access used by the shape-driven renderer/parser to bind a
+/// <c>ShapeNode</c> to a POCO (or discriminated-union variant) property by
+/// name. Reflection cost is paid once per (type, property) pair.
+/// </summary>
+internal static class ShapeReflection
+{
+    private static readonly ConcurrentDictionary<(Type, string), PropertyInfo> _cache = new();
+
+    private static PropertyInfo Prop(Type type, string name) =>
+        _cache.GetOrAdd((type, name), key =>
+            key.Item1.GetProperty(key.Item2, BindingFlags.Public | BindingFlags.Instance)
+            ?? throw new InvalidOperationException(
+                $"Shape references property '{key.Item2}' which does not exist on {key.Item1.Name}."));
+
+    public static object? Get(object source, string name) =>
+        Prop(source.GetType(), name).GetValue(source);
+
+    /// <summary>
+    /// Writes a shape-bound property, including init-only setters on record
+    /// positional parameters. A bound property with no setter marks an
+    /// emit-only node (e.g. a variant discriminator bound to a computed
+    /// <c>WireValue</c>), so parsing skips it rather than throwing.
+    /// </summary>
+    public static void Set(object target, string name, object? value)
+    {
+        var prop = Prop(target.GetType(), name);
+        if (prop.CanWrite)
+            prop.SetValue(target, value);
+    }
+
+    /// <summary>Declared type of a shape-bound property (for typed list parsing).</summary>
+    public static Type PropertyType(object source, string name) =>
+        Prop(source.GetType(), name).PropertyType;
+}
diff --git a/src/SharpFM.Model/Scripting/Serialization/StepDisplayFactory.cs b/src/SharpFM.Model/Scripting/Serialization/StepDisplayFactory.cs
index 6fb6b53..8babc72 100644
--- a/src/SharpFM.Model/Scripting/Serialization/StepDisplayFactory.cs
+++ b/src/SharpFM.Model/Scripting/Serialization/StepDisplayFactory.cs
@@ -21,11 +21,17 @@ public static class StepDisplayFactory
         new(StringComparer.OrdinalIgnoreCase);
 
     /// <summary>
-    /// Register a typed POCO's display-text factory delegate.
+    /// Register a typed POCO's display-text factory delegate. A canonical
+    /// name carrying FileMaker's trailing space ("Configure RAG Account ")
+    /// is additionally registered trimmed, because display-text parsing
+    /// trims step names.
     /// </summary>
     public static void Register(string stepName, Func<bool, string[], ScriptStep> creator)
     {
         _typed[stepName] = creator;
+        var trimmed = stepName.Trim();
+        if (trimmed != stepName)
+            _typed.TryAdd(trimmed, creator);
     }
 
     /// <summary>
diff --git a/src/SharpFM.Model/Scripting/Serialization/StepDisplayParser.cs b/src/SharpFM.Model/Scripting/Serialization/StepDisplayParser.cs
new file mode 100644
index 0000000..d01c1d5
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Serialization/StepDisplayParser.cs
@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Values;
+
+namespace SharpFM.Model.Scripting.Serialization;
+
+/// <summary>
+/// Constructs a typed POCO from parsed display-text tokens by walking the
+/// same <see cref="StepMetadata.Shape"/> display slots that
+/// <see cref="StepDisplayRenderer"/> renders — the display-side counterpart of
+/// <see cref="StepXmlParser"/>. Labeled tokens bind by <c>HrLabel</c>, a bare
+/// token equal to a flag's label marks presence, and remaining tokens bind
+/// positionally to unlabeled slots in display order. Unrecognized tokens are
+/// ignored (display text is user-edited; tolerance is the contract).
+///
+/// <para>
+/// A step is eligible only when its display grammar is faithful — the
+/// display round-trip contract suite is the proof. Steps with variant,
+/// value-type, or list slots keep hand-written display parsing.
+/// </para>
+/// </summary>
+public static class StepDisplayParser
+{
+    public static T Parse<T>(bool enabled, string[] hrParams, StepMetadata meta) where T : ScriptStep =>
+        (T)Parse(typeof(T), enabled, hrParams, meta);
+
+    public static ScriptStep Parse(Type pocoType, bool enabled, string[] hrParams, StepMetadata meta)
+    {
+        if (Activator.CreateInstance(pocoType, nonPublic: true) is not ScriptStep instance)
+            throw new InvalidOperationException(
+                $"{pocoType.Name} needs a parameterless constructor for shape-driven display parsing.");
+        instance.Enabled = enabled;
+
+        var slots = ShapeHrView.HrNodes(meta.Shape).Where(n => n is not HrOnly).ToList();
+        var used = new bool[slots.Count];
+
+        foreach (var raw in hrParams)
+        {
+            var token = raw.Trim();
+
+            // Labeled: "HrLabel: value"
+            var bound = false;
+            for (int i = 0; i < slots.Count && !bound; i++)
+            {
+                var label = slots[i].HrLabel;
+                if (used[i] || label is null) continue;
+                if (!token.StartsWith(label + ":", StringComparison.OrdinalIgnoreCase)) continue;
+                used[i] = true;
+                Assign(instance, slots[i], token[(label.Length + 1)..].Trim());
+                bound = true;
+            }
+            if (bound) continue;
+
+            // Bare presence flag: token equals a flag slot's label
+            for (int i = 0; i < slots.Count && !bound; i++)
+            {
+                if (used[i] || slots[i] is not FlagChild flag) continue;
+                var label = slots[i].HrLabel ?? flag.Element;
+                if (!token.Equals(label, StringComparison.OrdinalIgnoreCase)) continue;
+                used[i] = true;
+                ShapeReflection.Set(instance, flag.PocoProperty ?? flag.Element, true);
+                bound = true;
+            }
+            if (bound) continue;
+
+            // Positional: next unused unlabeled slot
+            for (int i = 0; i < slots.Count && !bound; i++)
+            {
+                if (used[i] || slots[i].HrLabel is not null) continue;
+                used[i] = true;
+                Assign(instance, slots[i], token);
+                bound = true;
+            }
+        }
+
+        return instance;
+    }
+
+    private static void Assign(object target, ShapeNode node, string value)
+    {
+        // The empty-slot / fallback token carries no information beyond the
+        // constructor default; an empty value likewise leaves the default.
+        if (value.Length == 0 || value == node.DisplayEmptyAs) return;
+
+        switch (node)
+        {
+            case BoolStateChild b:
+                ShapeReflection.Set(target, b.PocoProperty ?? b.Element,
+                    value.Equals("On", StringComparison.OrdinalIgnoreCase) != b.DisplayInverted);
+                return;
+
+            case EnumValueChild e:
+                ShapeReflection.Set(target, e.PocoProperty ?? e.Element, ToWireValue(e, value));
+                return;
+
+            case BareCalcChild:
+                ShapeReflection.Set(target, node.PocoProperty ?? "Calculation", new Calculation(value));
+                return;
+
+            case NamedCalcChild nc:
+                ShapeReflection.Set(target, nc.PocoProperty ?? nc.Element, new Calculation(value));
+                return;
+
+            case NamedTextChild nt:
+                ShapeReflection.Set(target, nt.PocoProperty ?? nt.Element, value);
+                return;
+
+            case FieldChild f:
+                ShapeReflection.Set(target, f.PocoProperty ?? f.Element, FieldRef.FromDisplayToken(value));
+                return;
+
+            case NamedRefChild nr:
+                // Display carries the name only; id 0 is the unknown sentinel.
+                ShapeReflection.Set(target, nr.PocoProperty ?? nr.Element, new NamedRef(0, value));
+                return;
+
+            default:
+                return; // variant/value-type/list slots need hand-written parsing
+        }
+    }
+
+    /// <summary>Inverse of the renderer's wire→display translation.</summary>
+    private static string ToWireValue(ShapeNode node, string display)
+    {
+        if (node.DisplayValues is null || node.ValidValues is null) return display;
+        var i = node.DisplayValues.ToList().FindIndex(v => v.Equals(display, StringComparison.OrdinalIgnoreCase));
+        return i >= 0 && i < node.ValidValues.Count ? node.ValidValues[i] : display;
+    }
+}
diff --git a/src/SharpFM.Model/Scripting/Serialization/StepDisplayRenderer.cs b/src/SharpFM.Model/Scripting/Serialization/StepDisplayRenderer.cs
new file mode 100644
index 0000000..ee689a5
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Serialization/StepDisplayRenderer.cs
@@ -0,0 +1,126 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Values;
+
+namespace SharpFM.Model.Scripting.Serialization;
+
+/// <summary>
+/// Renders a step's human-readable display line from the same
+/// <see cref="StepMetadata.Shape"/> that drives XML emission, reproducing the
+/// shipped display grammar exactly:
+///
+/// <para>
+/// <c>Step Name [ native ; Label: value ; Label: value ]</c>
+/// </para>
+///
+/// <list type="bullet">
+///   <item>Slots render in <see cref="Shapes.ShapeHrView.HrNodes"/> order
+///   (<see cref="DisplayMode.Native"/> first, then
+///   <see cref="DisplayMode.Augmented"/>) inside one bracket, joined by
+///   <c>;</c> — the way FileMaker Pro shows them.</item>
+///   <item>A labeled slot renders as <c>HrLabel: value</c>; an unlabeled
+///   native renders bare.</item>
+///   <item><see cref="DisplayMode.Hidden"/> nodes never appear.</item>
+/// </list>
+///
+/// Nodes whose value is blank are dropped; an augmented node whose value equals
+/// its <see cref="ShapeNode.DefaultValue"/> is also dropped (so a child that is
+/// always emitted in XML can still be hidden from the display line when it holds
+/// its default — e.g. Set Variable's Repetition of "1").
+/// </summary>
+public static class StepDisplayRenderer
+{
+    public static string Render(ScriptStep step, StepMetadata meta)
+    {
+        var tokens = new List<string>();
+
+        foreach (var node in ShapeHrView.HrNodes(meta.Shape))
+        {
+            // A true presence flag renders as its bare label; false renders
+            // nothing (FileMaker's "Select" / "Verify SSL Certificates" form).
+            if (node is FlagChild flag)
+            {
+                if ((bool)(Get(step, flag.PocoProperty ?? flag.Element) ?? false))
+                    tokens.Add(node.HrLabel ?? flag.Element);
+                continue;
+            }
+
+            var value = DisplayValue(step, node);
+            if (string.IsNullOrEmpty(value))
+            {
+                if (node.DisplayEmptyAs is null) continue;
+                value = node.DisplayEmptyAs;
+            }
+
+            if (node.Display == DisplayMode.Augmented)
+            {
+                // Display suppression is keyed on DefaultValue alone, decoupled
+                // from the XML-emission Optional flag: a child can be always
+                // emitted in XML (e.g. Set Variable's Repetition) yet hidden in
+                // the display line when it holds its default.
+                if (node.DefaultValue is not null && value == node.DefaultValue) continue;
+                tokens.Add($"{node.HrLabel ?? ElementLabel(node)}: {value}");
+            }
+            else
+            {
+                tokens.Add(node.HrLabel is not null ? $"{node.HrLabel}: {value}" : value);
+            }
+        }
+
+        return tokens.Count == 0
+            ? meta.Name
+            : $"{meta.Name} [ {string.Join(" ; ", tokens)} ]";
+    }
+
+    private static string? DisplayValue(object src, ShapeNode node) => node switch
+    {
+        AttributeNode a => Get(src, a.PocoProperty ?? a.AttrName)?.ToString(),
+        BoolStateChild b => (bool)(Get(src, b.PocoProperty ?? b.Element) ?? false) != b.DisplayInverted ? "On" : "Off",
+        EnumValueChild e => ToDisplayValue(node, Get(src, e.PocoProperty ?? e.Element)?.ToString()),
+        BareCalcChild => (Get(src, node.PocoProperty ?? "Calculation") as Calculation)?.Text,
+        NamedCalcChild nc => (Get(src, nc.PocoProperty ?? nc.Element) as Calculation)?.Text,
+        NamedTextChild nt => Get(src, nt.PocoProperty ?? nt.Element)?.ToString(),
+        FieldChild f => (Get(src, f.PocoProperty ?? f.Element) as FieldRef)?.ToDisplayString(),
+        NamedRefChild nr => (Get(src, nr.PocoProperty ?? nr.Element) as NamedRef)?.Name,
+        ParametersList pl => FormatList(Get(src, pl.PocoProperty ?? pl.Wrapper)),
+        // ValueTypeChild / VariantBlock / Passthrough / HrOnly have no uniform
+        // display contribution; steps needing them keep hand-written display.
+        _ => null,
+    };
+
+    /// <summary>
+    /// Translate a wire value to its display form via the node's parallel
+    /// ValidValues/DisplayValues lists (e.g. "SortAscending" → "Ascending").
+    /// Values outside the declared set pass through unchanged.
+    /// </summary>
+    private static string? ToDisplayValue(ShapeNode node, string? wire)
+    {
+        if (wire is null || node.DisplayValues is null || node.ValidValues is null) return wire;
+        var i = node.ValidValues.ToList().IndexOf(wire);
+        return i >= 0 && i < node.DisplayValues.Count ? node.DisplayValues[i] : wire;
+    }
+
+    private static string? FormatList(object? value) =>
+        value is IEnumerable e and not string
+            ? string.Join(", ", e.Cast<object>().Select(o => o is Calculation c ? c.Text : o?.ToString()))
+            : null;
+
+    private static string ElementLabel(ShapeNode node) => node switch
+    {
+        BoolStateChild b => b.Element,
+        EnumValueChild e => e.Element,
+        NamedCalcChild nc => nc.Element,
+        NamedTextChild nt => nt.Element,
+        FieldChild f => f.Element,
+        NamedRefChild nr => nr.Element,
+        ValueTypeChild vt => vt.Element,
+        AttributeNode a => a.AttrName,
+        _ => "value",
+    };
+
+    private static object? Get(object src, string name) => ShapeReflection.Get(src, name);
+}
diff --git a/src/SharpFM.Model/Scripting/Serialization/StepXmlParser.cs b/src/SharpFM.Model/Scripting/Serialization/StepXmlParser.cs
new file mode 100644
index 0000000..cdbdc48
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Serialization/StepXmlParser.cs
@@ -0,0 +1,254 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Values;
+
+namespace SharpFM.Model.Scripting.Serialization;
+
+/// <summary>
+/// Constructs a typed POCO from a <c>&lt;Step&gt;</c> element by walking its
+/// declarative <see cref="StepMetadata.Shape"/> — the inverse of
+/// <see cref="StepXmlRenderer"/>. The POCO is created through a parameterless
+/// constructor (public or non-public) and its shape-bound properties are
+/// populated by reflection, so a migrated step's <c>FromXml</c> reduces to a
+/// single call.
+/// </summary>
+public static class StepXmlParser
+{
+    public static T Parse<T>(XElement step, StepMetadata meta) where T : ScriptStep =>
+        (T)Parse(typeof(T), step, meta);
+
+    public static ScriptStep Parse(Type pocoType, XElement step, StepMetadata meta)
+    {
+        if (Activator.CreateInstance(pocoType, nonPublic: true) is not ScriptStep instance)
+            throw new InvalidOperationException(
+                $"{pocoType.Name} needs a parameterless constructor for shape-driven parsing.");
+
+        instance.Enabled = step.Attribute("enable")?.Value != "False";
+        foreach (var node in meta.Shape)
+            Populate(instance, step, node);
+
+        CapturePassthrough(instance, step, meta.Shape);
+        return instance;
+    }
+
+    /// <summary>
+    /// A Passthrough slot captures every child element its sibling nodes did
+    /// not model, so partially-known steps round-trip unknown children
+    /// verbatim. The bound property may be a <c>List&lt;XElement&gt;</c> or a
+    /// <see cref="StepChildBag"/>.
+    /// </summary>
+    private static void CapturePassthrough(object target, XElement parent, IReadOnlyList<ShapeNode> shape)
+    {
+        if (shape.OfType<Passthrough>().FirstOrDefault() is not { } pt) return;
+
+        var modeled = shape.SelectMany(StepXmlValidator.ElementNamesOf).ToHashSet();
+        var extras = parent.Elements()
+            .Where(e => !modeled.Contains(e.Name.LocalName))
+            .Select(e => new XElement(e))
+            .ToList();
+        var prop = pt.PocoProperty ?? "Passthrough";
+        Set(target, prop,
+            typeof(StepChildBag).IsAssignableFrom(ShapeReflection.PropertyType(target, prop))
+                ? new StepChildBag(extras)
+                : extras);
+    }
+
+    private static void Populate(object target, XElement step, ShapeNode node)
+    {
+        switch (node)
+        {
+            case AttributeNode a:
+                Set(target, a.PocoProperty ?? a.AttrName, step.Attribute(a.AttrName)?.Value ?? a.DefaultValue ?? "");
+                return;
+
+            case BoolStateChild b:
+            {
+                // Present -> the bool. Absent: false for a required flag; for an
+                // optional flag leave the POCO default (null for a bool? — keeps
+                // "absent" distinct from "present and False").
+                var el = step.Element(b.Element);
+                if (el is not null) Set(target, b.PocoProperty ?? b.Element, el.Attribute(b.Attr)?.Value == "True");
+                else if (!b.Optional) Set(target, b.PocoProperty ?? b.Element, false);
+                return;
+            }
+
+            case EnumValueChild e:
+            {
+                var v = step.Element(e.Element)?.Attribute("value")?.Value ?? e.DefaultValue ?? "";
+                Set(target, e.PocoProperty ?? e.Element, v);
+                return;
+            }
+
+            case FlagChild fl:
+                Set(target, fl.PocoProperty ?? fl.Element, step.Element(fl.Element) is not null);
+                return;
+
+            case BareCalcChild:
+            {
+                var el = step.Element("Calculation");
+                if (el is not null) Set(target, node.PocoProperty ?? "Calculation", Calculation.FromXml(el));
+                else if (!node.Optional) Set(target, node.PocoProperty ?? "Calculation", new Calculation(node.DefaultValue ?? ""));
+                return;
+            }
+
+            case NamedCalcChild nc:
+            {
+                var el = step.Element(nc.Element)?.Element("Calculation");
+                if (el is not null) Set(target, nc.PocoProperty ?? nc.Element, Calculation.FromXml(el));
+                else if (!nc.Optional) Set(target, nc.PocoProperty ?? nc.Element, new Calculation(nc.DefaultValue ?? ""));
+                return;
+            }
+
+            case NamedTextChild nt:
+            {
+                var el = step.Element(nt.Element);
+                Set(target, nt.PocoProperty ?? nt.Element, el?.Value ?? "");
+                if (nt.Attr is not null)
+                    Set(target, nt.AttrProperty ?? nt.Attr,
+                        el?.Attribute(nt.Attr)?.Value ?? nt.AttrDefault ?? "");
+                return;
+            }
+
+            case FieldChild f:
+            {
+                var el = step.Element(f.Element);
+                // A present-but-empty <Field/> means "no field bound" -> null;
+                // an absent element leaves the POCO default untouched.
+                if (el is not null)
+                    Set(target, f.PocoProperty ?? f.Element,
+                        el.HasAttributes || !string.IsNullOrEmpty(el.Value) ? FieldRef.FromXml(el) : null);
+                return;
+            }
+
+            case NamedRefChild nr:
+            {
+                // Absent leaves the POCO default (e.g. Go to Related Record's
+                // always-present Table keeps its empty default; an optional
+                // Layout stays null).
+                var el = step.Element(nr.Element);
+                if (el is not null) Set(target, nr.PocoProperty ?? nr.Element, NamedRef.FromXml(el));
+                return;
+            }
+
+            case ValueTypeChild vt:
+            {
+                // Leave the POCO's default (set in its parameterless ctor) when
+                // the element is absent, rather than nulling a non-nullable
+                // value-type property.
+                var el = step.Element(vt.Element);
+                if (el is not null) Set(target, vt.PocoProperty ?? vt.Element, InvokeFromXml(vt, target, el));
+                return;
+            }
+
+            case ParametersList pl:
+            {
+                var prop = pl.PocoProperty ?? pl.Wrapper;
+                var wrapper = step.Element(pl.Wrapper);
+                // Item typing follows the bound property: List<Calculation>
+                // round-trips the renderer's <P><Calculation> form; anything
+                // else parses as plain strings.
+                var itemType = ShapeReflection.PropertyType(target, prop)
+                    .GetGenericArguments().FirstOrDefault();
+                if (itemType == typeof(Calculation))
+                {
+                    var calcs = wrapper?.Elements(pl.Child)
+                        .Select(p => p.Element("Calculation") is { } c
+                            ? Calculation.FromXml(c)
+                            : new Calculation(p.Value))
+                        .ToList() ?? new List<Calculation>();
+                    Set(target, prop, calcs);
+                }
+                else
+                {
+                    var items = wrapper?.Elements(pl.Child).Select(p => p.Value).ToList() ?? new List<string>();
+                    Set(target, prop, items);
+                }
+                return;
+            }
+
+            case WrapperChild w:
+            {
+                var wrapper = step.Element(w.Element);
+                if (wrapper is not null)
+                {
+                    foreach (var child in w.Children)
+                        Populate(target, wrapper, child);
+                    CapturePassthrough(target, wrapper, w.Children);
+                }
+                return;
+            }
+
+            case HrOnly:
+                return; // display-grammar slot; no wire form of its own
+
+            case Passthrough:
+                return; // handled after the loop in Parse, with full-shape context
+
+            case VariantBlock vb:
+            {
+                var prop = node.PocoProperty
+                    ?? throw new InvalidOperationException("VariantBlock requires PocoProperty.");
+                var match = vb.Cases.FirstOrDefault(c => CaseMatches(c, step));
+                if (match is null) return; // leave the POCO's constructor default
+
+                // Union cases are records with positional parameters, so there
+                // is no parameterless constructor to call — create the blank
+                // instance uninitialized and let the case's children populate
+                // its init-only positional properties.
+                var value = CreateBlank(match.WhenType);
+                foreach (var child in match.Children)
+                    Populate(value, step, child);
+                Set(target, prop, value);
+                return;
+            }
+
+            default:
+                throw new NotSupportedException($"Unhandled shape node: {node.GetType().Name}");
+        }
+    }
+
+    private static bool CaseMatches(VariantCase c, XElement step)
+    {
+        if (c.MatchElement is null) return true; // unconditional fallback
+        var el = step.Element(c.MatchElement);
+        if (el is null) return false;
+        return c.MatchValues is null
+            || c.MatchValues.Contains(el.Attribute("value")?.Value ?? "", StringComparer.Ordinal);
+    }
+
+    private static object CreateBlank(Type type) =>
+        type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, Type.EmptyTypes)
+            ?.Invoke(null)
+        ?? System.Runtime.CompilerServices.RuntimeHelpers.GetUninitializedObject(type);
+
+    private static readonly Dictionary<(Type, string), MethodInfo> _fromXmlCache = new();
+
+    private static object InvokeFromXml(ValueTypeChild vt, object target, XElement el)
+    {
+        // The value type's property declares its concrete type; reflect its
+        // static FromXml(XElement) and invoke it.
+        var propType = target.GetType().GetProperty(vt.PocoProperty ?? vt.Element)!.PropertyType;
+        var underlying = Nullable.GetUnderlyingType(propType) ?? propType;
+        MethodInfo method;
+        lock (_fromXmlCache)
+        {
+            var key = (underlying, "FromXml");
+            if (!_fromXmlCache.TryGetValue(key, out method!))
+            {
+                method = underlying.GetMethod("FromXml", BindingFlags.Public | BindingFlags.Static, new[] { typeof(XElement) })
+                    ?? throw new InvalidOperationException(
+                        $"Value type {underlying.Name} has no static FromXml(XElement) for ValueTypeChild.");
+                _fromXmlCache[key] = method;
+            }
+        }
+        return method.Invoke(null, new object[] { el })!;
+    }
+
+    private static void Set(object target, string prop, object? value) =>
+        ShapeReflection.Set(target, prop, value);
+}
diff --git a/src/SharpFM.Model/Scripting/Serialization/StepXmlRenderer.cs b/src/SharpFM.Model/Scripting/Serialization/StepXmlRenderer.cs
new file mode 100644
index 0000000..bdb377e
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Serialization/StepXmlRenderer.cs
@@ -0,0 +1,223 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Values;
+
+namespace SharpFM.Model.Scripting.Serialization;
+
+/// <summary>
+/// Emits a <c>&lt;Step&gt;</c> element from a typed POCO by walking its
+/// declarative <see cref="StepMetadata.Shape"/>. Element order follows shape
+/// order exactly, satisfying FileMaker's canonical element-order requirements.
+/// Optional nodes whose bound value is empty/default are omitted — which is
+/// what keeps SharpFM from emitting placeholder elements FileMaker does not
+/// write for an unconfigured step. The shape owns the four silent-failure-mode
+/// primitives (<see cref="NamedTextChild"/> for Set Variable's <c>Name</c>,
+/// <see cref="ParametersList"/> for the JS <c>&lt;P&gt;</c> form,
+/// <see cref="NamedCalcChild"/> for the OnTimer <c>Interval</c> wrapper), so no
+/// migrated step can reintroduce them.
+/// </summary>
+public static class StepXmlRenderer
+{
+    public static XElement Render(ScriptStep step, StepMetadata meta)
+    {
+        var el = new XElement("Step",
+            new XAttribute("enable", step.Enabled ? "True" : "False"),
+            new XAttribute("id", meta.Id),
+            new XAttribute("name", meta.Name));
+
+        foreach (var node in meta.Shape)
+            Emit(el, step, node);
+
+        return el;
+    }
+
+    private static void Emit(XElement parent, object src, ShapeNode node)
+    {
+        switch (node)
+        {
+            case AttributeNode a:
+            {
+                var v = ShapeReflection.Get(src, a.PocoProperty ?? a.AttrName);
+                if (v is null && a.Optional) return;
+                parent.Add(new XAttribute(a.AttrName, Str(v)));
+                return;
+            }
+
+            case BoolStateChild b:
+            {
+                var raw = ShapeReflection.Get(src, b.PocoProperty ?? b.Element);
+                if (b.Optional && raw is null) return; // optional bool? absent
+                var v = (bool)(raw ?? false);
+                parent.Add(new XElement(b.Element, new XAttribute(b.Attr, v ? "True" : "False")));
+                return;
+            }
+
+            case EnumValueChild e:
+            {
+                var v = ShapeReflection.Get(src, e.PocoProperty ?? e.Element);
+                if (e.Optional && IsBlank(v)) return;
+                parent.Add(new XElement(e.Element, new XAttribute("value", Str(v))));
+                return;
+            }
+
+            case FlagChild fl:
+            {
+                if ((bool)(ShapeReflection.Get(src, fl.PocoProperty ?? fl.Element) ?? false))
+                    parent.Add(new XElement(fl.Element));
+                return;
+            }
+
+            case BareCalcChild:
+            {
+                var c = (Calculation?)ShapeReflection.Get(src, node.PocoProperty ?? "Calculation");
+                if (node.Optional && string.IsNullOrEmpty(c?.Text)) return;
+                parent.Add((c ?? new Calculation("")).ToXml());
+                return;
+            }
+
+            case NamedCalcChild nc:
+            {
+                var c = (Calculation?)ShapeReflection.Get(src, nc.PocoProperty ?? nc.Element);
+                if (nc.Optional && string.IsNullOrEmpty(c?.Text)) return;
+                parent.Add(new XElement(nc.Element, (c ?? new Calculation("")).ToXml()));
+                return;
+            }
+
+            case NamedTextChild nt:
+            {
+                var s = Str(ShapeReflection.Get(src, nt.PocoProperty ?? nt.Element));
+                if (nt.Optional && s.Length == 0) return;
+                var el = new XElement(nt.Element, s);
+                if (nt.Attr is not null)
+                    el.Add(new XAttribute(nt.Attr, Str(ShapeReflection.Get(src, nt.AttrProperty ?? nt.Attr))));
+                parent.Add(el);
+                return;
+            }
+
+            case FieldChild f:
+            {
+                var fr = (FieldRef?)ShapeReflection.Get(src, f.PocoProperty ?? f.Element);
+                if (fr is null)
+                {
+                    if (!f.Optional) parent.Add(new XElement(f.Element));
+                    return;
+                }
+                if (f.VariableTextMarker && fr.IsVariable) parent.Add(new XElement("Text"));
+                parent.Add(fr.ToXml(f.Element));
+                return;
+            }
+
+            case NamedRefChild nr:
+            {
+                var r = (NamedRef?)ShapeReflection.Get(src, nr.PocoProperty ?? nr.Element);
+                if (r is null)
+                {
+                    if (!nr.Optional) parent.Add(new XElement(nr.Element));
+                    return;
+                }
+                parent.Add(r.ToXml(nr.Element));
+                return;
+            }
+
+            case ValueTypeChild vt:
+            {
+                var v = ShapeReflection.Get(src, vt.PocoProperty ?? vt.Element);
+                if (v is null) return;
+                parent.Add(InvokeToXml(v, vt.Element));
+                return;
+            }
+
+            case ParametersList pl:
+            {
+                var items = (ShapeReflection.Get(src, pl.PocoProperty ?? pl.Wrapper) as IEnumerable)?
+                    .Cast<object>().ToList() ?? new List<object>();
+                if (pl.Optional && items.Count == 0) return;
+                var wrapper = new XElement(pl.Wrapper, new XAttribute("Count", items.Count));
+                foreach (var item in items)
+                {
+                    wrapper.Add(item is Calculation c
+                        ? new XElement(pl.Child, c.ToXml())
+                        : new XElement(pl.Child, Str(item)));
+                }
+                parent.Add(wrapper);
+                return;
+            }
+
+            case WrapperChild w:
+            {
+                if (w.Optional && w.PocoProperty is not null
+                    && ShapeReflection.Get(src, w.PocoProperty) is null) return;
+                var wrapper = new XElement(w.Element);
+                foreach (var child in w.Children)
+                    Emit(wrapper, src, child);
+                parent.Add(wrapper);
+                return;
+            }
+
+            case VariantBlock vb:
+            {
+                var v = ShapeReflection.Get(src, node.PocoProperty
+                    ?? throw new InvalidOperationException("VariantBlock requires PocoProperty."));
+                if (v is null) return;
+                var match = vb.Cases.FirstOrDefault(cse => cse.WhenType.IsInstanceOfType(v))
+                    ?? throw new InvalidOperationException(
+                        $"VariantBlock has no case for runtime type {v.GetType().Name}.");
+                foreach (var child in match.Children)
+                    Emit(parent, v, child);
+                return;
+            }
+
+            case HrOnly:
+                return; // display-grammar slot; no wire form of its own
+
+            case Passthrough:
+            {
+                var v = ShapeReflection.Get(src, node.PocoProperty ?? "Passthrough");
+                if (v is StepChildBag bag) bag.AppendTo(parent);
+                else if (v is IEnumerable<XElement> extra)
+                    foreach (var x in extra)
+                        parent.Add(new XElement(x));
+                return;
+            }
+
+            default:
+                throw new NotSupportedException($"Unhandled shape node: {node.GetType().Name}");
+        }
+    }
+
+    private static readonly Dictionary<Type, MethodInfo> _toXmlCache = new();
+
+    private static XElement InvokeToXml(object value, string elementName)
+    {
+        MethodInfo method;
+        lock (_toXmlCache)
+        {
+            if (!_toXmlCache.TryGetValue(value.GetType(), out method!))
+            {
+                var withName = value.GetType().GetMethod("ToXml", new[] { typeof(string) });
+                var noArg = value.GetType().GetMethod("ToXml", Type.EmptyTypes);
+                method = withName ?? noArg
+                    ?? throw new InvalidOperationException(
+                        $"Value type {value.GetType().Name} has no ToXml() method for ValueTypeChild.");
+                _toXmlCache[value.GetType()] = method;
+            }
+        }
+        var args = method.GetParameters().Length == 1 ? new object[] { elementName } : Array.Empty<object>();
+        return (XElement)method.Invoke(value, args)!;
+    }
+
+    private static string Str(object? v) => v switch
+    {
+        null => "",
+        bool b => b ? "True" : "False",
+        _ => v.ToString() ?? "",
+    };
+
+    private static bool IsBlank(object? v) => v is null || (v is string s && s.Length == 0);
+}
diff --git a/src/SharpFM.Model/Scripting/Serialization/StepXmlValidator.cs b/src/SharpFM.Model/Scripting/Serialization/StepXmlValidator.cs
new file mode 100644
index 0000000..84afe67
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Serialization/StepXmlValidator.cs
@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
+
+namespace SharpFM.Model.Scripting.Serialization;
+
+/// <summary>
+/// Lints a <c>&lt;Step&gt;</c> element against its declared
+/// <see cref="StepMetadata.Shape"/>: every child element must be one the shape
+/// can emit, and the children must appear in shape order. This catches the
+/// element-order class of FileMaker paste failures (e.g. a <c>&lt;Name&gt;</c>
+/// that is present but not last in Set Variable) before XML reaches the
+/// clipboard. Optional children may be absent; unknown trailing children are
+/// permitted only when the shape declares a <see cref="Passthrough"/> slot.
+/// </summary>
+public static class StepXmlValidator
+{
+    public static IReadOnlyList<string> Validate(XElement step, StepMetadata meta)
+    {
+        var issues = new List<string>();
+        var expected = ExpectedElementOrder(meta.Shape);
+        var allowsPassthrough = meta.Shape.Any(n => n is Passthrough);
+
+        int cursor = 0;
+        foreach (var child in step.Elements())
+        {
+            var name = child.Name.LocalName;
+            var found = false;
+            for (int i = cursor; i < expected.Count; i++)
+            {
+                if (expected[i] == name) { cursor = i + 1; found = true; break; }
+            }
+            if (!found)
+            {
+                if (allowsPassthrough && !expected.Contains(name)) continue; // unmodeled child preserved verbatim
+                issues.Add(expected.Contains(name)
+                    ? $"<{name}> is out of canonical order for step '{meta.Name}'."
+                    : $"<{name}> is not a recognized child of step '{meta.Name}'.");
+            }
+        }
+        return issues;
+    }
+
+    /// <summary>
+    /// The ordered element names the shape can emit. <see cref="AttributeNode"/>
+    /// contributes nothing (it is a Step-level attribute). A
+    /// <see cref="VariantBlock"/> contributes its cases' element names in order
+    /// (any case may be the one present).
+    /// </summary>
+    private static IReadOnlyList<string> ExpectedElementOrder(IReadOnlyList<ShapeNode> shape)
+    {
+        var names = new List<string>();
+        foreach (var node in shape)
+            names.AddRange(ElementNamesOf(node));
+        return names;
+    }
+
+    /// <summary>The XML element names a single shape node can emit (empty for attribute/step-level nodes).</summary>
+    public static IEnumerable<string> ElementNamesOf(ShapeNode node) => node switch
+    {
+        AttributeNode or Passthrough => [],
+        BoolStateChild b => [b.Element],
+        EnumValueChild e => [e.Element],
+        FlagChild fl => [fl.Element],
+        BareCalcChild => ["Calculation"],
+        NamedCalcChild nc => [nc.Element],
+        NamedTextChild nt => [nt.Element],
+        FieldChild f => [f.Element],
+        NamedRefChild nr => [nr.Element],
+        ValueTypeChild vt => [vt.Element],
+        ParametersList pl => [pl.Wrapper],
+        WrapperChild w => [w.Element],
+        VariantBlock vb => vb.Cases.SelectMany(c => c.Children.SelectMany(ElementNamesOf)),
+        _ => [],
+    };
+}
diff --git a/src/SharpFM.Model/Scripting/Shapes/ShapeHrView.cs b/src/SharpFM.Model/Scripting/Shapes/ShapeHrView.cs
new file mode 100644
index 0000000..3f9b8e0
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Shapes/ShapeHrView.cs
@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SharpFM.Model.Scripting.Shapes;
+
+/// <summary>
+/// Human-readable projection of a step's <c>Shape</c> for the display-text
+/// consumers (param synthesis, script validation, editor completion). The
+/// shape lists nodes in XML order; display lines put FileMaker-native tokens
+/// first and SharpFM's augmented <c>[Label: value]</c> tokens after, so this
+/// view re-orders accordingly and drops wire-only plumbing.
+/// </summary>
+public static class ShapeHrView
+{
+    /// <summary>
+    /// Display-ordered, flattened parameter slots: <see cref="DisplayMode.Native"/>
+    /// nodes first (in shape order), then <see cref="DisplayMode.Augmented"/>;
+    /// <see cref="DisplayMode.Hidden"/> nodes are excluded. Wrapper children
+    /// flatten into the list (they bind the owning step's properties); a
+    /// <see cref="VariantBlock"/> contributes itself as a single slot;
+    /// <see cref="Passthrough"/> and <see cref="AttributeNode"/> are wire-only
+    /// and never surface.
+    /// </summary>
+    public static IReadOnlyList<ShapeNode> HrNodes(IReadOnlyList<ShapeNode> shape)
+    {
+        var flat = new List<ShapeNode>();
+        Flatten(shape, flat);
+        return flat.Where(n => n.Display == DisplayMode.Native)
+            .Concat(flat.Where(n => n.Display == DisplayMode.Augmented))
+            .ToList();
+    }
+
+    private static void Flatten(IReadOnlyList<ShapeNode> shape, List<ShapeNode> into)
+    {
+        foreach (var node in shape)
+        {
+            switch (node)
+            {
+                case Passthrough or AttributeNode:
+                    continue;
+                case WrapperChild w:
+                    Flatten(w.Children, into);
+                    continue;
+                default:
+                    if (node.Display != DisplayMode.Hidden) into.Add(node);
+                    continue;
+            }
+        }
+    }
+
+    /// <summary>Canonical parameter name of a slot: the bound property, falling back to its primary element.</summary>
+    public static string NameOf(ShapeNode node) => node switch
+    {
+        HrOnly h => h.Name,
+        _ => node.PocoProperty ?? PrimaryElementOf(node) ?? "",
+    };
+
+    /// <summary>
+    /// True when <paramref name="key"/> addresses this slot. Callers may use
+    /// the bound property name, the XML element name, or the display label —
+    /// all case-insensitive — so pre-cutover param names keep working.
+    /// </summary>
+    public static bool MatchesName(ShapeNode node, string key) =>
+        string.Equals(NameOf(node), key, StringComparison.OrdinalIgnoreCase)
+        || string.Equals(node.HrLabel, key, StringComparison.OrdinalIgnoreCase)
+        || Serialization.StepXmlValidator.ElementNamesOf(node)
+            .Any(e => string.Equals(e, key, StringComparison.OrdinalIgnoreCase));
+
+    /// <summary>True for presence/state booleans, whose display values are On/Off.</summary>
+    public static bool IsBooleanLike(ShapeNode node) =>
+        node is BoolStateChild or FlagChild or HrOnly { Boolean: true };
+
+    /// <summary>
+    /// Valid display-text values for completion and validation: the node's
+    /// <see cref="ShapeNode.DisplayValues"/> when the display forms differ from
+    /// the wire forms, On/Off for boolean-like nodes, then the wire
+    /// <see cref="ShapeNode.ValidValues"/>.
+    /// </summary>
+    public static IReadOnlyList<string> DisplayValuesOf(ShapeNode node)
+    {
+        if (node.DisplayValues is { Count: > 0 } dv) return dv;
+        if (IsBooleanLike(node)) return new[] { "On", "Off" };
+        return node.ValidValues ?? Array.Empty<string>();
+    }
+
+    /// <summary>Short kind label shown as the completion description.</summary>
+    public static string KindOf(ShapeNode node) => node switch
+    {
+        HrOnly h => h.Boolean ? "boolean" : "option",
+        FlagChild => "flag",
+        BoolStateChild => "boolean",
+        EnumValueChild => "enum",
+        BareCalcChild or NamedCalcChild => "calculation",
+        NamedTextChild => "text",
+        FieldChild => "field",
+        NamedRefChild => "reference",
+        ValueTypeChild => "options",
+        ParametersList => "parameters",
+        VariantBlock => "target",
+        _ => "value",
+    };
+
+    private static string? PrimaryElementOf(ShapeNode node) =>
+        Serialization.StepXmlValidator.ElementNamesOf(node).FirstOrDefault();
+}
diff --git a/src/SharpFM.Model/Scripting/Shapes/ShapeNode.cs b/src/SharpFM.Model/Scripting/Shapes/ShapeNode.cs
new file mode 100644
index 0000000..b01eada
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Shapes/ShapeNode.cs
@@ -0,0 +1,252 @@
+using System;
+using System.Collections.Generic;
+
+namespace SharpFM.Model.Scripting.Shapes;
+
+/// <summary>
+/// How a shape node's value participates in the human-readable display line
+/// SharpFM renders for a step. FileMaker Pro's own script display is lossy —
+/// it hides values the XML carries (options, repetitions, targets) behind its
+/// UI. Because SharpFM is an XML-faithful editor it must surface those hidden
+/// values with an invented but <em>consistent</em> syntax so they stay visible
+/// and editable.
+/// </summary>
+public enum DisplayMode
+{
+    /// <summary>Rendered the way FileMaker Pro shows it.</summary>
+    Native,
+
+    /// <summary>
+    /// FileMaker Pro's UI hides this value, but the XML carries it. SharpFM
+    /// surfaces it through one uniform convention (a trailing
+    /// <c>[HrLabel: value]</c> segment) applied identically across every step
+    /// that needs it.
+    /// </summary>
+    Augmented,
+
+    /// <summary>Never shown in the display line (round-tripped in XML only).</summary>
+    Hidden,
+}
+
+/// <summary>
+/// One ordered entry in a step's declarative <c>Shape</c> — the single source
+/// of truth for how a child (or step-level attribute) serializes to XML,
+/// parses back, validates, and renders in the display line. A step's
+/// <c>Shape</c> is an ordered <see cref="IReadOnlyList{ShapeNode}"/>; element
+/// order in the emitted XML matches shape order exactly, which is what fixes
+/// the canonical element-order requirements FileMaker's paste handler enforces.
+///
+/// <para>
+/// The base carries the display/agent-facing metadata (<see cref="HrLabel"/>,
+/// <see cref="Required"/>, <see cref="ValidValues"/>, <see cref="DisplayValues"/>,
+/// <see cref="DefaultValue"/>, <see cref="Description"/>) so each shape entry is
+/// the single description of both its wire emission and its human-readable
+/// role. Concrete records add the per-kind emission rule.
+/// </para>
+///
+/// <para>
+/// <see cref="PocoProperty"/> binds the node to a property on the step POCO by
+/// name (resolved by the renderer/parser via cached reflection). When omitted
+/// it defaults to the node's element/attribute name, which is the common case
+/// (element <c>Name</c> ↔ property <c>Name</c>).
+/// </para>
+/// </summary>
+public abstract record ShapeNode
+{
+    /// <summary>POCO property this node reads/writes. Defaults to the node's element/attribute name.</summary>
+    public string? PocoProperty { get; init; }
+
+    /// <summary>Human-readable label for display text and completion.</summary>
+    public string? HrLabel { get; init; }
+
+    /// <summary>True when the child must be present in valid canonical XML.</summary>
+    public bool Required { get; init; }
+
+    /// <summary>
+    /// True when the child is emitted only if its bound value is populated /
+    /// non-default. FileMaker omits most optional children from the canonical
+    /// form of an unconfigured step and emits them once configured; this flag
+    /// is what keeps SharpFM from emitting empty placeholder elements FileMaker
+    /// does not write.
+    /// </summary>
+    public bool Optional { get; init; }
+
+    /// <summary>Closed set of permissible wire values for enum / boolean nodes.</summary>
+    public IReadOnlyList<string>? ValidValues { get; init; }
+
+    /// <summary>
+    /// Display-text forms of the permissible values when they differ from the
+    /// wire forms (e.g. View As shows "View as Form" for the wire value
+    /// "Form"). Display consumers fall back to <see cref="ValidValues"/> when
+    /// unset.
+    /// </summary>
+    public IReadOnlyList<string>? DisplayValues { get; init; }
+
+    /// <summary>Default value assumed when the child is absent.</summary>
+    public string? DefaultValue { get; init; }
+
+    /// <summary>How this node participates in the display line.</summary>
+    public DisplayMode Display { get; init; } = DisplayMode.Native;
+
+    /// <summary>
+    /// True when the display form is the logical inverse of the wire boolean —
+    /// FileMaker's <c>With dialog: On</c> is the wire's
+    /// <c>NoInteract state="False"</c>.
+    /// </summary>
+    public bool DisplayInverted { get; init; }
+
+    /// <summary>
+    /// Display text rendered when the bound value is blank, instead of
+    /// dropping the token (e.g. Close File's <c>Current File</c>; an empty
+    /// string keeps FileMaker's empty-slot token). Null drops blank tokens.
+    /// </summary>
+    public string? DisplayEmptyAs { get; init; }
+
+    /// <summary>Human-facing explanation of the value — tooltip / hover source.</summary>
+    public string? Description { get; init; }
+}
+
+/// <summary>Step-level extra attribute, e.g. <c>&lt;Step Source="MBSP" index="2" …&gt;</c> (MBS plugin).</summary>
+public sealed record AttributeNode(string AttrName) : ShapeNode;
+
+/// <summary>
+/// A boolean child carried on an attribute: <c>&lt;El state="True|False"/&gt;</c>
+/// by default, or <c>&lt;El value="True|False"/&gt;</c> when <see cref="Attr"/> is
+/// <c>"value"</c> (e.g. Add Account's <c>ChgPwdOnNextLogin</c>). Bound to a
+/// <see cref="bool"/> property.
+/// </summary>
+public sealed record BoolStateChild(string Element, string Attr = "state") : ShapeNode;
+
+/// <summary><c>&lt;El value="X"/&gt;</c> bound to a string/enum property (FlushType, PauseTime, CallbackScriptState…).</summary>
+public sealed record EnumValueChild(string Element) : ShapeNode;
+
+/// <summary>
+/// A presence-as-boolean flag element bound to a <see cref="bool"/> property:
+/// the bare element <c>&lt;El/&gt;</c> is emitted when the value is true and
+/// omitted when false (FileMaker's "flagElement" convention — e.g. Insert
+/// Embedding in Found Set's <c>Overwrite</c>/<c>ContinueOnError</c>/<c>ShowSummary</c>).
+/// </summary>
+public sealed record FlagChild(string Element) : ShapeNode;
+
+/// <summary><c>&lt;Calculation&gt;&lt;![CDATA[…]]&gt;&lt;/Calculation&gt;</c> bound to a <c>Calculation</c> property (If condition, Exit Script return).</summary>
+public sealed record BareCalcChild : ShapeNode;
+
+/// <summary>
+/// <c>&lt;El&gt;&lt;Calculation&gt;…&lt;/Calculation&gt;&lt;/El&gt;</c> bound to a
+/// <c>Calculation</c> property (Set Variable Value/Repetition; Show Custom
+/// Dialog Title/Message). Also covers the Install OnTimer Script
+/// <c>&lt;Interval&gt;&lt;Calculation&gt;</c> §7.3 trap — structurally the same
+/// rule, declared as <c>NamedCalcChild("Interval")</c>.
+/// </summary>
+public sealed record NamedCalcChild(string Element) : ShapeNode;
+
+/// <summary>
+/// <c>&lt;El&gt;text&lt;/El&gt;</c> bound to a <see cref="string"/> property —
+/// the Set Variable <c>&lt;Name&gt;$var&lt;/Name&gt;</c> §7.1/7.4 trap, plus
+/// Configure Persistent Data <c>&lt;Name&gt;</c>, Flow, Text, etc. When
+/// <see cref="Attr"/> is set the element also carries one attribute bound to
+/// its own property (e.g. Insert PDF's
+/// <c>&lt;UniversalPathList type="Embedded"&gt;path&lt;/UniversalPathList&gt;</c>).
+/// </summary>
+public sealed record NamedTextChild(string Element) : ShapeNode
+{
+    /// <summary>Attribute carried on the same element, always emitted when set.</summary>
+    public string? Attr { get; init; }
+
+    /// <summary>POCO property the attribute binds to. Defaults to <see cref="Attr"/>.</summary>
+    public string? AttrProperty { get; init; }
+
+    /// <summary>Attribute value assumed when the element or attribute is absent.</summary>
+    public string? AttrDefault { get; init; }
+}
+
+/// <summary>
+/// <c>&lt;Field table=… id=… name=…/&gt;</c> or <c>&lt;Field&gt;$var&lt;/Field&gt;</c>
+/// bound to a <c>FieldRef</c> property. When <see cref="VariableTextMarker"/> is
+/// set and the bound reference is a variable, FileMaker's bare <c>&lt;Text/&gt;</c>
+/// marker element is emitted immediately before the <c>&lt;Field&gt;</c> (Insert
+/// Calculated Result, Write to Data File, …).
+/// </summary>
+public sealed record FieldChild(string Element = "Field") : ShapeNode
+{
+    public bool VariableTextMarker { get; init; }
+}
+
+/// <summary><c>&lt;Script id=… name=…/&gt;</c>, <c>&lt;Layout …/&gt;</c>, <c>&lt;Table …/&gt;</c> bound to a <c>NamedRef</c> property.</summary>
+public sealed record NamedRefChild(string Element) : ShapeNode;
+
+/// <summary>
+/// Delegates emission/parsing to a value type's own
+/// <c>XElement ToXml(string)</c> / <c>static FromXml(XElement)</c> convention
+/// (<c>NewWindowStyles</c>, <c>Animation</c>, print-settings types…). The bound
+/// property's type owns the element's full attribute/child shape.
+/// </summary>
+public sealed record ValueTypeChild(string Element) : ShapeNode;
+
+/// <summary>
+/// <c>&lt;Parameters Count="N"&gt;&lt;P&gt;…&lt;/P&gt;…&lt;/Parameters&gt;</c>
+/// bound to a list property — the Perform JavaScript in Web Viewer §7.2 trap
+/// (parameters must be <c>&lt;P&gt;</c>, never flat <c>&lt;Parameter&gt;</c>).
+/// </summary>
+public sealed record ParametersList(string Wrapper = "Parameters", string Child = "P") : ShapeNode;
+
+/// <summary>
+/// A nested wrapper element that encloses <see cref="Children"/>, e.g. Configure
+/// RAG Account's <c>&lt;ConfigureRAGAccount&gt;</c> grouping. The wrapper is
+/// always emitted (empty when every child is omitted); children bind to the
+/// owning step's properties and their XML lookups are relative to the wrapper.
+/// With <see cref="ShapeNode.Optional"/> set, the wrapper is emitted only when
+/// the gate property named by <see cref="ShapeNode.PocoProperty"/> is non-null
+/// (e.g. Save a Copy as XML's <c>&lt;SaXML&gt;</c> block).
+/// </summary>
+public sealed record WrapperChild(string Element, IReadOnlyList<ShapeNode> Children) : ShapeNode;
+
+/// <summary>
+/// One case of a <see cref="VariantBlock"/>. Emission selects the case whose
+/// <see cref="WhenType"/> matches the bound property's runtime type. Parsing
+/// selects the first case (in declaration order) whose
+/// <see cref="MatchElement"/> is present in the step XML and — when
+/// <see cref="MatchValues"/> is set — whose <c>value</c> attribute is in that
+/// set. <see cref="MatchValues"/> may list legacy wire-value aliases alongside
+/// the canonical value; a case with no <see cref="MatchValues"/> matches on
+/// element presence alone, and a case with no <see cref="MatchElement"/> is the
+/// unconditional fallback.
+/// </summary>
+public sealed record VariantCase(Type WhenType, IReadOnlyList<ShapeNode> Children)
+{
+    /// <summary>Element whose presence selects this case during parsing.</summary>
+    public string? MatchElement { get; init; }
+
+    /// <summary>Accepted <c>value</c> attribute values on <see cref="MatchElement"/> (canonical + legacy aliases).</summary>
+    public IReadOnlyList<string>? MatchValues { get; init; }
+}
+
+/// <summary>
+/// Discriminated-union selection. Picks the <see cref="VariantCase"/> whose
+/// <see cref="VariantCase.WhenType"/> matches the bound property's runtime type
+/// and emits that case's children, which bind to the variant value's own
+/// properties. Used by <c>PerformScriptTarget</c> (ByReference vs
+/// ByCalculation) and <c>LayoutTarget</c>.
+/// </summary>
+public sealed record VariantBlock(IReadOnlyList<VariantCase> Cases) : ShapeNode;
+
+/// <summary>
+/// Preserves unrecognized child elements verbatim. Bound to a property holding
+/// captured <c>XElement</c>s so a partially-known step round-trips children the
+/// shape does not model (e.g. Print PDF <c>&lt;PlatformData&gt;</c> blobs).
+/// </summary>
+public sealed record Passthrough : ShapeNode;
+
+/// <summary>
+/// A display-grammar-only slot: emits and parses no XML of its own, but
+/// carries the label/values metadata for a display-line token whose wire form
+/// lives inside a sibling <see cref="Passthrough"/> bag or a value type's own
+/// serializer (e.g. Send Mail's To/Cc/Bcc, Enter Find Mode's stored requests).
+/// Keeps the display consumers (validation, completion, param synthesis)
+/// working for those tokens without duplicating the wire description.
+/// </summary>
+public sealed record HrOnly(string Name) : ShapeNode
+{
+    /// <summary>True when the token is an On/Off or presence flag.</summary>
+    public bool Boolean { get; init; }
+}
diff --git a/src/SharpFM.Model/Scripting/Steps/AVPlayerPlayStep.cs b/src/SharpFM.Model/Scripting/Steps/AVPlayerPlayStep.cs
index 86ecaa1..82061c5 100644
--- a/src/SharpFM.Model/Scripting/Steps/AVPlayerPlayStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/AVPlayerPlayStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,14 +14,19 @@ public sealed class AVPlayerPlayStep : ScriptStep, IStepFactory
     public const int XmlId = 177;
     public const string XmlName = "AVPlayer Play";
 
-    public string Source { get; set; }
-    public Calculation Repetition { get; set; }
-    public string Presentation { get; set; }
-    public Calculation Position { get; set; }
-    public Calculation StartOffset { get; set; }
-    public Calculation EndOffset { get; set; }
-    public bool HideControls { get; set; }
-    public bool DisableInteraction { get; set; }
+    public string Source { get; set; } = "Object Name";
+    public Calculation? Repetition { get; set; }
+    public string Presentation { get; set; } = "Start Full Screen";
+    public Calculation? Position { get; set; }
+    public Calculation? StartOffset { get; set; }
+    public Calculation? EndOffset { get; set; }
+    // HideControls/DisableInteraction emit <El value="True|False"/>. They are
+    // string-backed (not bool) so the unconfigured canonical form, which omits
+    // them, round-trips: a blank value is dropped by the Optional EnumValueChild.
+    public string HideControls { get; set; } = "";
+    public string DisableInteraction { get; set; } = "";
+
+    private AVPlayerPlayStep() : base(false) { }
 
     public AVPlayerPlayStep(
         string source = "Object Name",
@@ -28,17 +35,17 @@ public AVPlayerPlayStep(
         Calculation? position = null,
         Calculation? startOffset = null,
         Calculation? endOffset = null,
-        bool hideControls = false,
-        bool disableInteraction = false,
+        string hideControls = "",
+        string disableInteraction = "",
         bool enabled = true)
         : base(enabled)
     {
         Source = source;
-        Repetition = repetition ?? new Calculation("");
+        Repetition = repetition;
         Presentation = presentation;
-        Position = position ?? new Calculation("");
-        StartOffset = startOffset ?? new Calculation("");
-        EndOffset = endOffset ?? new Calculation("");
+        Position = position;
+        StartOffset = startOffset;
+        EndOffset = endOffset;
         HideControls = hideControls;
         DisableInteraction = disableInteraction;
     }
@@ -77,49 +84,32 @@ public AVPlayerPlayStep(
     private static string PresentationHr(string x) => _PresentationToHr.TryGetValue(x, out var h) ? h : x;
     private static string PresentationXml(string h) => _PresentationFromHr.TryGetValue(h, out var x) ? x : h;
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Source", new XAttribute("value", Source)),
-            new XElement("Repetition", Repetition.ToXml("Calculation")),
-            new XElement("Presentation", new XAttribute("value", Presentation)),
-            new XElement("PlaybackPosition", Position.ToXml("Calculation")),
-            new XElement("StartOffset", StartOffset.ToXml("Calculation")),
-            new XElement("EndOffset", EndOffset.ToXml("Calculation")),
-            new XElement("HideControls", new XAttribute("value", HideControls ? "True" : "False")),
-            new XElement("DisableInteraction", new XAttribute("value", DisableInteraction ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: Hide Controls / Disable Interaction map the wire's
+    // "True"/absent values to On/Off, a translation display metadata cannot
+    // express without widening the nodes' wire ValidValues.
     public override string ToDisplayLine() =>
-        "AVPlayer Play [ " + SourceHr(Source) + " ; " + "Repetition: " + Repetition.Text + " ; " + "Presentation: " + PresentationHr(Presentation) + " ; " + "Position: " + Position.Text + " ; " + "Start Offset: " + StartOffset.Text + " ; " + "End Offset: " + EndOffset.Text + " ; " + "Hide Controls: " + (HideControls ? "On" : "Off") + " ; " + "Disable Interaction: " + (DisableInteraction ? "On" : "Off") + " ]";
+        "AVPlayer Play [ " + SourceHr(Source) + " ; " + "Repetition: " + (Repetition?.Text ?? "") + " ; " + "Presentation: " + PresentationHr(Presentation) + " ; " + "Position: " + (Position?.Text ?? "") + " ; " + "Start Offset: " + (StartOffset?.Text ?? "") + " ; " + "End Offset: " + (EndOffset?.Text ?? "") + " ; " + "Hide Controls: " + (HideControls == "True" ? "On" : "Off") + " ; " + "Disable Interaction: " + (DisableInteraction == "True" ? "On" : "Off") + " ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var source_v = step.Element("Source")?.Attribute("value")?.Value ?? "Object Name";
-        var repetition_vWrapEl = step.Element("Repetition");
-        var repetition_vCalcEl = repetition_vWrapEl?.Element("Calculation");
-        var repetition_v = repetition_vCalcEl is not null ? Calculation.FromXml(repetition_vCalcEl) : new Calculation("");
-        var presentation_v = step.Element("Presentation")?.Attribute("value")?.Value ?? "Start Full Screen";
-        var position_vWrapEl = step.Element("PlaybackPosition");
-        var position_vCalcEl = position_vWrapEl?.Element("Calculation");
-        var position_v = position_vCalcEl is not null ? Calculation.FromXml(position_vCalcEl) : new Calculation("");
-        var startOffset_vWrapEl = step.Element("StartOffset");
-        var startOffset_vCalcEl = startOffset_vWrapEl?.Element("Calculation");
-        var startOffset_v = startOffset_vCalcEl is not null ? Calculation.FromXml(startOffset_vCalcEl) : new Calculation("");
-        var endOffset_vWrapEl = step.Element("EndOffset");
-        var endOffset_vCalcEl = endOffset_vWrapEl?.Element("Calculation");
-        var endOffset_v = endOffset_vCalcEl is not null ? Calculation.FromXml(endOffset_vCalcEl) : new Calculation("");
-        var hideControls_v = step.Element("HideControls")?.Attribute("value")?.Value == "True";
-        var disableInteraction_v = step.Element("DisableInteraction")?.Attribute("value")?.Value == "True";
-        return new AVPlayerPlayStep(source_v, repetition_v, presentation_v, position_v, startOffset_v, endOffset_v, hideControls_v, disableInteraction_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<AVPlayerPlayStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when a toggle is explicitly stored
+    /// as False: the display renders both the absent and the explicit-False
+    /// forms as "Off", so a parsed "Off" maps to absent.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        HideControls != "False" && DisableInteraction != "False";
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        string source_v = "Object Name";
+        // The leading unlabeled token is the source enum.
+        string source_v = tokens.Length > 0 && !tokens[0].Contains(':')
+            ? SourceXml(tokens[0])
+            : "Object Name";
         Calculation? repetition_v = null;
         foreach (var tok in tokens) { if (tok.StartsWith("Repetition:", StringComparison.OrdinalIgnoreCase)) { repetition_v = new Calculation(tok.Substring(11).Trim()); break; } }
         string presentation_v = "Start Full Screen";
@@ -130,10 +120,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         foreach (var tok in tokens) { if (tok.StartsWith("Start Offset:", StringComparison.OrdinalIgnoreCase)) { startOffset_v = new Calculation(tok.Substring(13).Trim()); break; } }
         Calculation? endOffset_v = null;
         foreach (var tok in tokens) { if (tok.StartsWith("End Offset:", StringComparison.OrdinalIgnoreCase)) { endOffset_v = new Calculation(tok.Substring(11).Trim()); break; } }
-        bool hideControls_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Hide Controls:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(14).Trim(); hideControls_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool disableInteraction_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Disable Interaction:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(20).Trim(); disableInteraction_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
+        // "Off" is ambiguous between absent and explicit False; it maps to
+        // absent (explicit-False instances are sealed).
+        string hideControls_v = "";
+        foreach (var tok in tokens) { if (tok.StartsWith("Hide Controls:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(14).Trim(); hideControls_v = v.Equals("On", StringComparison.OrdinalIgnoreCase) ? "True" : ""; break; } }
+        string disableInteraction_v = "";
+        foreach (var tok in tokens) { if (tok.StartsWith("Disable Interaction:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(20).Trim(); disableInteraction_v = v.Equals("On", StringComparison.OrdinalIgnoreCase) ? "True" : ""; break; } }
         return new AVPlayerPlayStep(source_v, repetition_v, presentation_v, position_v, startOffset_v, endOffset_v, hideControls_v, disableInteraction_v, enabled);
     }
 
@@ -143,74 +135,20 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/avplayer-play.html",
-        Params =
+        // Canonical form carries only Source; every other option element is
+        // omitted until configured, so all but Source are Optional. HideControls
+        // and DisableInteraction use a value="True|False" attribute and are
+        // modeled as EnumValueChild over a string so they can be dropped.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Source",
-                XmlElement = "Source",
-                Type = "enum",
-                XmlAttr = "value",
-                ValidValues = ["Object Name", "Field", "URL"],
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Repetition",
-            },
-            new ParamMetadata
-            {
-                Name = "Presentation",
-                XmlElement = "Presentation",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Presentation",
-                ValidValues = ["Start Full Screen", "Full Screen Only", "Start Embedded", "Embedded Only", "Audio Only"],
-                DefaultValue = "Start Full Screen",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Position",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Start Offset",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "End Offset",
-            },
-            new ParamMetadata
-            {
-                Name = "HideControls",
-                XmlElement = "HideControls",
-                Type = "boolean",
-                XmlAttr = "value",
-                HrLabel = "Hide Controls",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "DisableInteraction",
-                XmlElement = "DisableInteraction",
-                Type = "boolean",
-                XmlAttr = "value",
-                HrLabel = "Disable Interaction",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
+            new EnumValueChild("Source") { PocoProperty = "Source", ValidValues = ["Object Name", "Field", "URL"] },
+            new NamedCalcChild("Repetition") { PocoProperty = "Repetition", HrLabel = "Repetition", Optional = true },
+            new EnumValueChild("Presentation") { PocoProperty = "Presentation", HrLabel = "Presentation", Optional = true, DisplayValues = ["Start Full Screen", "Full Screen Only", "Start Embedded", "Embedded Only", "Audio Only"] },
+            new NamedCalcChild("PlaybackPosition") { PocoProperty = "Position", HrLabel = "Position", Optional = true },
+            new NamedCalcChild("StartOffset") { PocoProperty = "StartOffset", HrLabel = "Start Offset", Optional = true },
+            new NamedCalcChild("EndOffset") { PocoProperty = "EndOffset", HrLabel = "End Offset", Optional = true },
+            new EnumValueChild("HideControls") { PocoProperty = "HideControls", HrLabel = "Hide Controls", Optional = true, DisplayValues = ["On", "Off"] },
+            new EnumValueChild("DisableInteraction") { PocoProperty = "DisableInteraction", HrLabel = "Disable Interaction", Optional = true, DisplayValues = ["On", "Off"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/AVPlayerSetOptionsStep.cs b/src/SharpFM.Model/Scripting/Steps/AVPlayerSetOptionsStep.cs
index ed0fe80..7998481 100644
--- a/src/SharpFM.Model/Scripting/Steps/AVPlayerSetOptionsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/AVPlayerSetOptionsStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,24 +14,29 @@ public sealed class AVPlayerSetOptionsStep : ScriptStep, IStepFactory
     public const int XmlId = 179;
     public const string XmlName = "AVPlayer Set Options";
 
-    public string Presentation { get; set; }
-    public bool DisableInteraction { get; set; }
-    public bool HideControls { get; set; }
-    public bool DisableExternalControls { get; set; }
-    public bool PauseInBackground { get; set; }
-    public Calculation Position { get; set; }
-    public Calculation StartOffset { get; set; }
-    public Calculation EndOffset { get; set; }
-    public Calculation Volume { get; set; }
-    public string Zoom { get; set; }
-    public string Sequence { get; set; }
+    public string Presentation { get; set; } = "Start Full Screen";
+    // The four toggle options emit <El value="True|False"/>. They are
+    // string-backed (not bool) so the unconfigured canonical form, which omits
+    // them entirely, round-trips: a blank value is dropped by Optional EnumValueChild.
+    public string DisableInteraction { get; set; } = "";
+    public string HideControls { get; set; } = "";
+    public string DisableExternalControls { get; set; } = "";
+    public string PauseInBackground { get; set; } = "";
+    public Calculation? Position { get; set; }
+    public Calculation? StartOffset { get; set; }
+    public Calculation? EndOffset { get; set; }
+    public Calculation? Volume { get; set; }
+    public string Zoom { get; set; } = "Fit";
+    public string Sequence { get; set; } = "None";
+
+    private AVPlayerSetOptionsStep() : base(false) { }
 
     public AVPlayerSetOptionsStep(
         string presentation = "Start Full Screen",
-        bool disableInteraction = false,
-        bool hideControls = false,
-        bool disableExternalControls = false,
-        bool pauseInBackground = false,
+        string disableInteraction = "",
+        string hideControls = "",
+        string disableExternalControls = "",
+        string pauseInBackground = "",
         Calculation? position = null,
         Calculation? startOffset = null,
         Calculation? endOffset = null,
@@ -44,10 +51,10 @@ public AVPlayerSetOptionsStep(
         HideControls = hideControls;
         DisableExternalControls = disableExternalControls;
         PauseInBackground = pauseInBackground;
-        Position = position ?? new Calculation("");
-        StartOffset = startOffset ?? new Calculation("");
-        EndOffset = endOffset ?? new Calculation("");
-        Volume = volume ?? new Calculation("");
+        Position = position;
+        StartOffset = startOffset;
+        EndOffset = endOffset;
+        Volume = volume;
         Zoom = zoom;
         Sequence = sequence;
     }
@@ -107,64 +114,40 @@ public AVPlayerSetOptionsStep(
     private static string SequenceHr(string x) => _SequenceToHr.TryGetValue(x, out var h) ? h : x;
     private static string SequenceXml(string h) => _SequenceFromHr.TryGetValue(h, out var x) ? x : h;
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Presentation", new XAttribute("value", Presentation)),
-            new XElement("DisableInteraction", new XAttribute("value", DisableInteraction ? "True" : "False")),
-            new XElement("HideControls", new XAttribute("value", HideControls ? "True" : "False")),
-            new XElement("DisableExternalControls", new XAttribute("value", DisableExternalControls ? "True" : "False")),
-            new XElement("PauseInBackground", new XAttribute("value", PauseInBackground ? "True" : "False")),
-            new XElement("PlaybackPosition", Position.ToXml("Calculation")),
-            new XElement("StartOffset", StartOffset.ToXml("Calculation")),
-            new XElement("EndOffset", EndOffset.ToXml("Calculation")),
-            new XElement("Volume", Volume.ToXml("Calculation")),
-            new XElement("Zoom", new XAttribute("value", Zoom)),
-            new XElement("Sequence", new XAttribute("value", Sequence)));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: option toggles map the wire's "True"/absent values to
+    // On/Off, a translation display metadata cannot express.
     public override string ToDisplayLine() =>
-        "AVPlayer Set Options [ " + "Presentation: " + PresentationHr(Presentation) + " ; " + "Disable Interaction: " + (DisableInteraction ? "On" : "Off") + " ; " + "Hide Controls: " + (HideControls ? "On" : "Off") + " ; " + "Disable External Controls: " + (DisableExternalControls ? "On" : "Off") + " ; " + "Pause in Background: " + (PauseInBackground ? "On" : "Off") + " ; " + "Position: " + Position.Text + " ; " + "Start Offset: " + StartOffset.Text + " ; " + "End Offset: " + EndOffset.Text + " ; " + "Volume: " + Volume.Text + " ; " + "Zoom: " + ZoomHr(Zoom) + " ; " + "Sequence: " + SequenceHr(Sequence) + " ]";
+        "AVPlayer Set Options [ " + "Presentation: " + PresentationHr(Presentation) + " ; " + "Disable Interaction: " + (DisableInteraction == "True" ? "On" : "Off") + " ; " + "Hide Controls: " + (HideControls == "True" ? "On" : "Off") + " ; " + "Disable External Controls: " + (DisableExternalControls == "True" ? "On" : "Off") + " ; " + "Pause in Background: " + (PauseInBackground == "True" ? "On" : "Off") + " ; " + "Position: " + (Position?.Text ?? "") + " ; " + "Start Offset: " + (StartOffset?.Text ?? "") + " ; " + "End Offset: " + (EndOffset?.Text ?? "") + " ; " + "Volume: " + (Volume?.Text ?? "") + " ; " + "Zoom: " + ZoomHr(Zoom) + " ; " + "Sequence: " + SequenceHr(Sequence) + " ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var presentation_v = step.Element("Presentation")?.Attribute("value")?.Value ?? "Start Full Screen";
-        var disableInteraction_v = step.Element("DisableInteraction")?.Attribute("value")?.Value == "True";
-        var hideControls_v = step.Element("HideControls")?.Attribute("value")?.Value == "True";
-        var disableExternalControls_v = step.Element("DisableExternalControls")?.Attribute("value")?.Value == "True";
-        var pauseInBackground_v = step.Element("PauseInBackground")?.Attribute("value")?.Value == "True";
-        var position_vWrapEl = step.Element("PlaybackPosition");
-        var position_vCalcEl = position_vWrapEl?.Element("Calculation");
-        var position_v = position_vCalcEl is not null ? Calculation.FromXml(position_vCalcEl) : new Calculation("");
-        var startOffset_vWrapEl = step.Element("StartOffset");
-        var startOffset_vCalcEl = startOffset_vWrapEl?.Element("Calculation");
-        var startOffset_v = startOffset_vCalcEl is not null ? Calculation.FromXml(startOffset_vCalcEl) : new Calculation("");
-        var endOffset_vWrapEl = step.Element("EndOffset");
-        var endOffset_vCalcEl = endOffset_vWrapEl?.Element("Calculation");
-        var endOffset_v = endOffset_vCalcEl is not null ? Calculation.FromXml(endOffset_vCalcEl) : new Calculation("");
-        var volume_vWrapEl = step.Element("Volume");
-        var volume_vCalcEl = volume_vWrapEl?.Element("Calculation");
-        var volume_v = volume_vCalcEl is not null ? Calculation.FromXml(volume_vCalcEl) : new Calculation("");
-        var zoom_v = step.Element("Zoom")?.Attribute("value")?.Value ?? "Fit";
-        var sequence_v = step.Element("Sequence")?.Attribute("value")?.Value ?? "None";
-        return new AVPlayerSetOptionsStep(presentation_v, disableInteraction_v, hideControls_v, disableExternalControls_v, pauseInBackground_v, position_v, startOffset_v, endOffset_v, volume_v, zoom_v, sequence_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<AVPlayerSetOptionsStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when a toggle is explicitly stored
+    /// as False: the display renders both the absent and the explicit-False
+    /// forms as "Off", so a parsed "Off" maps to absent.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        DisableInteraction != "False" && HideControls != "False"
+        && DisableExternalControls != "False" && PauseInBackground != "False";
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         var tokens = hrParams.Select(h => h.Trim()).ToArray();
         string presentation_v = "Start Full Screen";
         foreach (var tok in tokens) { if (tok.StartsWith("Presentation:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(13).Trim(); presentation_v = PresentationXml(v); break; } }
-        bool disableInteraction_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Disable Interaction:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(20).Trim(); disableInteraction_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool hideControls_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Hide Controls:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(14).Trim(); hideControls_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool disableExternalControls_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Disable External Controls:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(26).Trim(); disableExternalControls_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool pauseInBackground_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Pause in Background:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(20).Trim(); pauseInBackground_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
+        // "Off" is ambiguous between absent and explicit False; it maps to
+        // absent (explicit-False instances are sealed).
+        string disableInteraction_v = "";
+        foreach (var tok in tokens) { if (tok.StartsWith("Disable Interaction:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(20).Trim(); disableInteraction_v = v.Equals("On", StringComparison.OrdinalIgnoreCase) ? "True" : ""; break; } }
+        string hideControls_v = "";
+        foreach (var tok in tokens) { if (tok.StartsWith("Hide Controls:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(14).Trim(); hideControls_v = v.Equals("On", StringComparison.OrdinalIgnoreCase) ? "True" : ""; break; } }
+        string disableExternalControls_v = "";
+        foreach (var tok in tokens) { if (tok.StartsWith("Disable External Controls:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(26).Trim(); disableExternalControls_v = v.Equals("On", StringComparison.OrdinalIgnoreCase) ? "True" : ""; break; } }
+        string pauseInBackground_v = "";
+        foreach (var tok in tokens) { if (tok.StartsWith("Pause in Background:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(20).Trim(); pauseInBackground_v = v.Equals("On", StringComparison.OrdinalIgnoreCase) ? "True" : ""; break; } }
         Calculation? position_v = null;
         foreach (var tok in tokens) { if (tok.StartsWith("Position:", StringComparison.OrdinalIgnoreCase)) { position_v = new Calculation(tok.Substring(9).Trim()); break; } }
         Calculation? startOffset_v = null;
@@ -186,106 +169,22 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/avplayer-set-options.html",
-        Params =
+        // Canonical unconfigured form is empty: every option is Optional. The four
+        // toggle options use a value="True|False" attribute and are modeled as
+        // EnumValueChild over a string so a blank (unconfigured) value is dropped.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Presentation",
-                XmlElement = "Presentation",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Presentation",
-                ValidValues = ["Start Full Screen", "Full Screen Only", "Start Embedded", "Embedded Only", "Audio Only"],
-                DefaultValue = "Start Full Screen",
-            },
-            new ParamMetadata
-            {
-                Name = "DisableInteraction",
-                XmlElement = "DisableInteraction",
-                Type = "boolean",
-                XmlAttr = "value",
-                HrLabel = "Disable Interaction",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "HideControls",
-                XmlElement = "HideControls",
-                Type = "boolean",
-                XmlAttr = "value",
-                HrLabel = "Hide Controls",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "DisableExternalControls",
-                XmlElement = "DisableExternalControls",
-                Type = "boolean",
-                XmlAttr = "value",
-                HrLabel = "Disable External Controls",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "PauseInBackground",
-                XmlElement = "PauseInBackground",
-                Type = "boolean",
-                XmlAttr = "value",
-                HrLabel = "Pause in Background",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Position",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Start Offset",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "End Offset",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Volume",
-            },
-            new ParamMetadata
-            {
-                Name = "Zoom",
-                XmlElement = "Zoom",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Zoom",
-                ValidValues = ["Fit", "Fill", "Stretch", "Fit Only", "Fill Only", "Stretch Only"],
-                DefaultValue = "Fit",
-            },
-            new ParamMetadata
-            {
-                Name = "Sequence",
-                XmlElement = "Sequence",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Sequence",
-                ValidValues = ["None", "Next", "Previous"],
-                DefaultValue = "None",
-            },
+            new EnumValueChild("Presentation") { PocoProperty = "Presentation", HrLabel = "Presentation", Optional = true, DisplayValues = ["Start Full Screen", "Full Screen Only", "Start Embedded", "Embedded Only", "Audio Only"] },
+            new EnumValueChild("DisableInteraction") { PocoProperty = "DisableInteraction", HrLabel = "Disable Interaction", Optional = true, DisplayValues = ["On", "Off"] },
+            new EnumValueChild("HideControls") { PocoProperty = "HideControls", HrLabel = "Hide Controls", Optional = true, DisplayValues = ["On", "Off"] },
+            new EnumValueChild("DisableExternalControls") { PocoProperty = "DisableExternalControls", HrLabel = "Disable External Controls", Optional = true, DisplayValues = ["On", "Off"] },
+            new EnumValueChild("PauseInBackground") { PocoProperty = "PauseInBackground", HrLabel = "Pause in Background", Optional = true, DisplayValues = ["On", "Off"] },
+            new NamedCalcChild("PlaybackPosition") { PocoProperty = "Position", HrLabel = "Position", Optional = true },
+            new NamedCalcChild("StartOffset") { PocoProperty = "StartOffset", HrLabel = "Start Offset", Optional = true },
+            new NamedCalcChild("EndOffset") { PocoProperty = "EndOffset", HrLabel = "End Offset", Optional = true },
+            new NamedCalcChild("Volume") { PocoProperty = "Volume", HrLabel = "Volume", Optional = true },
+            new EnumValueChild("Zoom") { PocoProperty = "Zoom", HrLabel = "Zoom", Optional = true, DisplayValues = ["Fit", "Fill", "Stretch", "Fit Only", "Fill Only", "Stretch Only"] },
+            new EnumValueChild("Sequence") { PocoProperty = "Sequence", HrLabel = "Sequence", Optional = true, DisplayValues = ["None", "Next", "Previous"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/AVPlayerSetPlaybackStateStep.cs b/src/SharpFM.Model/Scripting/Steps/AVPlayerSetPlaybackStateStep.cs
index 5ae2aa4..1d87d87 100644
--- a/src/SharpFM.Model/Scripting/Steps/AVPlayerSetPlaybackStateStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/AVPlayerSetPlaybackStateStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,7 +19,9 @@ public sealed class AVPlayerSetPlaybackStateStep : ScriptStep, IStepFactory
     public const string XmlName = "AVPlayer Set Playback State";
 
     /// <summary>The enum XML value emitted on the <c>&lt;PlaybackState&gt;</c> element.</summary>
-    public string PlaybackState { get; set; }
+    public string PlaybackState { get; set; } = "Stopped";
+
+    private AVPlayerSetPlaybackStateStep() : base(false) { }
 
     public AVPlayerSetPlaybackStateStep(string playbackState = "Stopped", bool enabled = true)
         : base(enabled)
@@ -25,51 +29,15 @@ public AVPlayerSetPlaybackStateStep(string playbackState = "Stopped", bool enabl
         PlaybackState = playbackState;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _xmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["Stopped"] = "Stopped",
-        ["Paused"] = "Paused",
-        ["Playing"] = "Playing",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _hrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["Stopped"] = "Stopped",
-        ["Paused"] = "Paused",
-        ["Playing"] = "Playing",
-    };
-
-    private static string ToHr(string xmlValue) =>
-        _xmlToHr.TryGetValue(xmlValue, out var hr) ? hr : xmlValue;
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string FromHr(string hrValue) =>
-        _hrToXml.TryGetValue(hrValue, out var xml) ? xml : hrValue;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("PlaybackState",
-                new XAttribute("value", PlaybackState)));
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<AVPlayerSetPlaybackStateStep>(step, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"AVPlayer Set Playback State [ {ToHr(PlaybackState)} ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var value = step.Element("PlaybackState")?.Attribute("value")?.Value ?? "Stopped";
-        return new AVPlayerSetPlaybackStateStep(value, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        return new AVPlayerSetPlaybackStateStep(FromHr(token), enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<AVPlayerSetPlaybackStateStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -77,17 +45,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/avplayer-set-playback-state.html",
-        Params =
+        // Single always-emitted <PlaybackState value="..."/> enum child.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "PlaybackState",
-                XmlElement = "PlaybackState",
-                Type = "enum",
-                XmlAttr = "value",
-                DefaultValue = "Stopped",
-                ValidValues = ["Stopped", "Paused", "Playing"],
-            },
+            new EnumValueChild("PlaybackState") { PocoProperty = "PlaybackState", DefaultValue = "Stopped", ValidValues = ["Stopped", "Paused", "Playing"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/AddAccountStep.cs b/src/SharpFM.Model/Scripting/Steps/AddAccountStep.cs
index bee1434..1ac442b 100644
--- a/src/SharpFM.Model/Scripting/Steps/AddAccountStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/AddAccountStep.cs
@@ -1,23 +1,30 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
+/// <summary>
+/// Add Account (134). Canonical form (skill, accounts reference):
+/// <c>&lt;ChgPwdOnNextLogin value="…"/&gt;</c> first, then an
+/// <c>&lt;AddAccount&gt;</c> wrapper holding the text <c>&lt;AccountType&gt;</c>
+/// and the optional account name / password / privilege-set fields.
+/// </summary>
 public sealed class AddAccountStep : ScriptStep, IStepFactory
 {
     public const int XmlId = 134;
     public const string XmlName = "Add Account";
 
-    public string AuthenticateVia { get; set; }
-    public Calculation AccountName { get; set; }
-    public Calculation Password { get; set; }
-    public string PrivilegeSet { get; set; }
+    public string AuthenticateVia { get; set; } = "FileMaker";
+    public Calculation AccountName { get; set; } = new("");
+    public Calculation Password { get; set; } = new("");
+    public string PrivilegeSet { get; set; } = "";
     public bool ExpirePassword { get; set; }
 
+    private AddAccountStep() : base(false) { }
+
     public AddAccountStep(
         string authenticateVia = "FileMaker",
         Calculation? accountName = null,
@@ -34,73 +41,15 @@ public AddAccountStep(
         ExpirePassword = expirePassword;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _AuthenticateViaToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal) {
-        ["FileMaker"] = "FileMaker",
-        ["External Server"] = "External Server",
-        ["Apple Account"] = "Apple Account",
-        ["Amazon"] = "Amazon",
-        ["Google"] = "Google",
-        ["Microsoft Entra ID"] = "Microsoft Entra ID",
-        ["Custom OAuth"] = "Custom OAuth",
-    };
-    private static readonly IReadOnlyDictionary<string, string> _AuthenticateViaFromHr =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {
-        ["FileMaker"] = "FileMaker",
-        ["External Server"] = "External Server",
-        ["Apple Account"] = "Apple Account",
-        ["Amazon"] = "Amazon",
-        ["Google"] = "Google",
-        ["Microsoft Entra ID"] = "Microsoft Entra ID",
-        ["Custom OAuth"] = "Custom OAuth",
-    };
-    private static string AuthenticateViaHr(string x) => _AuthenticateViaToHr.TryGetValue(x, out var h) ? h : x;
-    private static string AuthenticateViaXml(string h) => _AuthenticateViaFromHr.TryGetValue(h, out var x) ? x : h;
-
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("AccountType", new XAttribute("value", AuthenticateVia)),
-            new XElement("AccountName", AccountName.ToXml("Calculation")),
-            new XElement("Password", Password.ToXml("Calculation")),
-            new XElement("PrivilegeSet", PrivilegeSet),
-            new XElement("ChgPwdOnNextLogin", new XAttribute("value", ExpirePassword ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Add Account [ " + "Authenticate via: " + AuthenticateViaHr(AuthenticateVia) + " ; " + "Account Name: " + AccountName.Text + " ; " + "Password: " + Password.Text + " ; " + "Privilege Set: " + PrivilegeSet + " ; " + "Expire password: " + (ExpirePassword ? "On" : "Off") + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var authenticateVia_v = step.Element("AccountType")?.Attribute("value")?.Value ?? "FileMaker";
-        var accountName_vWrapEl = step.Element("AccountName");
-        var accountName_vCalcEl = accountName_vWrapEl?.Element("Calculation");
-        var accountName_v = accountName_vCalcEl is not null ? Calculation.FromXml(accountName_vCalcEl) : new Calculation("");
-        var password_vWrapEl = step.Element("Password");
-        var password_vCalcEl = password_vWrapEl?.Element("Calculation");
-        var password_v = password_vCalcEl is not null ? Calculation.FromXml(password_vCalcEl) : new Calculation("");
-        var privilegeSet_v = step.Element("PrivilegeSet")?.Value ?? "";
-        var expirePassword_v = step.Element("ChgPwdOnNextLogin")?.Attribute("value")?.Value == "True";
-        return new AddAccountStep(authenticateVia_v, accountName_v, password_v, privilegeSet_v, expirePassword_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<AddAccountStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        string authenticateVia_v = "FileMaker";
-        foreach (var tok in tokens) { if (tok.StartsWith("Authenticate via:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(17).Trim(); authenticateVia_v = AuthenticateViaXml(v); break; } }
-        Calculation? accountName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Account Name:", StringComparison.OrdinalIgnoreCase)) { accountName_v = new Calculation(tok.Substring(13).Trim()); break; } }
-        Calculation? password_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Password:", StringComparison.OrdinalIgnoreCase)) { password_v = new Calculation(tok.Substring(9).Trim()); break; } }
-        string privilegeSet_v = "";
-        foreach (var tok in tokens) { if (tok.StartsWith("Privilege Set:", StringComparison.OrdinalIgnoreCase)) { privilegeSet_v = tok.Substring(14).Trim(); break; } }
-        bool expirePassword_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Expire password:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(16).Trim(); expirePassword_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        return new AddAccountStep(authenticateVia_v, accountName_v, password_v, privilegeSet_v, expirePassword_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<AddAccountStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -108,48 +57,18 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "accounts",
         HelpUrl = "https://help.claris.com/en/pro-help/content/add-account.html",
-        Params =
+        // Canonical: ChgPwdOnNextLogin (value attr) first, then the <AddAccount>
+        // wrapper with text <AccountType> and the optional account fields.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "AccountType",
-                XmlElement = "AccountType",
-                Type = "enum",
-                HrLabel = "Authenticate via",
-                ValidValues = ["FileMaker", "External Server", "Apple Account", "Amazon", "Google", "Microsoft Entra ID", "Custom OAuth"],
-                DefaultValue = "FileMaker",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Account Name",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Password",
-            },
-            new ParamMetadata
-            {
-                Name = "PrivilegeSet",
-                XmlElement = "PrivilegeSet",
-                Type = "text",
-                HrLabel = "Privilege Set",
-            },
-            new ParamMetadata
-            {
-                Name = "ChgPwdOnNextLogin",
-                XmlElement = "ChgPwdOnNextLogin",
-                Type = "boolean",
-                XmlAttr = "value",
-                HrLabel = "Expire password",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
+            new BoolStateChild("ChgPwdOnNextLogin", "value") { PocoProperty = "ExpirePassword", HrLabel = "Expire password", Display = DisplayMode.Augmented },
+            new WrapperChild("AddAccount",
+            [
+                new NamedTextChild("AccountType") { PocoProperty = "AuthenticateVia", HrLabel = "Authenticate via", DefaultValue = "FileMaker", DisplayValues = ["FileMaker", "External Server", "Apple Account", "Amazon", "Google", "Microsoft Entra ID", "Custom OAuth"], Display = DisplayMode.Native },
+                new NamedCalcChild("AccountName") { PocoProperty = "AccountName", HrLabel = "Account Name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+                new NamedCalcChild("Password") { PocoProperty = "Password", HrLabel = "Password", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+                new NamedTextChild("PrivilegeSet") { PocoProperty = "PrivilegeSet", HrLabel = "Privilege Set", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            ]),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/AdjustWindowStep.cs b/src/SharpFM.Model/Scripting/Steps/AdjustWindowStep.cs
index 80094bf..cecc82f 100644
--- a/src/SharpFM.Model/Scripting/Steps/AdjustWindowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/AdjustWindowStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,7 +19,9 @@ public sealed class AdjustWindowStep : ScriptStep, IStepFactory
     public const string XmlName = "Adjust Window";
 
     /// <summary>The enum XML value emitted on the <c>&lt;WindowState&gt;</c> element.</summary>
-    public string WindowState { get; set; }
+    public string WindowState { get; set; } = "ResizeToFit";
+
+    private AdjustWindowStep() : base(false) { }
 
     public AdjustWindowStep(string windowState = "ResizeToFit", bool enabled = true)
         : base(enabled)
@@ -25,55 +29,15 @@ public AdjustWindowStep(string windowState = "ResizeToFit", bool enabled = true)
         WindowState = windowState;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _xmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["Resize to Fit"] = "Resize to Fit",
-        ["Maximize"] = "Maximize",
-        ["Minimize"] = "Minimize",
-        ["Restore"] = "Restore",
-        ["Hide"] = "Hide",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _hrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["Resize to Fit"] = "Resize to Fit",
-        ["Maximize"] = "Maximize",
-        ["Minimize"] = "Minimize",
-        ["Restore"] = "Restore",
-        ["Hide"] = "Hide",
-    };
-
-    private static string ToHr(string xmlValue) =>
-        _xmlToHr.TryGetValue(xmlValue, out var hr) ? hr : xmlValue;
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string FromHr(string hrValue) =>
-        _hrToXml.TryGetValue(hrValue, out var xml) ? xml : hrValue;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("WindowState",
-                new XAttribute("value", WindowState)));
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<AdjustWindowStep>(step, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Adjust Window [ {ToHr(WindowState)} ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var value = step.Element("WindowState")?.Attribute("value")?.Value ?? "ResizeToFit";
-        return new AdjustWindowStep(value, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        return new AdjustWindowStep(FromHr(token), enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<AdjustWindowStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -81,17 +45,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/adjust-window.html",
-        Params =
+        // Single always-emitted <WindowState value="..."/> enum child.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "WindowState",
-                XmlElement = "WindowState",
-                Type = "enum",
-                XmlAttr = "value",
-                DefaultValue = "ResizeToFit",
-                ValidValues = ["Resize to Fit", "Maximize", "Minimize", "Restore", "Hide"],
-            },
+            new EnumValueChild("WindowState") { PocoProperty = "WindowState", DefaultValue = "ResizeToFit", ValidValues = ["Resize to Fit", "Maximize", "Minimize", "Restore", "Hide"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/AllowFormattingBarStep.cs b/src/SharpFM.Model/Scripting/Steps/AllowFormattingBarStep.cs
index 03410fa..d167832 100644
--- a/src/SharpFM.Model/Scripting/Steps/AllowFormattingBarStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/AllowFormattingBarStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,35 +19,23 @@ public sealed class AllowFormattingBarStep : ScriptStep, IStepFactory
     /// <summary>The boolean setting encoded as <c>&lt;Set state="True|False"/&gt;</c>.</summary>
     public bool Set { get; set; }
 
+    private AllowFormattingBarStep() : base(false) { }
+
     public AllowFormattingBarStep(bool set = false, bool enabled = true)
         : base(enabled)
     {
         Set = set;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Set",
-                new XAttribute("state", Set ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Allow Formatting Bar [ {(Set ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("Set")?.Attribute("state")?.Value == "True";
-        return new AllowFormattingBarStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<AllowFormattingBarStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var isOn = hrParams.Length > 0 && hrParams[0].Trim().Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new AllowFormattingBarStep(isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<AllowFormattingBarStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -53,17 +43,7 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/allow-formatting-bar.html",
-        Params =
-        [
-            new ParamMetadata
-            {
-                Name = "Set",
-                XmlElement = "Set",
-                Type = "boolean",
-                XmlAttr = "state",
-                ValidValues = ["On", "Off"],
-            },
-        ],
+        Shape = [new BoolStateChild("Set")],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/AllowUserAbortStep.cs b/src/SharpFM.Model/Scripting/Steps/AllowUserAbortStep.cs
index e788627..2b32618 100644
--- a/src/SharpFM.Model/Scripting/Steps/AllowUserAbortStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/AllowUserAbortStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,52 +19,30 @@ public sealed class AllowUserAbortStep : ScriptStep, IStepFactory
     /// <summary>The boolean setting encoded as <c>&lt;Set state="True|False"/&gt;</c>.</summary>
     public bool Set { get; set; }
 
+    private AllowUserAbortStep() : base(false) { }
+
     public AllowUserAbortStep(bool set = false, bool enabled = true)
         : base(enabled)
     {
         Set = set;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Set",
-                new XAttribute("state", Set ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Allow User Abort [ {(Set ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("Set")?.Attribute("state")?.Value == "True";
-        return new AllowUserAbortStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<AllowUserAbortStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var isOn = hrParams.Length > 0 && hrParams[0].Trim().Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new AllowUserAbortStep(isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<AllowUserAbortStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "control",
-        Params =
-        [
-            new ParamMetadata
-            {
-                Name = "Set",
-                XmlElement = "Set",
-                Type = "boolean",
-                XmlAttr = "state",
-                ValidValues = ["On", "Off"],
-            },
-        ],
+        Shape = [new BoolStateChild("Set")],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/AppendPdfStep.cs b/src/SharpFM.Model/Scripting/Steps/AppendPdfStep.cs
new file mode 100644
index 0000000..ccfd5a9
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Steps/AppendPdfStep.cs
@@ -0,0 +1,93 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Values;
+
+namespace SharpFM.Model.Scripting.Steps;
+
+/// <summary>
+/// Append PDF adds pages to an existing PDF in a multi-step assembly. The
+/// <c>&lt;Option&gt;</c> toggle pairs with the optional
+/// <c>&lt;UniversalPathList&gt;</c>, and the <c>&lt;AppendPDFFile&gt;</c>
+/// wrapper carries the save type plus an optional open-password calculation.
+/// </summary>
+public sealed class AppendPdfStep : ScriptStep, IStepFactory
+{
+    public const int XmlId = 244;
+    public const string XmlName = "Append PDF";
+
+    public bool SpecifyFile { get; set; }
+    public string Path { get; set; } = "";
+    public string SaveType { get; set; } = "File";
+    public Calculation? OpenPassword { get; set; }
+
+    private AppendPdfStep() : base(false) { }
+
+    public AppendPdfStep(
+        bool specifyFile = false,
+        string path = "",
+        string saveType = "File",
+        Calculation? openPassword = null,
+        bool enabled = true)
+        : base(enabled)
+    {
+        SpecifyFile = specifyFile;
+        Path = path;
+        SaveType = saveType;
+        OpenPassword = openPassword;
+    }
+
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
+
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<AppendPdfStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when state the display line cannot
+    /// carry is present: an open-password calculation or a non-default save
+    /// type (the display shows only the path).
+    /// </summary>
+    public override bool IsFullyEditable => OpenPassword is null && SaveType == "File";
+
+    // Hand-written: couples the hidden Option wire flag to path presence,
+    // which the shape parser cannot express.
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
+    {
+        string path = "";
+        foreach (var tok in hrParams)
+        {
+            var t = tok.Trim();
+            if (!string.IsNullOrWhiteSpace(t)) { path = t; break; }
+        }
+        return new AppendPdfStep(!string.IsNullOrEmpty(path), path, "File", null, enabled);
+    }
+
+    public static StepMetadata Metadata { get; } = new()
+    {
+        Name = XmlName,
+        Id = XmlId,
+        Category = "files",
+        HelpUrl = "https://help.claris.com/en/pro-help/content/append-pdf.html",
+        // Option always emitted; <UniversalPathList> only when a path is set;
+        // the <AppendPDFFile> wrapper always emitted with its save type and an
+        // optional open-password calculation.
+        Shape =
+        [
+            new BoolStateChild("Option") { PocoProperty = "SpecifyFile", Display = DisplayMode.Hidden },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Optional = true },
+            new WrapperChild("AppendPDFFile",
+            [
+                new NamedTextChild("PDFSaveType") { PocoProperty = "SaveType", DefaultValue = "File", Display = DisplayMode.Hidden },
+                new NamedCalcChild("OpenPassword") { PocoProperty = "OpenPassword", Optional = true, Display = DisplayMode.Hidden },
+            ]),
+            // The wrapper's save type / password surface as one opaque display
+            // slot, mirroring the legacy AppendPDFFile param.
+            new HrOnly("AppendPDFFile"),
+        ],
+        FromXml = FromXml,
+        FromDisplay = FromDisplayParams,
+    };
+}
diff --git a/src/SharpFM.Model/Scripting/Steps/ArrangeAllWindowsStep.cs b/src/SharpFM.Model/Scripting/Steps/ArrangeAllWindowsStep.cs
index fa70947..acf9683 100644
--- a/src/SharpFM.Model/Scripting/Steps/ArrangeAllWindowsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ArrangeAllWindowsStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,7 +19,9 @@ public sealed class ArrangeAllWindowsStep : ScriptStep, IStepFactory
     public const string XmlName = "Arrange All Windows";
 
     /// <summary>The enum XML value emitted on the <c>&lt;WindowArrangement&gt;</c> element.</summary>
-    public string WindowArrangement { get; set; }
+    public string WindowArrangement { get; set; } = "Cascade Window";
+
+    private ArrangeAllWindowsStep() : base(false) { }
 
     public ArrangeAllWindowsStep(string windowArrangement = "Cascade Window", bool enabled = true)
         : base(enabled)
@@ -25,53 +29,15 @@ public ArrangeAllWindowsStep(string windowArrangement = "Cascade Window", bool e
         WindowArrangement = windowArrangement;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _xmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["Tile Horizontally"] = "Tile Horizontally",
-        ["Tile Vertically"] = "Tile Vertically",
-        ["Cascade Window"] = "Cascade Window",
-        ["Bring All To Front"] = "Bring All To Front",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _hrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["Tile Horizontally"] = "Tile Horizontally",
-        ["Tile Vertically"] = "Tile Vertically",
-        ["Cascade Window"] = "Cascade Window",
-        ["Bring All To Front"] = "Bring All To Front",
-    };
-
-    private static string ToHr(string xmlValue) =>
-        _xmlToHr.TryGetValue(xmlValue, out var hr) ? hr : xmlValue;
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string FromHr(string hrValue) =>
-        _hrToXml.TryGetValue(hrValue, out var xml) ? xml : hrValue;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("WindowArrangement",
-                new XAttribute("value", WindowArrangement)));
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ArrangeAllWindowsStep>(step, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Arrange All Windows [ {ToHr(WindowArrangement)} ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var value = step.Element("WindowArrangement")?.Attribute("value")?.Value ?? "Cascade Window";
-        return new ArrangeAllWindowsStep(value, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        return new ArrangeAllWindowsStep(FromHr(token), enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ArrangeAllWindowsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -79,17 +45,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/arrange-all-windows.html",
-        Params =
+        // Single always-emitted <WindowArrangement value="..."/> enum child.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "WindowArrangement",
-                XmlElement = "WindowArrangement",
-                Type = "enum",
-                XmlAttr = "value",
-                DefaultValue = "Cascade Window",
-                ValidValues = ["Tile Horizontally", "Tile Vertically", "Cascade Window", "Bring All To Front"],
-            },
+            new EnumValueChild("WindowArrangement") { PocoProperty = "WindowArrangement", DefaultValue = "Cascade Window", ValidValues = ["Tile Horizontally", "Tile Vertically", "Cascade Window", "Bring All To Front"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/BeepStep.cs b/src/SharpFM.Model/Scripting/Steps/BeepStep.cs
index f4adb2d..3596388 100644
--- a/src/SharpFM.Model/Scripting/Steps/BeepStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/BeepStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -19,21 +20,19 @@ public sealed class BeepStep : ScriptStep, IStepFactory
     public const int XmlId = 93;
     public const string XmlName = "Beep";
 
+    private BeepStep() : base(false) { }
+
     public BeepStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new BeepStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<BeepStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new BeepStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<BeepStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/CancelPdfStep.cs b/src/SharpFM.Model/Scripting/Steps/CancelPdfStep.cs
new file mode 100644
index 0000000..5d55a9e
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Steps/CancelPdfStep.cs
@@ -0,0 +1,39 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+
+namespace SharpFM.Model.Scripting.Steps;
+
+/// <summary>
+/// Cancel PDF aborts an in-progress multi-step PDF assembly. It carries no
+/// parameters — the canonical form is an empty <c>&lt;Step&gt;</c> element.
+/// </summary>
+public sealed class CancelPdfStep : ScriptStep, IStepFactory
+{
+    public const int XmlId = 247;
+    public const string XmlName = "Cancel PDF";
+
+    private CancelPdfStep() : base(false) { }
+
+    public CancelPdfStep(bool enabled = true) : base(enabled) { }
+
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
+
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<CancelPdfStep>(step, Metadata);
+
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CancelPdfStep>(enabled, hrParams, Metadata);
+
+    public static StepMetadata Metadata { get; } = new()
+    {
+        Name = XmlName,
+        Id = XmlId,
+        Category = "files",
+        HelpUrl = "https://help.claris.com/en/pro-help/content/cancel-pdf.html",
+        FromXml = FromXml,
+        FromDisplay = FromDisplayParams,
+    };
+}
diff --git a/src/SharpFM.Model/Scripting/Steps/ChangePasswordStep.cs b/src/SharpFM.Model/Scripting/Steps/ChangePasswordStep.cs
index d3c08e3..3d5d654 100644
--- a/src/SharpFM.Model/Scripting/Steps/ChangePasswordStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ChangePasswordStep.cs
@@ -1,8 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,10 +11,20 @@ public sealed class ChangePasswordStep : ScriptStep, IStepFactory
     public const int XmlId = 83;
     public const string XmlName = "Change Password";
 
-    public Calculation OldPassword { get; set; }
-    public Calculation Password { get; set; }
+    public Calculation? OldPassword { get; set; }
+    public Calculation? Password { get; set; }
     public bool WithDialog { get; set; }
 
+    /// <summary>
+    /// XML-facing inverse of <see cref="WithDialog"/>: canonical
+    /// <c>&lt;NoInteract state="…"/&gt;</c> suppresses the dialog, so it is the
+    /// negation of the display-facing flag. The shape binds this so the raw
+    /// state round-trips without re-applying the inversion.
+    /// </summary>
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+
+    private ChangePasswordStep() : base(false) { }
+
     public ChangePasswordStep(
         Calculation? oldPassword = null,
         Calculation? password = null,
@@ -23,47 +32,20 @@ public ChangePasswordStep(
         bool enabled = true)
         : base(enabled)
     {
-        OldPassword = oldPassword ?? new Calculation("");
-        Password = password ?? new Calculation("");
+        OldPassword = oldPassword;
+        Password = password;
         WithDialog = withDialog;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("OldPassword", OldPassword.ToXml("Calculation")),
-            new XElement("NewPassword", Password.ToXml("Calculation")),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Change Password [ " + "Old Password: " + OldPassword.Text + " ; " + "Password: " + Password.Text + " ; " + "With dialog: " + (WithDialog ? "On" : "Off") + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var oldPassword_vWrapEl = step.Element("OldPassword");
-        var oldPassword_vCalcEl = oldPassword_vWrapEl?.Element("Calculation");
-        var oldPassword_v = oldPassword_vCalcEl is not null ? Calculation.FromXml(oldPassword_vCalcEl) : new Calculation("");
-        var password_vWrapEl = step.Element("NewPassword");
-        var password_vCalcEl = password_vWrapEl?.Element("Calculation");
-        var password_v = password_vCalcEl is not null ? Calculation.FromXml(password_vCalcEl) : new Calculation("");
-        var withDialog_v = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        return new ChangePasswordStep(oldPassword_v, password_v, withDialog_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ChangePasswordStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? oldPassword_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Old Password:", StringComparison.OrdinalIgnoreCase)) { oldPassword_v = new Calculation(tok.Substring(13).Trim()); break; } }
-        Calculation? password_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Password:", StringComparison.OrdinalIgnoreCase)) { password_v = new Calculation(tok.Substring(9).Trim()); break; } }
-        bool withDialog_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(12).Trim(); withDialog_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        return new ChangePasswordStep(oldPassword_v, password_v, withDialog_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ChangePasswordStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -71,32 +53,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "accounts",
         HelpUrl = "https://help.claris.com/en/pro-help/content/change-password.html",
-        Params =
+        // Canonical 083-ChangePassword: only NoInteract (always present, the
+        // inverse of WithDialog). The <OldPassword>/<NewPassword> calculation
+        // wrappers are omitted until configured, so both are Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Old Password",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Password",
-            },
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
+            new NamedCalcChild("OldPassword") { PocoProperty = "OldPassword", HrLabel = "Old Password", Optional = true, DisplayEmptyAs = "" },
+            new NamedCalcChild("NewPassword") { PocoProperty = "Password", HrLabel = "Password", Optional = true, DisplayEmptyAs = "" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteract", HrLabel = "With dialog", DisplayInverted = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/CheckFoundSetStep.cs b/src/SharpFM.Model/Scripting/Steps/CheckFoundSetStep.cs
index 45ccb0e..d26e65f 100644
--- a/src/SharpFM.Model/Scripting/Steps/CheckFoundSetStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CheckFoundSetStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class CheckFoundSetStep : ScriptStep, IStepFactory
     public const int XmlId = 20;
     public const string XmlName = "Check Found Set";
 
+    private CheckFoundSetStep() : base(false) { }
+
     public CheckFoundSetStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new CheckFoundSetStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<CheckFoundSetStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new CheckFoundSetStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CheckFoundSetStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/CheckRecordStep.cs b/src/SharpFM.Model/Scripting/Steps/CheckRecordStep.cs
index 126e270..bac761a 100644
--- a/src/SharpFM.Model/Scripting/Steps/CheckRecordStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CheckRecordStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class CheckRecordStep : ScriptStep, IStepFactory
     public const int XmlId = 19;
     public const string XmlName = "Check Record";
 
+    private CheckRecordStep() : base(false) { }
+
     public CheckRecordStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new CheckRecordStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<CheckRecordStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new CheckRecordStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CheckRecordStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/CheckSelectionStep.cs b/src/SharpFM.Model/Scripting/Steps/CheckSelectionStep.cs
index 7b5ce35..876a35c 100644
--- a/src/SharpFM.Model/Scripting/Steps/CheckSelectionStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CheckSelectionStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +14,9 @@ public sealed class CheckSelectionStep : ScriptStep, IStepFactory
     public const string XmlName = "Check Selection";
 
     public bool Select { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private CheckSelectionStep() : base(false) { Select = true; }
 
     public CheckSelectionStep(
         bool select = true,
@@ -21,38 +25,18 @@ public CheckSelectionStep(
         : base(enabled)
     {
         Select = select;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Check Selection [ " + "Select: " + (Select ? "On" : "Off") + " ; " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new CheckSelectionStep(select_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<CheckSelectionStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool select_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); select_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (!tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(tok)) { target = FieldRef.FromDisplayToken(tok); break; } }
-        return new CheckSelectionStep(select_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CheckSelectionStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,24 +44,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "spelling",
         HelpUrl = "https://help.claris.com/en/pro-help/content/check-selection.html",
-        Params =
+        // Canonical 018-CheckSelection: only <SelectAll>; <Field> is omitted
+        // until a target is bound, so it is Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Select",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-            },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ClearStep.cs b/src/SharpFM.Model/Scripting/Steps/ClearStep.cs
index 0962370..9aace37 100644
--- a/src/SharpFM.Model/Scripting/Steps/ClearStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ClearStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +14,9 @@ public sealed class ClearStep : ScriptStep, IStepFactory
     public const string XmlName = "Clear";
 
     public bool Select { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private ClearStep() : base(false) { Select = true; }
 
     public ClearStep(
         bool select = true,
@@ -21,38 +25,18 @@ public ClearStep(
         : base(enabled)
     {
         Select = select;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Clear [ " + "Select: " + (Select ? "On" : "Off") + " ; " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new ClearStep(select_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ClearStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool select_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); select_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (!tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(tok)) { target = FieldRef.FromDisplayToken(tok); break; } }
-        return new ClearStep(select_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ClearStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,24 +44,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "editing",
         HelpUrl = "https://help.claris.com/en/pro-help/content/clear.html",
-        Params =
+        // Canonical 049-Clear: only <SelectAll>; <Field> is omitted until a
+        // target is bound, so it is Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Select",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-            },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/CloseDataFileStep.cs b/src/SharpFM.Model/Scripting/Steps/CloseDataFileStep.cs
index 709d150..41b96df 100644
--- a/src/SharpFM.Model/Scripting/Steps/CloseDataFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CloseDataFileStep.cs
@@ -1,8 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,41 +11,27 @@ public sealed class CloseDataFileStep : ScriptStep, IStepFactory
     public const int XmlId = 196;
     public const string XmlName = "Close Data File";
 
-    public Calculation FileID { get; set; }
+    public Calculation? FileID { get; set; }
+
+    private CloseDataFileStep() : base(false) { }
 
     public CloseDataFileStep(
         Calculation? fileID = null,
         bool enabled = true)
         : base(enabled)
     {
-        FileID = fileID ?? new Calculation("");
+        FileID = fileID;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            FileID.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Close Data File [ " + "File ID: " + FileID.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var fileID_vEl = step.Element("Calculation");
-        var fileID_v = fileID_vEl is not null ? Calculation.FromXml(fileID_vEl) : new Calculation("");
-        return new CloseDataFileStep(fileID_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<CloseDataFileStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? fileID_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("File ID:", StringComparison.OrdinalIgnoreCase)) { fileID_v = new Calculation(tok.Substring(8).Trim()); break; } }
-        return new CloseDataFileStep(fileID_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CloseDataFileStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -54,15 +39,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/close-data-file.html",
-        Params =
+        // Canonical unconfigured form is empty: the bare File ID calc is omitted when blank.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                HrLabel = "File ID",
-            },
+            new BareCalcChild { PocoProperty = "FileID", HrLabel = "File ID", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/CloseFileStep.cs b/src/SharpFM.Model/Scripting/Steps/CloseFileStep.cs
index d2b9308..84d7e9c 100644
--- a/src/SharpFM.Model/Scripting/Steps/CloseFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CloseFileStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,34 +13,26 @@ public sealed class CloseFileStep : ScriptStep, IStepFactory
 
     public FileReference? File { get; set; }
 
+    private CloseFileStep() : base(false) { }
+
     public CloseFileStep(FileReference? file = null, bool enabled = true)
         : base(enabled)
     {
         File = file;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        if (File is not null) step.Add(File.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the token comes from the FileReference value type
+    // (absence means "Current File"), which the shape-driven renderer
+    // cannot surface.
     public override string ToDisplayLine() =>
         File is null
             ? "Close File [ Current File ]"
             : $"Close File [ {File.ToDisplayString()} ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var fileEl = step.Element("FileReference");
-        var file = fileEl is not null ? FileReference.FromXml(fileEl) : null;
-        return new CloseFileStep(file, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<CloseFileStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -59,15 +53,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/close-file.html",
-        Params =
-        [
-            new ParamMetadata
-            {
-                Name = "FileReference",
-                XmlElement = "FileReference",
-                Type = "fileReference",
-            },
-        ],
+        // FileReference is emitted only when a specific file is configured;
+        // its absence means "Current File".
+        Shape = [new ValueTypeChild("FileReference") { PocoProperty = "File", Optional = true }],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/ClosePdfStep.cs b/src/SharpFM.Model/Scripting/Steps/ClosePdfStep.cs
new file mode 100644
index 0000000..8bf2941
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Steps/ClosePdfStep.cs
@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
+
+namespace SharpFM.Model.Scripting.Steps;
+
+/// <summary>
+/// Close PDF finalises a multi-step PDF and carries the post-close behaviour
+/// flags (<c>CreateDirectories</c> / <c>AutoOpen</c> / <c>CreateEmail</c>),
+/// an optional output path, and a <c>&lt;ClosePDFFile&gt;</c> wrapper holding
+/// the save type.
+/// </summary>
+public sealed class ClosePdfStep : ScriptStep, IStepFactory
+{
+    public const int XmlId = 245;
+    public const string XmlName = "Close PDF";
+
+    public bool CreateDirectories { get; set; }
+    public bool AutoOpen { get; set; }
+    public bool CreateEmail { get; set; }
+    public string Path { get; set; } = "";
+    public string SaveType { get; set; } = "File";
+
+    private ClosePdfStep() : base(false) { }
+
+    public ClosePdfStep(
+        bool createDirectories = false,
+        bool autoOpen = false,
+        bool createEmail = false,
+        string path = "",
+        string saveType = "File",
+        bool enabled = true)
+        : base(enabled)
+    {
+        CreateDirectories = createDirectories;
+        AutoOpen = autoOpen;
+        CreateEmail = createEmail;
+        Path = path;
+        SaveType = saveType;
+    }
+
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    // Hand-written: AutoOpen/CreateEmail render as conditional bare tokens,
+    // a form a BoolStateChild cannot produce (it always renders On/Off).
+    public override string ToDisplayLine()
+    {
+        var parts = new List<string>();
+        if (!string.IsNullOrEmpty(Path)) parts.Add(Path);
+        if (AutoOpen) parts.Add("Automatically open");
+        if (CreateEmail) parts.Add("Create email");
+        return parts.Count == 0
+            ? "Close PDF"
+            : $"Close PDF [ {string.Join(" ; ", parts)} ]";
+    }
+
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ClosePdfStep>(step, Metadata);
+
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
+    {
+        bool autoOpen = false, createEmail = false;
+        string path = "";
+        bool pathSeen = false;
+        foreach (var tok in hrParams)
+        {
+            var t = tok.Trim();
+            if (t.Equals("Automatically open", System.StringComparison.OrdinalIgnoreCase)) autoOpen = true;
+            else if (t.Equals("Create email", System.StringComparison.OrdinalIgnoreCase)) createEmail = true;
+            else if (!pathSeen && !string.IsNullOrWhiteSpace(t)) { path = t; pathSeen = true; }
+        }
+        return new ClosePdfStep(false, autoOpen, createEmail, path, "File", enabled);
+    }
+
+    public static StepMetadata Metadata { get; } = new()
+    {
+        Name = XmlName,
+        Id = XmlId,
+        Category = "files",
+        HelpUrl = "https://help.claris.com/en/pro-help/content/close-pdf.html",
+        // Three state flags always emitted; <UniversalPathList> only when a
+        // path is set; the <ClosePDFFile> wrapper always emitted with its
+        // save type.
+        Shape =
+        [
+            new BoolStateChild("CreateDirectories") { PocoProperty = "CreateDirectories", Display = DisplayMode.Native },
+            new BoolStateChild("AutoOpen") { PocoProperty = "AutoOpen" },
+            new BoolStateChild("CreateEmail") { PocoProperty = "CreateEmail" },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Optional = true },
+            new WrapperChild("ClosePDFFile",
+            [
+                new NamedTextChild("PDFSaveType") { PocoProperty = "SaveType", DefaultValue = "File", Display = DisplayMode.Hidden },
+            ]),
+            // The wrapper's save type surfaces as one opaque display slot,
+            // mirroring the legacy ClosePDFFile param.
+            new HrOnly("ClosePDFFile"),
+        ],
+        FromXml = FromXml,
+        FromDisplay = FromDisplayParams,
+    };
+}
diff --git a/src/SharpFM.Model/Scripting/Steps/ClosePopoverStep.cs b/src/SharpFM.Model/Scripting/Steps/ClosePopoverStep.cs
index 759fba0..bb5873d 100644
--- a/src/SharpFM.Model/Scripting/Steps/ClosePopoverStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ClosePopoverStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class ClosePopoverStep : ScriptStep, IStepFactory
     public const int XmlId = 169;
     public const string XmlName = "Close Popover";
 
+    private ClosePopoverStep() : base(false) { }
+
     public ClosePopoverStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ClosePopoverStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ClosePopoverStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new ClosePopoverStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ClosePopoverStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/CloseWindowStep.cs b/src/SharpFM.Model/Scripting/Steps/CloseWindowStep.cs
index 154e4fa..87750a2 100644
--- a/src/SharpFM.Model/Scripting/Steps/CloseWindowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CloseWindowStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,8 +15,10 @@ public sealed class CloseWindowStep : ScriptStep, IStepFactory
     public const string XmlName = "Close Window";
 
     public bool LimitToWindowsOfCurrentFile { get; set; }
-    public string Window { get; set; }
-    public Calculation Calculation { get; set; }
+    public string Window { get; set; } = "ByName";
+    public Calculation Calculation { get; set; } = new("");
+
+    private CloseWindowStep() : base(false) { }
 
     public CloseWindowStep(
         bool limitToWindowsOfCurrentFile = true,
@@ -41,36 +45,27 @@ public CloseWindowStep(
     private static string WindowHr(string x) => _WindowToHr.TryGetValue(x, out var h) ? h : x;
     private static string WindowXml(string h) => _WindowFromHr.TryGetValue(h, out var x) ? x : h;
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("LimitToWindowsOfCurrentFile", new XAttribute("state", LimitToWindowsOfCurrentFile ? "True" : "False")),
-            new XElement("Window", new XAttribute("value", Window)),
-            new XElement("Name", Calculation.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: variant window-target grammar (Current/ByName) the shape
+    // renderer cannot produce.
     public override string ToDisplayLine() =>
         "Close Window [ " + (LimitToWindowsOfCurrentFile ? "On" : "Off") + " ; " + WindowHr(Window) + " ; " + Calculation.Text + " ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var limitToWindowsOfCurrentFile_v = step.Element("LimitToWindowsOfCurrentFile")?.Attribute("state")?.Value == "True";
-        var window_v = step.Element("Window")?.Attribute("value")?.Value ?? "ByName";
-        var calculation_vWrapEl = step.Element("Name");
-        var calculation_vCalcEl = calculation_vWrapEl?.Element("Calculation");
-        var calculation_v = calculation_vCalcEl is not null ? Calculation.FromXml(calculation_vCalcEl) : new Calculation("");
-        return new CloseWindowStep(limitToWindowsOfCurrentFile_v, window_v, calculation_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<CloseWindowStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
+        // Positional display grammar: [ On/Off ; Window ; name-calc ]. A
+        // trailing empty calc token is dropped by the param splitter.
         var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool limitToWindowsOfCurrentFile_v = true;
-        string window_v = "ByName";
-        Calculation? calculation_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation_v = new Calculation(tok); break; } }
+        bool limitToWindowsOfCurrentFile_v = tokens.Length == 0
+            || tokens[0].Equals("On", StringComparison.OrdinalIgnoreCase);
+        string window_v = tokens.Length > 1 ? WindowXml(tokens[1]) : "ByName";
+        Calculation? calculation_v = tokens.Length > 2 && tokens[2].Length > 0
+            ? new Calculation(tokens[2])
+            : null;
         return new CloseWindowStep(limitToWindowsOfCurrentFile_v, window_v, calculation_v, enabled);
     }
 
@@ -80,32 +75,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/close-window.html",
-        Params =
+        // Canonical: LimitToWindowsOfCurrentFile, Window, then the optional
+        // <Name> calculation (present only in the ByName form).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "LimitToWindowsOfCurrentFile",
-                XmlElement = "LimitToWindowsOfCurrentFile",
-                Type = "boolean",
-                XmlAttr = "state",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Window",
-                XmlElement = "Window",
-                Type = "enum",
-                XmlAttr = "value",
-                ValidValues = ["ByName", "Current"],
-                DefaultValue = "ByName",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
+            new BoolStateChild("LimitToWindowsOfCurrentFile") { PocoProperty = "LimitToWindowsOfCurrentFile", Display = DisplayMode.Native },
+            new EnumValueChild("Window") { PocoProperty = "Window", DefaultValue = "ByName", DisplayValues = ["ByName", "Current"], Display = DisplayMode.Native },
+            new NamedCalcChild("Name") { PocoProperty = "Calculation", Optional = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/CommentStep.cs b/src/SharpFM.Model/Scripting/Steps/CommentStep.cs
index 104edd0..4126ad0 100644
--- a/src/SharpFM.Model/Scripting/Steps/CommentStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CommentStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -27,6 +29,9 @@ public CommentStep(bool enabled, string text)
         Text = text;
     }
 
+    // Hand-written rather than StepXmlParser: the reader must normalize the
+    // clipboard's CR/CRLF newlines to LF, a text transform the shape engine
+    // does not express.
     public static new ScriptStep FromXml(XElement step)
     {
         var enabled = step.Attribute("enable")?.Value != "False";
@@ -40,13 +45,10 @@ public CommentStep(bool enabled, string text)
         return new CommentStep(enabled, text);
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Text", Text));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the comment grammar (# prefix, no brackets) is outside
+    // the shared "Name [ tokens ]" display form.
     public override string ToDisplayLine() =>
         // FM Pro convention: an empty-text comment renders as a blank
         // line in the script editor, not "# ". Blank display lines are
@@ -70,9 +72,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Name = XmlName,
         Id = XmlId,
         Category = "control",
-        Params =
+        // Canonical (skill §8.1): a bare divider comment is the self-closing
+        // form, not an empty <Text/> — hence Optional.
+        Shape =
         [
-            new ParamMetadata { Name = "Text", XmlElement = "Text", Type = "text" },
+            new NamedTextChild("Text") { Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/CommitRecordsRequestsStep.cs b/src/SharpFM.Model/Scripting/Steps/CommitRecordsRequestsStep.cs
index 37a5076..42dfac5 100644
--- a/src/SharpFM.Model/Scripting/Steps/CommitRecordsRequestsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CommitRecordsRequestsStep.cs
@@ -1,7 +1,7 @@
-using System;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -23,6 +23,11 @@ public sealed class CommitRecordsRequestsStep : ScriptStep, IStepFactory
     /// <summary>Override ESS/ODBC locking conflicts on commit.</summary>
     public bool ForceCommit { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    private CommitRecordsRequestsStep() : this(withDialog: true) { }
+
     public CommitRecordsRequestsStep(
         bool withDialog = true,
         bool skipDataEntryValidation = false,
@@ -35,57 +40,15 @@ public CommitRecordsRequestsStep(
         ForceCommit = forceCommit;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("Option", new XAttribute("state", SkipDataEntryValidation ? "True" : "False")),
-            new XElement("ESSForceCommit", new XAttribute("state", ForceCommit ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Commit Records/Requests [ "
-        + "With dialog: " + (WithDialog ? "On" : "Off")
-        + " ; Skip data entry validation: " + (SkipDataEntryValidation ? "On" : "Off")
-        + " ; Force commit: " + (ForceCommit ? "On" : "Off")
-        + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var noInteract = step.Element("NoInteract")?.Attribute("state")?.Value == "True";
-        var option = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var essForce = step.Element("ESSForceCommit")?.Attribute("state")?.Value == "True";
-        return new CommitRecordsRequestsStep(
-            withDialog: !noInteract,
-            skipDataEntryValidation: option,
-            forceCommit: essForce,
-            enabled: enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<CommitRecordsRequestsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        return new CommitRecordsRequestsStep(
-            withDialog: ParseOn(tokens, "With dialog:", defaultValue: true),
-            skipDataEntryValidation: ParseOn(tokens, "Skip data entry validation:", defaultValue: false),
-            forceCommit: ParseOn(tokens, "Force commit:", defaultValue: false),
-            enabled: enabled);
-    }
-
-    private static bool ParseOn(string[] tokens, string prefix, bool defaultValue)
-    {
-        foreach (var tok in tokens)
-        {
-            if (tok.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
-            {
-                var v = tok.Substring(prefix.Length).Trim();
-                return v.Equals("On", StringComparison.OrdinalIgnoreCase);
-            }
-        }
-        return defaultValue;
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CommitRecordsRequestsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -93,27 +56,11 @@ private static bool ParseOn(string[] tokens, string prefix, bool defaultValue)
         Id = XmlId,
         Category = "records",
         HelpUrl = "https://help.claris.com/en/pro-help/content/commit-records-requests.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract", XmlElement = "NoInteract", Type = "boolean",
-                XmlAttr = "state", HrLabel = "With dialog",
-                // Inverted: XML state=True means HR "With dialog: Off".
-                ValidValues = ["On", "Off"], DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Option", XmlElement = "Option", Type = "boolean",
-                XmlAttr = "state", HrLabel = "Skip data entry validation",
-                ValidValues = ["On", "Off"], DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "ESSForceCommit", XmlElement = "ESSForceCommit", Type = "boolean",
-                XmlAttr = "state", HrLabel = "Force commit",
-                ValidValues = ["On", "Off"], DefaultValue = "False",
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", DisplayInverted = true },
+            new BoolStateChild("Option") { PocoProperty = "SkipDataEntryValidation", HrLabel = "Skip data entry validation" },
+            new BoolStateChild("ESSForceCommit") { PocoProperty = "ForceCommit", HrLabel = "Force commit" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/CommitTransactionStep.cs b/src/SharpFM.Model/Scripting/Steps/CommitTransactionStep.cs
index 50c6344..eb1bd03 100644
--- a/src/SharpFM.Model/Scripting/Steps/CommitTransactionStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CommitTransactionStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class CommitTransactionStep : ScriptStep, IStepFactory
     public const int XmlId = 206;
     public const string XmlName = "Commit Transaction";
 
+    private CommitTransactionStep() : base(false) { }
+
     public CommitTransactionStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new CommitTransactionStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<CommitTransactionStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new CommitTransactionStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CommitTransactionStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/ConfigureAIAccountStep.cs b/src/SharpFM.Model/Scripting/Steps/ConfigureAIAccountStep.cs
index d029610..5cb134d 100644
--- a/src/SharpFM.Model/Scripting/Steps/ConfigureAIAccountStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ConfigureAIAccountStep.cs
@@ -3,26 +3,37 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
+/// <summary>
+/// Configure AI Account (212). Canonical form (skill, AI reference): an optional
+/// <c>&lt;VerifySSLCertificates&gt;</c>, then <c>&lt;LLMType value="…"/&gt;</c>,
+/// then a <c>&lt;SetLLMAccount&gt;</c> wrapper holding the optional account name,
+/// endpoint and API key. <see cref="VerifySSLCertificates"/> is nullable so an
+/// absent flag stays distinct from a present "False".
+/// </summary>
 public sealed class ConfigureAIAccountStep : ScriptStep, IStepFactory
 {
     public const int XmlId = 212;
     public const string XmlName = "Configure AI Account";
 
-    public Calculation AccountName { get; set; }
-    public string ModelProvider { get; set; }
-    public Calculation Endpoint { get; set; }
-    public bool VerifySSLCertificates { get; set; }
-    public Calculation APIKey { get; set; }
+    public Calculation AccountName { get; set; } = new("");
+    public string ModelProvider { get; set; } = "OpenAI";
+    public Calculation Endpoint { get; set; } = new("");
+    public bool? VerifySSLCertificates { get; set; }
+    public Calculation APIKey { get; set; } = new("");
+
+    private ConfigureAIAccountStep() : base(false) { }
 
     public ConfigureAIAccountStep(
         Calculation? accountName = null,
         string modelProvider = "OpenAI",
         Calculation? endpoint = null,
-        bool verifySSLCertificates = false,
+        bool? verifySSLCertificates = null,
         Calculation? aPIKey = null,
         bool enabled = true)
         : base(enabled)
@@ -51,36 +62,23 @@ public ConfigureAIAccountStep(
     private static string ModelProviderHr(string x) => _ModelProviderToHr.TryGetValue(x, out var h) ? h : x;
     private static string ModelProviderXml(string h) => _ModelProviderFromHr.TryGetValue(h, out var x) ? x : h;
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("AccoutName", AccountName.ToXml("Calculation")),
-            new XElement("LLMType", new XAttribute("value", ModelProvider)),
-            new XElement("Endpoint", Endpoint.ToXml("Calculation")),
-            new XElement("VerifySSLCertificates", new XAttribute("state", VerifySSLCertificates ? "True" : "False")),
-            new XElement("AccessAPIKey", APIKey.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: FileMaker's token order (Account Name before Model
+    // Provider, SSL flag fourth) diverges from the canonical XML order, and
+    // the nullable SSL flag renders absent and explicit-False identically.
     public override string ToDisplayLine() =>
-        "Configure AI Account [ " + "Account Name: " + AccountName.Text + " ; " + "Model Provider: " + ModelProviderHr(ModelProvider) + " ; " + "Endpoint: " + Endpoint.Text + " ; " + "Verify SSL Certificates: " + (VerifySSLCertificates ? "On" : "Off") + " ; " + "API key: " + APIKey.Text + " ]";
+        "Configure AI Account [ " + "Account Name: " + AccountName.Text + " ; " + "Model Provider: " + ModelProviderHr(ModelProvider) + " ; " + "Endpoint: " + Endpoint.Text + " ; " + "Verify SSL Certificates: " + (VerifySSLCertificates == true ? "On" : "Off") + " ; " + "API key: " + APIKey.Text + " ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var accountName_vWrapEl = step.Element("AccoutName");
-        var accountName_vCalcEl = accountName_vWrapEl?.Element("Calculation");
-        var accountName_v = accountName_vCalcEl is not null ? Calculation.FromXml(accountName_vCalcEl) : new Calculation("");
-        var modelProvider_v = step.Element("LLMType")?.Attribute("value")?.Value ?? "OpenAI";
-        var endpoint_vWrapEl = step.Element("Endpoint");
-        var endpoint_vCalcEl = endpoint_vWrapEl?.Element("Calculation");
-        var endpoint_v = endpoint_vCalcEl is not null ? Calculation.FromXml(endpoint_vCalcEl) : new Calculation("");
-        var verifySSLCertificates_v = step.Element("VerifySSLCertificates")?.Attribute("state")?.Value == "True";
-        var aPIKey_vWrapEl = step.Element("AccessAPIKey");
-        var aPIKey_vCalcEl = aPIKey_vWrapEl?.Element("Calculation");
-        var aPIKey_v = aPIKey_vCalcEl is not null ? Calculation.FromXml(aPIKey_vCalcEl) : new Calculation("");
-        return new ConfigureAIAccountStep(accountName_v, modelProvider_v, endpoint_v, verifySSLCertificates_v, aPIKey_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ConfigureAIAccountStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when the SSL flag is explicitly
+    /// stored as False: the display renders both the absent and the
+    /// explicit-False forms as "Off", so a parsed "Off" maps to absent.
+    /// </summary>
+    public override bool IsFullyEditable => VerifySSLCertificates != false;
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -91,8 +89,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         foreach (var tok in tokens) { if (tok.StartsWith("Model Provider:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(15).Trim(); modelProvider_v = ModelProviderXml(v); break; } }
         Calculation? endpoint_v = null;
         foreach (var tok in tokens) { if (tok.StartsWith("Endpoint:", StringComparison.OrdinalIgnoreCase)) { endpoint_v = new Calculation(tok.Substring(9).Trim()); break; } }
-        bool verifySSLCertificates_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Verify SSL Certificates:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(24).Trim(); verifySSLCertificates_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
+        // "Off" is ambiguous between absent and explicit False; it maps to
+        // absent (explicit-False instances are sealed).
+        bool? verifySSLCertificates_v = null;
+        foreach (var tok in tokens) { if (tok.StartsWith("Verify SSL Certificates:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(24).Trim(); verifySSLCertificates_v = v.Equals("On", StringComparison.OrdinalIgnoreCase) ? true : null; break; } }
         Calculation? aPIKey_v = null;
         foreach (var tok in tokens) { if (tok.StartsWith("API key:", StringComparison.OrdinalIgnoreCase)) { aPIKey_v = new Calculation(tok.Substring(8).Trim()); break; } }
         return new ConfigureAIAccountStep(accountName_v, modelProvider_v, endpoint_v, verifySSLCertificates_v, aPIKey_v, enabled);
@@ -103,49 +103,18 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
-        Params =
+        // Canonical: optional VerifySSLCertificates, then LLMType (value attr),
+        // then the <SetLLMAccount> wrapper with the optional account fields.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Account Name",
-            },
-            new ParamMetadata
-            {
-                Name = "LLMType",
-                XmlElement = "LLMType",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Model Provider",
-                ValidValues = ["OpenAI", "Anthropic", "Cohere", "Custom"],
-                DefaultValue = "OpenAI",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Endpoint",
-            },
-            new ParamMetadata
-            {
-                Name = "VerifySSLCertificates",
-                XmlElement = "VerifySSLCertificates",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Verify SSL Certificates",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "API key",
-            },
+            new BoolStateChild("VerifySSLCertificates") { PocoProperty = "VerifySSLCertificates", HrLabel = "Verify SSL Certificates", Optional = true, Display = DisplayMode.Augmented },
+            new EnumValueChild("LLMType") { PocoProperty = "ModelProvider", HrLabel = "Model Provider", DefaultValue = "OpenAI", DisplayValues = ["OpenAI", "Anthropic", "Cohere", "Custom"], Display = DisplayMode.Augmented },
+            new WrapperChild("SetLLMAccount",
+            [
+                new NamedCalcChild("AccountName") { PocoProperty = "AccountName", HrLabel = "Account Name", Optional = true, Display = DisplayMode.Augmented },
+                new NamedCalcChild("Endpoint") { PocoProperty = "Endpoint", HrLabel = "Endpoint", Optional = true, Display = DisplayMode.Augmented },
+                new NamedCalcChild("AccessAPIKey") { PocoProperty = "APIKey", HrLabel = "API key", Optional = true, Display = DisplayMode.Augmented },
+            ]),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ConfigureLocalNotificationStep.cs b/src/SharpFM.Model/Scripting/Steps/ConfigureLocalNotificationStep.cs
index 6b97ded..229d25b 100644
--- a/src/SharpFM.Model/Scripting/Steps/ConfigureLocalNotificationStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ConfigureLocalNotificationStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -17,35 +19,42 @@ public sealed class ConfigureLocalNotificationStep : ScriptStep, IStepFactory
 
     public StepChildBag Children { get; set; }
 
+    private ConfigureLocalNotificationStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public ConfigureLocalNotificationStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ConfigureLocalNotificationStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ConfigureLocalNotificationStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new ConfigureLocalNotificationStep(enabled: enabled);
+        StepDisplayParser.Parse<ConfigureLocalNotificationStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "control",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/ConfigureMachineLearningModelStep.cs b/src/SharpFM.Model/Scripting/Steps/ConfigureMachineLearningModelStep.cs
index 1570283..adf1771 100644
--- a/src/SharpFM.Model/Scripting/Steps/ConfigureMachineLearningModelStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ConfigureMachineLearningModelStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,35 +13,42 @@ public sealed class ConfigureMachineLearningModelStep : ScriptStep, IStepFactory
 
     public StepChildBag Children { get; set; }
 
+    private ConfigureMachineLearningModelStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public ConfigureMachineLearningModelStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ConfigureMachineLearningModelStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ConfigureMachineLearningModelStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new ConfigureMachineLearningModelStep(enabled: enabled);
+        StepDisplayParser.Parse<ConfigureMachineLearningModelStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/ConfigureNfcReadingStep.cs b/src/SharpFM.Model/Scripting/Steps/ConfigureNfcReadingStep.cs
index 5bbc120..b9595d0 100644
--- a/src/SharpFM.Model/Scripting/Steps/ConfigureNfcReadingStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ConfigureNfcReadingStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,35 +13,42 @@ public sealed class ConfigureNfcReadingStep : ScriptStep, IStepFactory
 
     public StepChildBag Children { get; set; }
 
+    private ConfigureNfcReadingStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public ConfigureNfcReadingStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ConfigureNfcReadingStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ConfigureNfcReadingStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new ConfigureNfcReadingStep(enabled: enabled);
+        StepDisplayParser.Parse<ConfigureNfcReadingStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "control",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/ConfigurePromptTemplateStep.cs b/src/SharpFM.Model/Scripting/Steps/ConfigurePromptTemplateStep.cs
index 83227a2..926f158 100644
--- a/src/SharpFM.Model/Scripting/Steps/ConfigurePromptTemplateStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ConfigurePromptTemplateStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,15 +14,17 @@ public sealed class ConfigurePromptTemplateStep : ScriptStep, IStepFactory
     public const int XmlId = 226;
     public const string XmlName = "Configure Prompt Template";
 
-    public Calculation TemplateName { get; set; }
-    public string ModelProvider { get; set; }
-    public string TemplateType { get; set; }
-    public Calculation SQLPrompt { get; set; }
-    public Calculation NaturalLanguagePrompt { get; set; }
-    public Calculation FindRequestPrompt { get; set; }
-    public Calculation RAGPrompt { get; set; }
+    public Calculation TemplateName { get; set; } = new("");
+    public string ModelProvider { get; set; } = "OpenAI";
+    public string TemplateType { get; set; } = "SQL Query";
+    public Calculation SQLPrompt { get; set; } = new("");
+    public Calculation NaturalLanguagePrompt { get; set; } = new("");
+    public Calculation FindRequestPrompt { get; set; } = new("");
+    public Calculation RAGPrompt { get; set; } = new("");
     public bool Option { get; set; }
 
+    private ConfigurePromptTemplateStep() : base(false) { }
+
     public ConfigurePromptTemplateStep(
         Calculation? templateName = null,
         string modelProvider = "OpenAI",
@@ -75,46 +79,15 @@ public ConfigurePromptTemplateStep(
     private static string TemplateTypeHr(string x) => _TemplateTypeToHr.TryGetValue(x, out var h) ? h : x;
     private static string TemplateTypeXml(string h) => _TemplateTypeFromHr.TryGetValue(h, out var x) ? x : h;
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("TemplateName", TemplateName.ToXml("Calculation")),
-            new XElement("ModelProvider", new XAttribute("value", ModelProvider)),
-            new XElement("RequestType", new XAttribute("value", TemplateType)),
-            new XElement("SQLPrompt", SQLPrompt.ToXml("Calculation")),
-            new XElement("NaturalLanguagePrompt", NaturalLanguagePrompt.ToXml("Calculation")),
-            new XElement("FindRequestPrompt", FindRequestPrompt.ToXml("Calculation")),
-            new XElement("RAGPPrompt", RAGPrompt.ToXml("Calculation")),
-            new XElement("Option", new XAttribute("state", Option ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: trailing bare On/Off token and token order diverging from
+    // the canonical XML order.
     public override string ToDisplayLine() =>
         "Configure Prompt Template [ " + "Template Name: " + TemplateName.Text + " ; " + "Model Provider: " + ModelProviderHr(ModelProvider) + " ; " + "Template Type: " + TemplateTypeHr(TemplateType) + " ; " + "SQL Prompt: " + SQLPrompt.Text + " ; " + "Natural Language Prompt: " + NaturalLanguagePrompt.Text + " ; " + "Find Request Prompt: " + FindRequestPrompt.Text + " ; " + "RAG Prompt: " + RAGPrompt.Text + " ; " + (Option ? "On" : "Off") + " ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var templateName_vWrapEl = step.Element("TemplateName");
-        var templateName_vCalcEl = templateName_vWrapEl?.Element("Calculation");
-        var templateName_v = templateName_vCalcEl is not null ? Calculation.FromXml(templateName_vCalcEl) : new Calculation("");
-        var modelProvider_v = step.Element("ModelProvider")?.Attribute("value")?.Value ?? "OpenAI";
-        var templateType_v = step.Element("RequestType")?.Attribute("value")?.Value ?? "SQL Query";
-        var sQLPrompt_vWrapEl = step.Element("SQLPrompt");
-        var sQLPrompt_vCalcEl = sQLPrompt_vWrapEl?.Element("Calculation");
-        var sQLPrompt_v = sQLPrompt_vCalcEl is not null ? Calculation.FromXml(sQLPrompt_vCalcEl) : new Calculation("");
-        var naturalLanguagePrompt_vWrapEl = step.Element("NaturalLanguagePrompt");
-        var naturalLanguagePrompt_vCalcEl = naturalLanguagePrompt_vWrapEl?.Element("Calculation");
-        var naturalLanguagePrompt_v = naturalLanguagePrompt_vCalcEl is not null ? Calculation.FromXml(naturalLanguagePrompt_vCalcEl) : new Calculation("");
-        var findRequestPrompt_vWrapEl = step.Element("FindRequestPrompt");
-        var findRequestPrompt_vCalcEl = findRequestPrompt_vWrapEl?.Element("Calculation");
-        var findRequestPrompt_v = findRequestPrompt_vCalcEl is not null ? Calculation.FromXml(findRequestPrompt_vCalcEl) : new Calculation("");
-        var rAGPrompt_vWrapEl = step.Element("RAGPPrompt");
-        var rAGPrompt_vCalcEl = rAGPrompt_vWrapEl?.Element("Calculation");
-        var rAGPrompt_v = rAGPrompt_vCalcEl is not null ? Calculation.FromXml(rAGPrompt_vCalcEl) : new Calculation("");
-        var option_v = step.Element("Option")?.Attribute("state")?.Value == "True";
-        return new ConfigurePromptTemplateStep(templateName_v, modelProvider_v, templateType_v, sQLPrompt_v, naturalLanguagePrompt_v, findRequestPrompt_v, rAGPrompt_v, option_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ConfigurePromptTemplateStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -142,70 +115,23 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
-        Params =
+        // Canonical: Option, then a <ConfigurePromptTemplate> wrapper carrying
+        // the text <ModelProvider> and <RequestType> children.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Template Name",
-            },
-            new ParamMetadata
-            {
-                Name = "ModelProvider",
-                XmlElement = "ModelProvider",
-                Type = "enum",
-                HrLabel = "Model Provider",
-                ValidValues = ["OpenAI", "Anthropic", "Cohere", "Custom"],
-                DefaultValue = "OpenAI",
-            },
-            new ParamMetadata
-            {
-                Name = "RequestType",
-                XmlElement = "RequestType",
-                Type = "enum",
-                HrLabel = "Template Type",
-                ValidValues = ["SQL Query", "Find Request", "RAG Prompt"],
-                DefaultValue = "SQL Query",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "SQL Prompt",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Natural Language Prompt",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Find Request Prompt",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "RAG Prompt",
-            },
-            new ParamMetadata
-            {
-                Name = "Option",
-                XmlElement = "Option",
-                Type = "boolean",
-                XmlAttr = "state",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
+            new BoolStateChild("Option") { PocoProperty = "Option", Display = DisplayMode.Native },
+            new WrapperChild("ConfigurePromptTemplate",
+            [
+                new NamedTextChild("ModelProvider") { PocoProperty = "ModelProvider", HrLabel = "Model Provider", DisplayValues = ["OpenAI", "Anthropic", "Cohere", "Custom"], Display = DisplayMode.Augmented },
+                new NamedTextChild("RequestType") { PocoProperty = "TemplateType", HrLabel = "Template Type", DisplayValues = ["SQL Query", "Find Request", "RAG Prompt"], Display = DisplayMode.Augmented },
+            ]),
+            // The name and per-mode prompt calcs have no wire children in the
+            // canonical form; HR-only slots keep their display tokens addressable.
+            new HrOnly("TemplateName") { HrLabel = "Template Name" },
+            new HrOnly("SQLPrompt") { HrLabel = "SQL Prompt" },
+            new HrOnly("NaturalLanguagePrompt") { HrLabel = "Natural Language Prompt" },
+            new HrOnly("FindRequestPrompt") { HrLabel = "Find Request Prompt" },
+            new HrOnly("RAGPrompt") { HrLabel = "RAG Prompt" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ConfigureRAGAccountStep.cs b/src/SharpFM.Model/Scripting/Steps/ConfigureRAGAccountStep.cs
index 5503fb4..2cd72d6 100644
--- a/src/SharpFM.Model/Scripting/Steps/ConfigureRAGAccountStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ConfigureRAGAccountStep.cs
@@ -1,22 +1,30 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
+/// <summary>
+/// Configure RAG Account (227). Canonical form (skill, accounts/AI reference):
+/// <c>&lt;VerifySSLCertificates state="False"/&gt;</c> followed by a
+/// <c>&lt;ConfigureRAGAccount&gt;</c> wrapper that holds the account fields when
+/// configured and is emitted empty when not. The step name carries a trailing
+/// space, preserved verbatim.
+/// </summary>
 public sealed class ConfigureRAGAccountStep : ScriptStep, IStepFactory
 {
     public const int XmlId = 227;
     public const string XmlName = "Configure RAG Account ";
 
-    public Calculation RAGAccountName { get; set; }
-    public Calculation Endpoint { get; set; }
-    public Calculation APIKey { get; set; }
+    public Calculation RAGAccountName { get; set; } = new("");
+    public Calculation Endpoint { get; set; } = new("");
+    public Calculation APIKey { get; set; } = new("");
     public bool VerifySSLCertificates { get; set; }
 
+    private ConfigureRAGAccountStep() : base(false) { }
+
     public ConfigureRAGAccountStep(
         Calculation? rAGAccountName = null,
         Calculation? endpoint = null,
@@ -31,87 +39,32 @@ public ConfigureRAGAccountStep(
         VerifySSLCertificates = verifySSLCertificates;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("RAGAccountName", RAGAccountName.ToXml("Calculation")),
-            new XElement("Endpoint", Endpoint.ToXml("Calculation")),
-            new XElement("AccessAPIKey", APIKey.ToXml("Calculation")),
-            new XElement("VerifySSLCertificates", new XAttribute("state", VerifySSLCertificates ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Configure RAG Account  [ " + "RAG Account Name: " + RAGAccountName.Text + " ; " + "Endpoint: " + Endpoint.Text + " ; " + "API key: " + APIKey.Text + " ; " + "Verify SSL Certificates: " + (VerifySSLCertificates ? "On" : "Off") + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var rAGAccountName_vWrapEl = step.Element("RAGAccountName");
-        var rAGAccountName_vCalcEl = rAGAccountName_vWrapEl?.Element("Calculation");
-        var rAGAccountName_v = rAGAccountName_vCalcEl is not null ? Calculation.FromXml(rAGAccountName_vCalcEl) : new Calculation("");
-        var endpoint_vWrapEl = step.Element("Endpoint");
-        var endpoint_vCalcEl = endpoint_vWrapEl?.Element("Calculation");
-        var endpoint_v = endpoint_vCalcEl is not null ? Calculation.FromXml(endpoint_vCalcEl) : new Calculation("");
-        var aPIKey_vWrapEl = step.Element("AccessAPIKey");
-        var aPIKey_vCalcEl = aPIKey_vWrapEl?.Element("Calculation");
-        var aPIKey_v = aPIKey_vCalcEl is not null ? Calculation.FromXml(aPIKey_vCalcEl) : new Calculation("");
-        var verifySSLCertificates_v = step.Element("VerifySSLCertificates")?.Attribute("state")?.Value == "True";
-        return new ConfigureRAGAccountStep(rAGAccountName_v, endpoint_v, aPIKey_v, verifySSLCertificates_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ConfigureRAGAccountStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? rAGAccountName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("RAG Account Name:", StringComparison.OrdinalIgnoreCase)) { rAGAccountName_v = new Calculation(tok.Substring(17).Trim()); break; } }
-        Calculation? endpoint_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Endpoint:", StringComparison.OrdinalIgnoreCase)) { endpoint_v = new Calculation(tok.Substring(9).Trim()); break; } }
-        Calculation? aPIKey_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("API key:", StringComparison.OrdinalIgnoreCase)) { aPIKey_v = new Calculation(tok.Substring(8).Trim()); break; } }
-        bool verifySSLCertificates_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Verify SSL Certificates:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(24).Trim(); verifySSLCertificates_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        return new ConfigureRAGAccountStep(rAGAccountName_v, endpoint_v, aPIKey_v, verifySSLCertificates_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ConfigureRAGAccountStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
-        Params =
+        // Canonical: VerifySSLCertificates, then the <ConfigureRAGAccount> wrapper
+        // holding the (optional) account fields. Unconfigured -> empty wrapper.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "RAG Account Name",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Endpoint",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "API key",
-            },
-            new ParamMetadata
-            {
-                Name = "VerifySSLCertificates",
-                XmlElement = "VerifySSLCertificates",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Verify SSL Certificates",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
+            new BoolStateChild("VerifySSLCertificates") { PocoProperty = "VerifySSLCertificates", HrLabel = "Verify SSL Certificates", Display = DisplayMode.Augmented },
+            new WrapperChild("ConfigureRAGAccount",
+            [
+                new NamedCalcChild("RAGAccountName") { PocoProperty = "RAGAccountName", HrLabel = "RAG Account Name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+                new NamedCalcChild("Endpoint") { PocoProperty = "Endpoint", HrLabel = "Endpoint", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+                new NamedCalcChild("AccessAPIKey") { PocoProperty = "APIKey", HrLabel = "API key", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            ]),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ConfigureRegionMonitorScriptStep.cs b/src/SharpFM.Model/Scripting/Steps/ConfigureRegionMonitorScriptStep.cs
index 1a1ba1a..9858b6d 100644
--- a/src/SharpFM.Model/Scripting/Steps/ConfigureRegionMonitorScriptStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ConfigureRegionMonitorScriptStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,35 +13,42 @@ public sealed class ConfigureRegionMonitorScriptStep : ScriptStep, IStepFactory
 
     public StepChildBag Children { get; set; }
 
+    private ConfigureRegionMonitorScriptStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public ConfigureRegionMonitorScriptStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ConfigureRegionMonitorScriptStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ConfigureRegionMonitorScriptStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new ConfigureRegionMonitorScriptStep(enabled: enabled);
+        StepDisplayParser.Parse<ConfigureRegionMonitorScriptStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "control",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/ConfigureRegressionModelStep.cs b/src/SharpFM.Model/Scripting/Steps/ConfigureRegressionModelStep.cs
index be13732..aa16f32 100644
--- a/src/SharpFM.Model/Scripting/Steps/ConfigureRegressionModelStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ConfigureRegressionModelStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,35 +13,42 @@ public sealed class ConfigureRegressionModelStep : ScriptStep, IStepFactory
 
     public StepChildBag Children { get; set; }
 
+    private ConfigureRegressionModelStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public ConfigureRegressionModelStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ConfigureRegressionModelStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ConfigureRegressionModelStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new ConfigureRegressionModelStep(enabled: enabled);
+        StepDisplayParser.Parse<ConfigureRegressionModelStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/ConstrainFoundSetStep.cs b/src/SharpFM.Model/Scripting/Steps/ConstrainFoundSetStep.cs
index 3fbcc94..6751c0f 100644
--- a/src/SharpFM.Model/Scripting/Steps/ConstrainFoundSetStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ConstrainFoundSetStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +15,8 @@ public sealed class ConstrainFoundSetStep : ScriptStep, IStepFactory
     public bool RestoreStoredRequests { get; set; }
     public FindRequestList? Query { get; set; }
 
+    private ConstrainFoundSetStep() : base(false) { RestoreStoredRequests = true; }
+
     public ConstrainFoundSetStep(
         bool withoutIndexes = true,
         bool restoreStoredRequests = true,
@@ -25,42 +29,23 @@ public ConstrainFoundSetStep(
         Query = query;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Option", new XAttribute("state", WithoutIndexes ? "True" : "False")),
-            new XElement("Restore", new XAttribute("state", RestoreStoredRequests ? "True" : "False")));
-        if (Query is not null) step.Add(Query.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Constrain Found Set [ Restore: {(RestoreStoredRequests ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var option = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var restore = step.Element("Restore")?.Attribute("state")?.Value == "True";
-        var qEl = step.Element("Query");
-        var q = qEl is not null ? FindRequestList.FromXml(qEl) : null;
-        return new ConstrainFoundSetStep(option, restore, q, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ConstrainFoundSetStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        bool restore = true;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("Restore:", System.StringComparison.OrdinalIgnoreCase))
-                restore = t.Substring(8).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
-        }
-        return new ConstrainFoundSetStep(true, restore, null, enabled);
-    }
+    /// <summary>
+    /// Display edits are anchor-preserved when state the display line cannot
+    /// carry is present: a stored <c>&lt;Query&gt;</c> request list, or an
+    /// <c>&lt;Option&gt;</c> flag set to True (the display shows only the
+    /// Restore toggle).
+    /// </summary>
+    public override bool IsFullyEditable => !WithoutIndexes && Query is null;
+
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ConstrainFoundSetStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -68,11 +53,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "found sets",
         HelpUrl = "https://help.claris.com/en/pro-help/content/constrain-found-set.html",
-        Params =
+        // Option and Restore always emitted; <Query> only when a stored
+        // request list is present.
+        Shape =
         [
-            new ParamMetadata { Name = "Option", XmlElement = "Option", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Query", XmlElement = "Query", Type = "findRequests" },
+            new BoolStateChild("Option") { PocoProperty = "WithoutIndexes", Display = DisplayMode.Hidden },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredRequests", HrLabel = "Restore" },
+            new ValueTypeChild("Query") { PocoProperty = "Query", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ControlFlowSteps.cs b/src/SharpFM.Model/Scripting/Steps/ControlFlowSteps.cs
index b243b70..0e8fbd2 100644
--- a/src/SharpFM.Model/Scripting/Steps/ControlFlowSteps.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ControlFlowSteps.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
 using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -8,22 +9,17 @@ namespace SharpFM.Model.Scripting.Steps;
 /// <summary>
 /// Typed POCOs for FileMaker's block-pair control-flow steps:
 /// <c>If</c>, <c>Else If</c>, <c>Else</c>, <c>End If</c>, <c>Loop</c>,
-/// <c>End Loop</c>, <c>Exit Loop If</c>.
+/// <c>End Loop</c>, <c>Exit Loop If</c>. Serialization is shape-driven
+/// (<see cref="StepXmlRenderer"/> / <see cref="StepXmlParser"/>).
 /// <para>
-/// Every step here is an <see cref="IStepFactory"/>. The single-file
-/// layout keeps the related steps and their shared helpers
-/// (<see cref="IfStep.BuildConditionedStep"/>, <see cref="ElseStep.BuildBareStep"/>)
-/// colocated.
-/// </para>
-/// <para>
-/// Zero-loss audit:
-/// <list type="bullet">
-/// <item><c>If</c> / <c>Else If</c> / <c>Loop</c> carry a <c>Restore</c> element in some upstream XML
-/// sources. FM Pro never writes it and never changes the value; we drop it on read and never emit it.
-/// See <c>docs/advanced-filemaker-scripting-syntax.md</c>.</item>
-/// <item><c>Loop</c>'s <c>FlushType</c> enum is also absent from FM Pro clipboard output. Not surfaced
-/// in display and not round-tripped — same "semantically fixed / never-changed" justification.</item>
-/// </list>
+/// Canonical-form note: per the vendored FileMaker XML skill (§8.1), FileMaker
+/// Pro <em>does</em> emit <c>&lt;Restore state="False"/&gt;</c> on
+/// <c>If</c> / <c>Else If</c> / <c>Else</c> / <c>Loop</c>, and
+/// <c>&lt;FlushType value="Always"/&gt;</c> on <c>Loop</c>. These are paste-clean
+/// canonical elements, so SharpFM emits them. They carry fixed values FileMaker
+/// never varies, so they are hidden from the display line but round-tripped in
+/// XML. (Earlier revisions dropped them on the belief FM never wrote them; the
+/// skill's round-trip testing against FM Pro 2025/2026 supersedes that.)
 /// </para>
 /// </summary>
 public sealed class IfStep : ScriptStep, IStepFactory
@@ -31,7 +27,12 @@ public sealed class IfStep : ScriptStep, IStepFactory
     public const int XmlId = 68;
     public const string XmlName = "If";
 
-    public Calculation Condition { get; set; }
+    public Calculation Condition { get; set; } = new("");
+
+    /// <summary>The canonical <c>&lt;Restore state="False"/&gt;</c> flag (skill §8.1); fixed-value, XML-only.</summary>
+    public bool Restore { get; set; }
+
+    private IfStep() : base(false) { }
 
     public IfStep(bool enabled, Calculation condition)
         : base(enabled)
@@ -40,17 +41,14 @@ public IfStep(bool enabled, Calculation condition)
     }
 
     public static new ScriptStep FromXml(XElement step) =>
-        new IfStep(
-            step.Attribute("enable")?.Value != "False",
-            ReadCalculation(step));
+        StepXmlParser.Parse<IfStep>(step, Metadata);
 
-    public override XElement ToXml() =>
-        BuildConditionedStep(this, XmlName, XmlId, Condition);
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => $"If [ {Condition.Text} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new IfStep(enabled, ParseCondition(hrParams));
+        StepDisplayParser.Parse<IfStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -64,39 +62,16 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
             Role = BlockPairRole.Open,
             Partners = ["Else", "Else If", "End If"],
         },
-        Params =
+        // Canonical §8.1: <Restore state="False"/> then <Calculation>.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "condition",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                Required = true,
-            },
+            new BoolStateChild("Restore") { PocoProperty = "Restore", Display = DisplayMode.Hidden },
+            new BareCalcChild { PocoProperty = "Condition", Required = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         Notes = new StepNotes { Constraints = "Requires a matching End If step." },
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
-
-    internal static Calculation ReadCalculation(XElement step)
-    {
-        var calc = step.Element("Calculation");
-        return calc is not null ? Calculation.FromXml(calc) : new Calculation("");
-    }
-
-    internal static Calculation ParseCondition(string[] hrParams) =>
-        hrParams.Length >= 1 ? new Calculation(hrParams[0].Trim()) : new Calculation("");
-
-    internal static XElement BuildConditionedStep(ScriptStep owner, string name, int id, Calculation condition)
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", owner.Enabled ? "True" : "False"),
-            new XAttribute("id", id),
-            new XAttribute("name", name));
-        step.Add(condition.ToXml());
-        return step;
-    }
 }
 
 public sealed class ElseIfStep : ScriptStep, IStepFactory
@@ -104,7 +79,12 @@ public sealed class ElseIfStep : ScriptStep, IStepFactory
     public const int XmlId = 125;
     public const string XmlName = "Else If";
 
-    public Calculation Condition { get; set; }
+    public Calculation Condition { get; set; } = new("");
+
+    /// <summary>The canonical <c>&lt;Restore state="False"/&gt;</c> flag (skill §8.1); fixed-value, XML-only.</summary>
+    public bool Restore { get; set; }
+
+    private ElseIfStep() : base(false) { }
 
     public ElseIfStep(bool enabled, Calculation condition)
         : base(enabled)
@@ -113,17 +93,14 @@ public ElseIfStep(bool enabled, Calculation condition)
     }
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ElseIfStep(
-            step.Attribute("enable")?.Value != "False",
-            IfStep.ReadCalculation(step));
+        StepXmlParser.Parse<ElseIfStep>(step, Metadata);
 
-    public override XElement ToXml() =>
-        IfStep.BuildConditionedStep(this, XmlName, XmlId, Condition);
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => $"Else If [ {Condition.Text} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new ElseIfStep(enabled, IfStep.ParseCondition(hrParams));
+        StepDisplayParser.Parse<ElseIfStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -137,15 +114,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
             Role = BlockPairRole.Middle,
             Partners = ["If", "End If"],
         },
-        Params =
+        // Canonical §8.1: <Restore state="False"/> then <Calculation>.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "condition",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                Required = true,
-            },
+            new BoolStateChild("Restore") { PocoProperty = "Restore", Display = DisplayMode.Hidden },
+            new BareCalcChild { PocoProperty = "Condition", Required = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
@@ -157,18 +130,23 @@ public sealed class ElseStep : ScriptStep, IStepFactory
     public const int XmlId = 69;
     public const string XmlName = "Else";
 
+    /// <summary>The canonical <c>&lt;Restore state="False"/&gt;</c> flag (skill §8.1); fixed-value, XML-only.</summary>
+    public bool Restore { get; set; }
+
+    private ElseStep() : base(false) { }
+
     public ElseStep(bool enabled)
         : base(enabled) { }
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ElseStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ElseStep>(step, Metadata);
 
-    public override XElement ToXml() => BuildBareStep(this, XmlName, XmlId);
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new ElseStep(enabled);
+        StepDisplayParser.Parse<ElseStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -182,15 +160,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
             Role = BlockPairRole.Middle,
             Partners = ["If", "End If"],
         },
+        // Canonical §8.1: <Restore state="False"/>.
+        Shape = [new BoolStateChild("Restore") { PocoProperty = "Restore", Display = DisplayMode.Hidden }],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
-
-    internal static XElement BuildBareStep(ScriptStep owner, string name, int id) =>
-        new("Step",
-            new XAttribute("enable", owner.Enabled ? "True" : "False"),
-            new XAttribute("id", id),
-            new XAttribute("name", name));
 }
 
 public sealed class EndIfStep : ScriptStep, IStepFactory
@@ -198,18 +172,20 @@ public sealed class EndIfStep : ScriptStep, IStepFactory
     public const int XmlId = 70;
     public const string XmlName = "End If";
 
+    private EndIfStep() : base(false) { }
+
     public EndIfStep(bool enabled)
         : base(enabled) { }
 
     public static new ScriptStep FromXml(XElement step) =>
-        new EndIfStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<EndIfStep>(step, Metadata);
 
-    public override XElement ToXml() => ElseStep.BuildBareStep(this, XmlName, XmlId);
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new EndIfStep(enabled);
+        StepDisplayParser.Parse<EndIfStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -233,18 +209,26 @@ public sealed class LoopStep : ScriptStep, IStepFactory
     public const int XmlId = 71;
     public const string XmlName = "Loop";
 
+    /// <summary>The canonical <c>&lt;Restore state="False"/&gt;</c> flag (skill §8.1); fixed-value, XML-only.</summary>
+    public bool Restore { get; set; }
+
+    /// <summary>The canonical <c>&lt;FlushType value="Always"/&gt;</c> flag (skill §8.1); fixed-value, XML-only.</summary>
+    public string FlushType { get; set; } = "Always";
+
+    private LoopStep() : base(false) { }
+
     public LoopStep(bool enabled)
         : base(enabled) { }
 
     public static new ScriptStep FromXml(XElement step) =>
-        new LoopStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<LoopStep>(step, Metadata);
 
-    public override XElement ToXml() => ElseStep.BuildBareStep(this, XmlName, XmlId);
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new LoopStep(enabled);
+        StepDisplayParser.Parse<LoopStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -258,6 +242,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
             Role = BlockPairRole.Open,
             Partners = ["End Loop"],
         },
+        // Canonical §8.1: <Restore state="False"/> then <FlushType value="Always"/>.
+        Shape =
+        [
+            new BoolStateChild("Restore") { PocoProperty = "Restore", Display = DisplayMode.Hidden },
+            new EnumValueChild("FlushType") { PocoProperty = "FlushType", DefaultValue = "Always", Display = DisplayMode.Hidden },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
@@ -268,18 +258,20 @@ public sealed class EndLoopStep : ScriptStep, IStepFactory
     public const int XmlId = 73;
     public const string XmlName = "End Loop";
 
+    private EndLoopStep() : base(false) { }
+
     public EndLoopStep(bool enabled)
         : base(enabled) { }
 
     public static new ScriptStep FromXml(XElement step) =>
-        new EndLoopStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<EndLoopStep>(step, Metadata);
 
-    public override XElement ToXml() => ElseStep.BuildBareStep(this, XmlName, XmlId);
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new EndLoopStep(enabled);
+        StepDisplayParser.Parse<EndLoopStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -303,7 +295,9 @@ public sealed class ExitLoopIfStep : ScriptStep, IStepFactory
     public const int XmlId = 72;
     public const string XmlName = "Exit Loop If";
 
-    public Calculation Condition { get; set; }
+    public Calculation Condition { get; set; } = new("");
+
+    private ExitLoopIfStep() : base(false) { }
 
     public ExitLoopIfStep(bool enabled, Calculation condition)
         : base(enabled)
@@ -312,17 +306,14 @@ public ExitLoopIfStep(bool enabled, Calculation condition)
     }
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ExitLoopIfStep(
-            step.Attribute("enable")?.Value != "False",
-            IfStep.ReadCalculation(step));
+        StepXmlParser.Parse<ExitLoopIfStep>(step, Metadata);
 
-    public override XElement ToXml() =>
-        IfStep.BuildConditionedStep(this, XmlName, XmlId, Condition);
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => $"Exit Loop If [ {Condition.Text} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new ExitLoopIfStep(enabled, IfStep.ParseCondition(hrParams));
+        StepDisplayParser.Parse<ExitLoopIfStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -336,16 +327,8 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
             Role = BlockPairRole.Middle,
             Partners = ["Loop", "End Loop"],
         },
-        Params =
-        [
-            new ParamMetadata
-            {
-                Name = "condition",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                Required = true,
-            },
-        ],
+        // Canonical §8.1: bare <Calculation> only — no <Restore> on Exit Loop If.
+        Shape = [new BareCalcChild { PocoProperty = "Condition", Required = true, Display = DisplayMode.Native, DisplayEmptyAs = "" }],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/ConvertFileStep.cs b/src/SharpFM.Model/Scripting/Steps/ConvertFileStep.cs
index 9936c5b..c823583 100644
--- a/src/SharpFM.Model/Scripting/Steps/ConvertFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ConvertFileStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -18,10 +20,18 @@ public sealed class ConvertFileStep : ScriptStep, IStepFactory
 
     public bool OpenFile { get; set; }
     public bool SkipIndexes { get; set; }
-    public bool WithDialog { get; set; }
-    public string DataSourceType { get; set; }
+
+    /// <summary>Raw <c>&lt;NoInteract&gt;</c> state. <see cref="WithDialog"/> is its inverse.</summary>
+    public bool NoInteract { get; set; }
+
+    /// <summary>UI-facing "with dialog" flag — the inverse of the wire <c>NoInteract</c> state.</summary>
+    public bool WithDialog { get => !NoInteract; set => NoInteract = !value; }
+
+    public string DataSourceType { get; set; } = "File";
     public bool VerifySSLCertificates { get; set; }
 
+    private ConvertFileStep() : base(false) { }
+
     public ConvertFileStep(
         bool openFile = false,
         bool skipIndexes = false,
@@ -38,17 +48,10 @@ public ConvertFileStep(
         VerifySSLCertificates = verifySSLCertificates;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Option", new XAttribute("state", OpenFile ? "True" : "False")),
-            new XElement("SkipIndexes", new XAttribute("state", SkipIndexes ? "True" : "False")),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("DataSourceType", new XAttribute("value", DataSourceType)),
-            new XElement("VerifySSLCertificates", new XAttribute("state", VerifySSLCertificates ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: With dialog renders mid-line between same-mode groups, an
+    // order the Native-then-Augmented display projection cannot produce.
     public override string ToDisplayLine() =>
         "Convert File [ "
         + "Open File: " + (OpenFile ? "On" : "Off")
@@ -58,22 +61,8 @@ public override string ToDisplayLine() =>
         + " ; Verify SSL Certificates: " + (VerifySSLCertificates ? "On" : "Off")
         + " ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var option = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var skipIdx = step.Element("SkipIndexes")?.Attribute("state")?.Value == "True";
-        var noInteract = step.Element("NoInteract")?.Attribute("state")?.Value == "True";
-        var dataType = step.Element("DataSourceType")?.Attribute("value")?.Value ?? "File";
-        var sslVerify = step.Element("VerifySSLCertificates")?.Attribute("state")?.Value == "True";
-        return new ConvertFileStep(
-            openFile: option,
-            skipIndexes: skipIdx,
-            withDialog: !noInteract,
-            dataSourceType: dataType,
-            verifySSLCertificates: sslVerify,
-            enabled: enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ConvertFileStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -112,39 +101,15 @@ private static bool ParseOn(string[] tokens, string prefix, bool defaultValue)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/convert-file.html",
-        Params =
+        // Canonical order: NoInteract, Option, SkipIndexes, VerifySSLCertificates,
+        // then the optional DataSourceType (omitted for the default File source).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Option", XmlElement = "Option", Type = "boolean",
-                XmlAttr = "state", HrLabel = "Open File",
-                ValidValues = ["On", "Off"], DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "SkipIndexes", XmlElement = "SkipIndexes", Type = "boolean",
-                XmlAttr = "state", HrLabel = "Skip Indexes",
-                ValidValues = ["On", "Off"], DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "NoInteract", XmlElement = "NoInteract", Type = "boolean",
-                XmlAttr = "state", HrLabel = "With dialog",
-                // Inverted: XML state=True means HR "With dialog: Off".
-                ValidValues = ["On", "Off"], DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "DataSourceType", XmlElement = "DataSourceType", Type = "enum",
-                XmlAttr = "value",
-                ValidValues = ["File", "XMLSource"], DefaultValue = "File",
-            },
-            new ParamMetadata
-            {
-                Name = "VerifySSLCertificates", XmlElement = "VerifySSLCertificates", Type = "boolean",
-                XmlAttr = "state", HrLabel = "Verify SSL Certificates",
-                ValidValues = ["On", "Off"], DefaultValue = "False",
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteract", HrLabel = "With dialog", Display = DisplayMode.Augmented },
+            new BoolStateChild("Option") { PocoProperty = "OpenFile", HrLabel = "Open File", Display = DisplayMode.Augmented },
+            new BoolStateChild("SkipIndexes") { PocoProperty = "SkipIndexes", HrLabel = "Skip Indexes", Display = DisplayMode.Augmented },
+            new BoolStateChild("VerifySSLCertificates") { PocoProperty = "VerifySSLCertificates", HrLabel = "Verify SSL Certificates", Display = DisplayMode.Augmented },
+            new EnumValueChild("DataSourceType") { PocoProperty = "DataSourceType", Optional = true, DisplayValues = ["File", "XMLSource"], Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/CopyAllRecordsRequestsStep.cs b/src/SharpFM.Model/Scripting/Steps/CopyAllRecordsRequestsStep.cs
index f2bf212..21bf556 100644
--- a/src/SharpFM.Model/Scripting/Steps/CopyAllRecordsRequestsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CopyAllRecordsRequestsStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class CopyAllRecordsRequestsStep : ScriptStep, IStepFactory
     public const int XmlId = 98;
     public const string XmlName = "Copy All Records/Requests";
 
+    private CopyAllRecordsRequestsStep() : base(false) { }
+
     public CopyAllRecordsRequestsStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new CopyAllRecordsRequestsStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<CopyAllRecordsRequestsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new CopyAllRecordsRequestsStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CopyAllRecordsRequestsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/CopyRecordRequestStep.cs b/src/SharpFM.Model/Scripting/Steps/CopyRecordRequestStep.cs
index 8f57074..02cb1ad 100644
--- a/src/SharpFM.Model/Scripting/Steps/CopyRecordRequestStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CopyRecordRequestStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class CopyRecordRequestStep : ScriptStep, IStepFactory
     public const int XmlId = 101;
     public const string XmlName = "Copy Record/Request";
 
+    private CopyRecordRequestStep() : base(false) { }
+
     public CopyRecordRequestStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new CopyRecordRequestStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<CopyRecordRequestStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new CopyRecordRequestStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CopyRecordRequestStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/CopyStep.cs b/src/SharpFM.Model/Scripting/Steps/CopyStep.cs
index 8019690..feee9cb 100644
--- a/src/SharpFM.Model/Scripting/Steps/CopyStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CopyStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +14,9 @@ public sealed class CopyStep : ScriptStep, IStepFactory
     public const string XmlName = "Copy";
 
     public bool Select { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private CopyStep() : base(false) { Select = true; }
 
     public CopyStep(
         bool select = true,
@@ -21,38 +25,18 @@ public CopyStep(
         : base(enabled)
     {
         Select = select;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Copy [ " + "Select: " + (Select ? "On" : "Off") + " ; " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new CopyStep(select_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<CopyStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool select_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); select_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (!tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(tok)) { target = FieldRef.FromDisplayToken(tok); break; } }
-        return new CopyStep(select_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CopyStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,24 +44,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "editing",
         HelpUrl = "https://help.claris.com/en/pro-help/content/copy.html",
-        Params =
+        // Canonical 047-Copy: only <SelectAll>; <Field> is omitted until a
+        // target is bound, so it is Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Select",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-            },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/CorrectWordStep.cs b/src/SharpFM.Model/Scripting/Steps/CorrectWordStep.cs
index 8f5e089..54b8e89 100644
--- a/src/SharpFM.Model/Scripting/Steps/CorrectWordStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CorrectWordStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class CorrectWordStep : ScriptStep, IStepFactory
     public const int XmlId = 106;
     public const string XmlName = "Correct Word";
 
+    private CorrectWordStep() : base(false) { }
+
     public CorrectWordStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new CorrectWordStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<CorrectWordStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new CorrectWordStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CorrectWordStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/CreateDataFileStep.cs b/src/SharpFM.Model/Scripting/Steps/CreateDataFileStep.cs
index a2fe992..d5910cc 100644
--- a/src/SharpFM.Model/Scripting/Steps/CreateDataFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CreateDataFileStep.cs
@@ -1,8 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -14,6 +13,8 @@ public sealed class CreateDataFileStep : ScriptStep, IStepFactory
     public string UniversalPathList { get; set; }
     public bool CreateFolders { get; set; }
 
+    private CreateDataFileStep() : base(false) { UniversalPathList = ""; CreateFolders = true; }
+
     public CreateDataFileStep(
         string universalPathList = "",
         bool createFolders = true,
@@ -24,36 +25,15 @@ public CreateDataFileStep(
         CreateFolders = createFolders;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UniversalPathList", UniversalPathList),
-            new XElement("CreateDirectories", new XAttribute("state", CreateFolders ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Create Data File [ " + UniversalPathList + " ; " + "Create folders: " + (CreateFolders ? "On" : "Off") + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var universalPathList_v = step.Element("UniversalPathList")?.Value ?? "";
-        var createFolders_v = step.Element("CreateDirectories")?.Attribute("state")?.Value == "True";
-        return new CreateDataFileStep(universalPathList_v, createFolders_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<CreateDataFileStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        string universalPathList_v = "";
-        bool createFolders_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Create folders:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(15).Trim(); createFolders_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        // Unlabeled text param — pick the token that doesn't match known labels.
-        universalPathList_v = tokens.FirstOrDefault(t =>
-            !t.StartsWith("Create folders:", StringComparison.OrdinalIgnoreCase)) ?? "";
-        return new CreateDataFileStep(universalPathList_v, createFolders_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CreateDataFileStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -61,24 +41,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/create-data-file.html",
-        Params =
+        // Canonical form omits the (optional) path; CreateDirectories is always emitted.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "UniversalPathList",
-                XmlElement = "UniversalPathList",
-                Type = "text",
-            },
-            new ParamMetadata
-            {
-                Name = "CreateDirectories",
-                XmlElement = "CreateDirectories",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Create folders",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "UniversalPathList", Optional = true, DisplayEmptyAs = "" },
+            new BoolStateChild("CreateDirectories") { PocoProperty = "CreateFolders", HrLabel = "Create folders" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/CreatePdfStep.cs b/src/SharpFM.Model/Scripting/Steps/CreatePdfStep.cs
new file mode 100644
index 0000000..0f98d49
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Steps/CreatePdfStep.cs
@@ -0,0 +1,111 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Values;
+
+namespace SharpFM.Model.Scripting.Steps;
+
+/// <summary>
+/// Create PDF starts a multi-step PDF assembly. It carries the
+/// restore-stored-options flag, an optional stored-label calculation, and a
+/// <c>&lt;CreatePDFFile&gt;</c> wrapper whose <c>Document</c> / <c>Security</c>
+/// / <c>View</c> blocks reuse the same value types as Save Records as PDF.
+/// </summary>
+public sealed class CreatePdfStep : ScriptStep, IStepFactory
+{
+    public const int XmlId = 243;
+    public const string XmlName = "Create PDF";
+
+    public bool RestoreStoredOptions { get; set; }
+    public Calculation? StoredLabel { get; set; }
+    public PdfDocument Document { get; set; } = new(null, null, null, null, true, null);
+    public PdfSecurity Security { get; set; } = PdfSecurity.Default();
+    public PdfView View { get; set; } = PdfView.Default();
+
+    private CreatePdfStep() : base(false) { }
+
+    public CreatePdfStep(
+        bool restoreStoredOptions = false,
+        Calculation? storedLabel = null,
+        PdfDocument? document = null,
+        PdfSecurity? security = null,
+        PdfView? view = null,
+        bool enabled = true)
+        : base(enabled)
+    {
+        RestoreStoredOptions = restoreStoredOptions;
+        StoredLabel = storedLabel;
+        Document = document ?? new PdfDocument(null, null, null, null, true, null);
+        Security = security ?? PdfSecurity.Default();
+        View = view ?? PdfView.Default();
+    }
+
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
+
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<CreatePdfStep>(step, Metadata);
+
+    /// <summary>
+    /// The canonical Document block FileMaker writes for an unconfigured
+    /// step: all pages numbered from 1 with a 1–1 page range.
+    /// </summary>
+    internal static PdfDocument DefaultDocument() =>
+        new(null, null, null, null, true,
+            new Calculation("1"), new Calculation("1"), new Calculation("1"));
+
+    /// <summary>
+    /// Display edits are anchor-preserved when state the display line cannot
+    /// carry is present: a stored-label calculation, or Document/Security/View
+    /// blocks configured beyond the canonical unconfigured form (the display
+    /// shows only the Restore toggle).
+    /// </summary>
+    public override bool IsFullyEditable =>
+        StoredLabel is null
+        && Document == DefaultDocument()
+        && Security == PdfSecurity.Default()
+        && View == PdfView.Default();
+
+    // Hand-written: must materialize the canonical Document block
+    // (DefaultDocument) that the shape parser's plain ctor cannot supply.
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
+    {
+        var restore = false;
+        foreach (var tok in hrParams)
+        {
+            var t = tok.Trim();
+            if (t.StartsWith("Restore:", System.StringComparison.OrdinalIgnoreCase))
+                restore = t.Substring(8).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
+        }
+        return new CreatePdfStep(restore, null, DefaultDocument(), null, null, enabled);
+    }
+
+    public static StepMetadata Metadata { get; } = new()
+    {
+        Name = XmlName,
+        Id = XmlId,
+        Category = "files",
+        HelpUrl = "https://help.claris.com/en/pro-help/content/create-pdf.html",
+        // Restore always emitted; a bare stored-label <Calculation> only when
+        // set; the <CreatePDFFile> wrapper always emitted with its
+        // Document / Security / View blocks.
+        Shape =
+        [
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredOptions", HrLabel = "Restore" },
+            new BareCalcChild { PocoProperty = "StoredLabel", Optional = true, Display = DisplayMode.Hidden },
+            new WrapperChild("CreatePDFFile",
+            [
+                new ValueTypeChild("Document") { PocoProperty = "Document", Display = DisplayMode.Hidden },
+                new ValueTypeChild("Security") { PocoProperty = "Security", Display = DisplayMode.Hidden },
+                new ValueTypeChild("View") { PocoProperty = "View", Display = DisplayMode.Hidden },
+            ]),
+            // The wrapper's Document/Security/View blocks surface as one opaque
+            // display slot, mirroring the legacy CreatePDFFile param.
+            new HrOnly("CreatePDFFile"),
+        ],
+        FromXml = FromXml,
+        FromDisplay = FromDisplayParams,
+    };
+}
diff --git a/src/SharpFM.Model/Scripting/Steps/CutStep.cs b/src/SharpFM.Model/Scripting/Steps/CutStep.cs
index 06642d7..a890390 100644
--- a/src/SharpFM.Model/Scripting/Steps/CutStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/CutStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +14,9 @@ public sealed class CutStep : ScriptStep, IStepFactory
     public const string XmlName = "Cut";
 
     public bool Select { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private CutStep() : base(false) { Select = true; }
 
     public CutStep(
         bool select = true,
@@ -21,38 +25,18 @@ public CutStep(
         : base(enabled)
     {
         Select = select;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Cut [ " + "Select: " + (Select ? "On" : "Off") + " ; " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new CutStep(select_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<CutStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool select_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); select_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (!tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(tok)) { target = FieldRef.FromDisplayToken(tok); break; } }
-        return new CutStep(select_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<CutStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,24 +44,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "editing",
         HelpUrl = "https://help.claris.com/en/pro-help/content/cut.html",
-        Params =
+        // Canonical 046-Cut: only <SelectAll>; <Field> is omitted until a
+        // target is bound, so it is Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Select",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-            },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/DeleteAccountStep.cs b/src/SharpFM.Model/Scripting/Steps/DeleteAccountStep.cs
index 82fd5e7..5238dc3 100644
--- a/src/SharpFM.Model/Scripting/Steps/DeleteAccountStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/DeleteAccountStep.cs
@@ -1,8 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +11,9 @@ public sealed class DeleteAccountStep : ScriptStep, IStepFactory
     public const int XmlId = 135;
     public const string XmlName = "Delete Account";
 
-    public Calculation AccountName { get; set; }
+    public Calculation AccountName { get; set; } = new("");
+
+    private DeleteAccountStep() : base(false) { }
 
     public DeleteAccountStep(
         Calculation? accountName = null,
@@ -22,32 +23,15 @@ public DeleteAccountStep(
         AccountName = accountName ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("AccountName", AccountName.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Delete Account [ " + "Account Name: " + AccountName.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var accountName_vWrapEl = step.Element("AccountName");
-        var accountName_vCalcEl = accountName_vWrapEl?.Element("Calculation");
-        var accountName_v = accountName_vCalcEl is not null ? Calculation.FromXml(accountName_vCalcEl) : new Calculation("");
-        return new DeleteAccountStep(accountName_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<DeleteAccountStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? accountName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Account Name:", StringComparison.OrdinalIgnoreCase)) { accountName_v = new Calculation(tok.Substring(13).Trim()); break; } }
-        return new DeleteAccountStep(accountName_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<DeleteAccountStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -55,15 +39,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "accounts",
         HelpUrl = "https://help.claris.com/en/pro-help/content/delete-account.html",
-        Params =
+        // The AccountName wrapper is omitted by the unconfigured form (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Account Name",
-            },
+            new NamedCalcChild("AccountName") { PocoProperty = "AccountName", HrLabel = "Account Name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/DeleteAllRecordsStep.cs b/src/SharpFM.Model/Scripting/Steps/DeleteAllRecordsStep.cs
index d0f3ecf..bb2cd6c 100644
--- a/src/SharpFM.Model/Scripting/Steps/DeleteAllRecordsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/DeleteAllRecordsStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,39 +19,31 @@ public sealed class DeleteAllRecordsStep : ScriptStep, IStepFactory
     /// <summary>The <c>With dialog</c> flag on the step.</summary>
     public bool WithDialog { get; set; }
 
+    /// <summary>
+    /// XML-facing inverse of <see cref="WithDialog"/>: canonical
+    /// <c>&lt;NoInteract state="…"/&gt;</c> suppresses the dialog, so it is the
+    /// negation of the display-facing flag. The shape binds this so the raw
+    /// state round-trips without re-applying the inversion.
+    /// </summary>
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+
+    private DeleteAllRecordsStep() : base(false) { }
+
     public DeleteAllRecordsStep(bool withdialog = false, bool enabled = true)
         : base(enabled)
     {
         WithDialog = withdialog;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract",
-                new XAttribute("state", WithDialog ? "False" : "True")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Delete All Records [ With dialog: {(WithDialog ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        return new DeleteAllRecordsStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<DeleteAllRecordsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "With dialog:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        var isOn = token.Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new DeleteAllRecordsStep(!isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<DeleteAllRecordsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -57,18 +51,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "records",
         HelpUrl = "https://help.claris.com/en/pro-help/content/delete-all-records.html",
-        Params =
+        // Single always-emitted <NoInteract state="..."/> child (inverse of WithDialog).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                // invertedHr: display 'On' means XML state='False'.
-                ValidValues = ["On", "Off"],
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteract", HrLabel = "With dialog", DisplayInverted = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/DeleteFileStep.cs b/src/SharpFM.Model/Scripting/Steps/DeleteFileStep.cs
index cddf2db..cbe0003 100644
--- a/src/SharpFM.Model/Scripting/Steps/DeleteFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/DeleteFileStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -18,28 +20,22 @@ public sealed class DeleteFileStep : ScriptStep, IStepFactory
 
     public string TargetFile { get; set; }
 
+    private DeleteFileStep() : base(false) { TargetFile = ""; }
+
     public DeleteFileStep(string targetFile = "", bool enabled = true) : base(enabled)
     {
         TargetFile = targetFile;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UniversalPathList", TargetFile));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Delete File [ Target file: {TargetFile} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var path = step.Element("UniversalPathList")?.Value ?? "";
-        return new DeleteFileStep(path, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<DeleteFileStep>(step, Metadata);
 
+    // Hand-written: also accepts a bare unlabeled path token, which the
+    // shape parser would ignore (labeled slots never bind positionally).
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         var tok = hrParams.Length > 0 ? hrParams[0].Trim() : "";
@@ -53,13 +49,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         Name = XmlName, Id = XmlId, Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/delete-file.html",
-        Params =
+        // Canonical unconfigured form is empty: the path text is omitted when blank.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "UniversalPathList", XmlElement = "UniversalPathList",
-                Type = "text", HrLabel = "Target file", Required = true,
-            },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "TargetFile", HrLabel = "Target file", Required = true, Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/DeletePortalRowStep.cs b/src/SharpFM.Model/Scripting/Steps/DeletePortalRowStep.cs
index c778c01..825364f 100644
--- a/src/SharpFM.Model/Scripting/Steps/DeletePortalRowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/DeletePortalRowStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,39 +19,31 @@ public sealed class DeletePortalRowStep : ScriptStep, IStepFactory
     /// <summary>The <c>With dialog</c> flag on the step.</summary>
     public bool WithDialog { get; set; }
 
+    /// <summary>
+    /// XML-facing inverse of <see cref="WithDialog"/>: canonical
+    /// <c>&lt;NoInteract state="…"/&gt;</c> suppresses the dialog, so it is the
+    /// negation of the display-facing flag. The shape binds this so the raw
+    /// state round-trips without re-applying the inversion.
+    /// </summary>
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+
+    private DeletePortalRowStep() : base(false) { }
+
     public DeletePortalRowStep(bool withdialog = false, bool enabled = true)
         : base(enabled)
     {
         WithDialog = withdialog;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract",
-                new XAttribute("state", WithDialog ? "False" : "True")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Delete Portal Row [ With dialog: {(WithDialog ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        return new DeletePortalRowStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<DeletePortalRowStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "With dialog:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        var isOn = token.Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new DeletePortalRowStep(!isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<DeletePortalRowStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -57,18 +51,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "records",
         HelpUrl = "https://help.claris.com/en/pro-help/content/delete-portal-row.html",
-        Params =
+        // Single always-emitted <NoInteract state="..."/> child (inverse of WithDialog).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                // invertedHr: display 'On' means XML state='False'.
-                ValidValues = ["On", "Off"],
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteract", HrLabel = "With dialog", DisplayInverted = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/DeleteRecordRequestStep.cs b/src/SharpFM.Model/Scripting/Steps/DeleteRecordRequestStep.cs
index 42e3fd5..16d2cfc 100644
--- a/src/SharpFM.Model/Scripting/Steps/DeleteRecordRequestStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/DeleteRecordRequestStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,39 +19,31 @@ public sealed class DeleteRecordRequestStep : ScriptStep, IStepFactory
     /// <summary>The <c>With dialog</c> flag on the step.</summary>
     public bool WithDialog { get; set; }
 
+    /// <summary>
+    /// XML-facing inverse of <see cref="WithDialog"/>: canonical
+    /// <c>&lt;NoInteract state="…"/&gt;</c> suppresses the dialog, so it is the
+    /// negation of the display-facing flag. The shape binds this so the raw
+    /// state round-trips without re-applying the inversion.
+    /// </summary>
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+
+    private DeleteRecordRequestStep() : base(false) { }
+
     public DeleteRecordRequestStep(bool withdialog = false, bool enabled = true)
         : base(enabled)
     {
         WithDialog = withdialog;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract",
-                new XAttribute("state", WithDialog ? "False" : "True")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Delete Record/Request [ With dialog: {(WithDialog ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        return new DeleteRecordRequestStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<DeleteRecordRequestStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "With dialog:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        var isOn = token.Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new DeleteRecordRequestStep(!isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<DeleteRecordRequestStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -57,18 +51,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "records",
         HelpUrl = "https://help.claris.com/en/pro-help/content/delete-record-request.html",
-        Params =
+        // Single always-emitted <NoInteract state="..."/> child (inverse of WithDialog).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                // invertedHr: display 'On' means XML state='False'.
-                ValidValues = ["On", "Off"],
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteract", HrLabel = "With dialog", DisplayInverted = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/DialPhoneStep.cs b/src/SharpFM.Model/Scripting/Steps/DialPhoneStep.cs
index c5098a6..a3c84c9 100644
--- a/src/SharpFM.Model/Scripting/Steps/DialPhoneStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/DialPhoneStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -14,7 +16,28 @@ public sealed class DialPhoneStep : ScriptStep, IStepFactory
 
     public bool WithDialog { get; set; }
     public bool UseDialPreferences { get; set; }
-    public Calculation Calculation { get; set; }
+    public Calculation? Calculation { get; set; }
+
+    /// <summary>
+    /// XML-facing inverse of <see cref="WithDialog"/>: canonical
+    /// <c>&lt;NoInteract state="…"/&gt;</c> suppresses the dialog, so it is the
+    /// negation of the display-facing flag. The shape binds this so the raw
+    /// state round-trips without re-applying the inversion.
+    /// </summary>
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+
+    /// <summary>
+    /// XML-facing view of <see cref="UseDialPreferences"/>: the canonical form
+    /// omits <c>&lt;UseDialPreferences&gt;</c> until it is enabled, so this is
+    /// null (omitted by the Optional node) when the flag is off.
+    /// </summary>
+    public string? UseDialPreferencesValue
+    {
+        get => UseDialPreferences ? "True" : null;
+        set => UseDialPreferences = value == "True";
+    }
+
+    private DialPhoneStep() : base(false) { }
 
     public DialPhoneStep(
         bool withDialog = true,
@@ -25,39 +48,28 @@ public DialPhoneStep(
     {
         WithDialog = withDialog;
         UseDialPreferences = useDialPreferences;
-        Calculation = calculation ?? new Calculation("");
+        Calculation = calculation;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("UseDialPreferences", new XAttribute("value", UseDialPreferences ? "True" : "False")),
-            Calculation.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the bare On/Off token maps the wire's "True"/absent
+    // UseDialPreferences value, a translation the display metadata cannot
+    // express without widening the node's wire ValidValues.
     public override string ToDisplayLine() =>
-        "Dial Phone [ " + "With dialog: " + (WithDialog ? "On" : "Off") + " ; " + (UseDialPreferences ? "On" : "Off") + " ; " + Calculation.Text + " ]";
+        "Dial Phone [ " + "With dialog: " + (WithDialog ? "On" : "Off") + " ; " + (UseDialPreferences ? "On" : "Off") + " ; " + (Calculation?.Text ?? "") + " ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog_v = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var useDialPreferences_v = step.Element("UseDialPreferences")?.Attribute("value")?.Value == "True";
-        var calculation_vEl = step.Element("Calculation");
-        var calculation_v = calculation_vEl is not null ? Calculation.FromXml(calculation_vEl) : new Calculation("");
-        return new DialPhoneStep(withDialog_v, useDialPreferences_v, calculation_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<DialPhoneStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         var tokens = hrParams.Select(h => h.Trim()).ToArray();
         bool withDialog_v = true;
         foreach (var tok in tokens) { if (tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(12).Trim(); withDialog_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool useDialPreferences_v = false;
-        Calculation? calculation_v = null;
-        foreach (var tok in tokens) { if (!(tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase))) { calculation_v = new Calculation(tok); break; } }
+        // Display shape is positional after the dialog flag: [ With dialog ; use-dial-prefs On/Off ; phone calc ].
+        bool useDialPreferences_v = tokens.Length >= 2 && tokens[1].Equals("On", StringComparison.OrdinalIgnoreCase);
+        Calculation? calculation_v = tokens.Length >= 3 && tokens[2].Length > 0 ? new Calculation(tokens[2]) : null;
         return new DialPhoneStep(withDialog_v, useDialPreferences_v, calculation_v, enabled);
     }
 
@@ -67,33 +79,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/dial-phone.html",
-        Params =
+        // Canonical 065-DialPhone: only NoInteract (always present, the inverse
+        // of WithDialog). <UseDialPreferences> and the bare <Calculation> are
+        // omitted until configured, so both are Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "UseDialPreferences",
-                XmlElement = "UseDialPreferences",
-                Type = "boolean",
-                XmlAttr = "value",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteract", HrLabel = "With dialog" },
+            new EnumValueChild("UseDialPreferences") { PocoProperty = "UseDialPreferencesValue", Optional = true, DisplayValues = ["On", "Off"] },
+            new BareCalcChild { PocoProperty = "Calculation", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/DuplicateRecordRequestStep.cs b/src/SharpFM.Model/Scripting/Steps/DuplicateRecordRequestStep.cs
index 911bf17..8acf43f 100644
--- a/src/SharpFM.Model/Scripting/Steps/DuplicateRecordRequestStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/DuplicateRecordRequestStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class DuplicateRecordRequestStep : ScriptStep, IStepFactory
     public const int XmlId = 8;
     public const string XmlName = "Duplicate Record/Request";
 
+    private DuplicateRecordRequestStep() : base(false) { }
+
     public DuplicateRecordRequestStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new DuplicateRecordRequestStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<DuplicateRecordRequestStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new DuplicateRecordRequestStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<DuplicateRecordRequestStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/EditUserDictionaryStep.cs b/src/SharpFM.Model/Scripting/Steps/EditUserDictionaryStep.cs
index 32ecf8b..eef74d8 100644
--- a/src/SharpFM.Model/Scripting/Steps/EditUserDictionaryStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/EditUserDictionaryStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class EditUserDictionaryStep : ScriptStep, IStepFactory
     public const int XmlId = 109;
     public const string XmlName = "Edit User Dictionary";
 
+    private EditUserDictionaryStep() : base(false) { }
+
     public EditUserDictionaryStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new EditUserDictionaryStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<EditUserDictionaryStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new EditUserDictionaryStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<EditUserDictionaryStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/EnableAccountStep.cs b/src/SharpFM.Model/Scripting/Steps/EnableAccountStep.cs
index 46a84e9..ddfd983 100644
--- a/src/SharpFM.Model/Scripting/Steps/EnableAccountStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/EnableAccountStep.cs
@@ -1,8 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,8 +11,10 @@ public sealed class EnableAccountStep : ScriptStep, IStepFactory
     public const int XmlId = 137;
     public const string XmlName = "Enable Account";
 
-    public Calculation AccountName { get; set; }
-    public string AccountOperation { get; set; }
+    public Calculation AccountName { get; set; } = new("");
+    public string AccountOperation { get; set; } = "Activate";
+
+    private EnableAccountStep() : base(false) { }
 
     public EnableAccountStep(
         Calculation? accountName = null,
@@ -25,48 +26,15 @@ public EnableAccountStep(
         AccountOperation = accountOperation;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _AccountOperationToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal) {
-        ["Activate"] = "Activate",
-        ["Deactivate"] = "Deactivate",
-    };
-    private static readonly IReadOnlyDictionary<string, string> _AccountOperationFromHr =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {
-        ["Activate"] = "Activate",
-        ["Deactivate"] = "Deactivate",
-    };
-    private static string AccountOperationHr(string x) => _AccountOperationToHr.TryGetValue(x, out var h) ? h : x;
-    private static string AccountOperationXml(string h) => _AccountOperationFromHr.TryGetValue(h, out var x) ? x : h;
-
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("AccountName", AccountName.ToXml("Calculation")),
-            new XElement("AccountOperation", new XAttribute("value", AccountOperation)));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Enable Account [ " + "Account Name: " + AccountName.Text + " ; " + AccountOperationHr(AccountOperation) + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var accountName_vWrapEl = step.Element("AccountName");
-        var accountName_vCalcEl = accountName_vWrapEl?.Element("Calculation");
-        var accountName_v = accountName_vCalcEl is not null ? Calculation.FromXml(accountName_vCalcEl) : new Calculation("");
-        var accountOperation_v = step.Element("AccountOperation")?.Attribute("value")?.Value ?? "Activate";
-        return new EnableAccountStep(accountName_v, accountOperation_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<EnableAccountStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? accountName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Account Name:", StringComparison.OrdinalIgnoreCase)) { accountName_v = new Calculation(tok.Substring(13).Trim()); break; } }
-        string accountOperation_v = "Activate";
-        return new EnableAccountStep(accountName_v, accountOperation_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<EnableAccountStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -74,24 +42,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "accounts",
         HelpUrl = "https://help.claris.com/en/pro-help/content/enable-account.html",
-        Params =
+        // AccountName (omitted when empty, Optional) then the always-present
+        // AccountOperation value flag.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Account Name",
-            },
-            new ParamMetadata
-            {
-                Name = "AccountOperation",
-                XmlElement = "AccountOperation",
-                Type = "enum",
-                XmlAttr = "value",
-                ValidValues = ["Activate", "Deactivate"],
-                DefaultValue = "Activate",
-            },
+            new NamedCalcChild("AccountName") { PocoProperty = "AccountName", HrLabel = "Account Name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new EnumValueChild("AccountOperation") { PocoProperty = "AccountOperation", DefaultValue = "Activate", DisplayValues = ["Activate", "Deactivate"], Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/EnableTouchKeyboardStep.cs b/src/SharpFM.Model/Scripting/Steps/EnableTouchKeyboardStep.cs
index 00f10a5..f5e55d4 100644
--- a/src/SharpFM.Model/Scripting/Steps/EnableTouchKeyboardStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/EnableTouchKeyboardStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,7 +19,9 @@ public sealed class EnableTouchKeyboardStep : ScriptStep, IStepFactory
     public const string XmlName = "Enable Touch Keyboard";
 
     /// <summary>The enum XML value emitted on the <c>&lt;ShowHide&gt;</c> element.</summary>
-    public string ShowHide { get; set; }
+    public string ShowHide { get; set; } = "Show";
+
+    private EnableTouchKeyboardStep() : base(false) { }
 
     public EnableTouchKeyboardStep(string showHide = "Show", bool enabled = true)
         : base(enabled)
@@ -25,51 +29,15 @@ public EnableTouchKeyboardStep(string showHide = "Show", bool enabled = true)
         ShowHide = showHide;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _xmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["On"] = "On",
-        ["Off"] = "Off",
-        ["Toggle"] = "Toggle",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _hrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["On"] = "On",
-        ["Off"] = "Off",
-        ["Toggle"] = "Toggle",
-    };
-
-    private static string ToHr(string xmlValue) =>
-        _xmlToHr.TryGetValue(xmlValue, out var hr) ? hr : xmlValue;
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string FromHr(string hrValue) =>
-        _hrToXml.TryGetValue(hrValue, out var xml) ? xml : hrValue;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ShowHide",
-                new XAttribute("value", ShowHide)));
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<EnableTouchKeyboardStep>(step, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Enable Touch Keyboard [ {ToHr(ShowHide)} ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var value = step.Element("ShowHide")?.Attribute("value")?.Value ?? "Show";
-        return new EnableTouchKeyboardStep(value, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        return new EnableTouchKeyboardStep(FromHr(token), enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<EnableTouchKeyboardStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -77,17 +45,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/enable-touch-keyboard.html",
-        Params =
+        // Single always-emitted <ShowHide value="..."/> enum child.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "ShowHide",
-                XmlElement = "ShowHide",
-                Type = "enum",
-                XmlAttr = "value",
-                DefaultValue = "Show",
-                ValidValues = ["On", "Off", "Toggle"],
-            },
+            new EnumValueChild("ShowHide") { PocoProperty = "ShowHide", DefaultValue = "Show", ValidValues = ["On", "Off", "Toggle"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/EnterBrowseModeStep.cs b/src/SharpFM.Model/Scripting/Steps/EnterBrowseModeStep.cs
index 099940e..664d763 100644
--- a/src/SharpFM.Model/Scripting/Steps/EnterBrowseModeStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/EnterBrowseModeStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,39 +19,23 @@ public sealed class EnterBrowseModeStep : ScriptStep, IStepFactory
     /// <summary>The <c>Pause</c> flag on the step.</summary>
     public bool Pause { get; set; }
 
+    private EnterBrowseModeStep() : base(false) { }
+
     public EnterBrowseModeStep(bool pause = false, bool enabled = true)
         : base(enabled)
     {
         Pause = pause;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Pause",
-                new XAttribute("state", Pause ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Enter Browse Mode [ Pause: {(Pause ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("Pause")?.Attribute("state")?.Value == "True";
-        return new EnterBrowseModeStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<EnterBrowseModeStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "Pause:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        var isOn = token.Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new EnterBrowseModeStep(isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<EnterBrowseModeStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -57,17 +43,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "navigation",
         HelpUrl = "https://help.claris.com/en/pro-help/content/enter-browse-mode.html",
-        Params =
+        // Single always-emitted <Pause state="..."/> child.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Pause",
-                XmlElement = "Pause",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Pause",
-                ValidValues = ["On", "Off"],
-            },
+            new BoolStateChild("Pause") { PocoProperty = "Pause", HrLabel = "Pause" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/EnterFindModeStep.cs b/src/SharpFM.Model/Scripting/Steps/EnterFindModeStep.cs
index 25153af..049b996 100644
--- a/src/SharpFM.Model/Scripting/Steps/EnterFindModeStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/EnterFindModeStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +15,8 @@ public sealed class EnterFindModeStep : ScriptStep, IStepFactory
     public bool RestoreStoredRequests { get; set; }
     public FindRequestList? Query { get; set; }
 
+    private EnterFindModeStep() : base(false) { }
+
     public EnterFindModeStep(
         bool pause = true,
         bool restoreStoredRequests = true,
@@ -25,31 +29,16 @@ public EnterFindModeStep(
         Query = query;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Pause", new XAttribute("state", Pause ? "True" : "False")),
-            new XElement("Restore", new XAttribute("state", RestoreStoredRequests ? "True" : "False")));
-        if (Query is not null) step.Add(Query.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Enter Find Mode [ Pause: {(Pause ? "On" : "Off")} ; Restore: {(RestoreStoredRequests ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var pause = step.Element("Pause")?.Attribute("state")?.Value == "True";
-        var restore = step.Element("Restore")?.Attribute("state")?.Value == "True";
-        var qEl = step.Element("Query");
-        var q = qEl is not null ? FindRequestList.FromXml(qEl) : null;
-        return new EnterFindModeStep(pause, restore, q, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<EnterFindModeStep>(step, Metadata);
 
+    // Hand-written: bare display text defaults Pause/Restore to On (FileMaker's
+    // new-step defaults), which the shape parser's false-initialized POCO
+    // cannot reproduce.
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         bool pause = true, restore = true;
@@ -70,11 +59,16 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "navigation",
         HelpUrl = "https://help.claris.com/en/pro-help/content/enter-find-mode.html",
-        Params =
+        // Pause and Restore always emitted; <Query> only when a stored
+        // request list is present.
+        Shape =
         [
-            new ParamMetadata { Name = "Pause", XmlElement = "Pause", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Query", XmlElement = "Query", Type = "findRequests" },
+            new BoolStateChild("Pause") { PocoProperty = "Pause", HrLabel = "Pause" },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredRequests", HrLabel = "Restore" },
+            new ValueTypeChild("Query") { PocoProperty = "Query", Optional = true, Display = DisplayMode.Hidden },
+            new HrOnly("Pause") { Boolean = true },
+            new HrOnly("Restore") { Boolean = true },
+            new HrOnly("Query"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/EnterPreviewModeStep.cs b/src/SharpFM.Model/Scripting/Steps/EnterPreviewModeStep.cs
index e984f94..91aca9a 100644
--- a/src/SharpFM.Model/Scripting/Steps/EnterPreviewModeStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/EnterPreviewModeStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,39 +19,23 @@ public sealed class EnterPreviewModeStep : ScriptStep, IStepFactory
     /// <summary>The <c>Pause</c> flag on the step.</summary>
     public bool Pause { get; set; }
 
+    private EnterPreviewModeStep() : base(false) { }
+
     public EnterPreviewModeStep(bool pause = false, bool enabled = true)
         : base(enabled)
     {
         Pause = pause;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Pause",
-                new XAttribute("state", Pause ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Enter Preview Mode [ Pause: {(Pause ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("Pause")?.Attribute("state")?.Value == "True";
-        return new EnterPreviewModeStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<EnterPreviewModeStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "Pause:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        var isOn = token.Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new EnterPreviewModeStep(isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<EnterPreviewModeStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -57,17 +43,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "navigation",
         HelpUrl = "https://help.claris.com/en/pro-help/content/enter-preview-mode.html",
-        Params =
+        // Single always-emitted <Pause state="..."/> child.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Pause",
-                XmlElement = "Pause",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Pause",
-                ValidValues = ["On", "Off"],
-            },
+            new BoolStateChild("Pause") { PocoProperty = "Pause", HrLabel = "Pause" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ExecuteFileMakerDataApiStep.cs b/src/SharpFM.Model/Scripting/Steps/ExecuteFileMakerDataApiStep.cs
index 3463a9c..0b14eeb 100644
--- a/src/SharpFM.Model/Scripting/Steps/ExecuteFileMakerDataApiStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ExecuteFileMakerDataApiStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +14,9 @@ public sealed class ExecuteFileMakerDataApiStep : ScriptStep, IStepFactory
 
     public bool Select { get; set; }
     public FieldRef? Target { get; set; }
-    public Calculation Query { get; set; }
+    public Calculation? Query { get; set; }
+
+    private ExecuteFileMakerDataApiStep() : base(false) { }
 
     public ExecuteFileMakerDataApiStep(
         bool select = true,
@@ -23,44 +27,24 @@ public ExecuteFileMakerDataApiStep(
     {
         Select = select;
         Target = target;
-        Query = query ?? new Calculation("");
+        Query = query;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            Query.ToXml("Calculation"));
-        if (Target is not null)
-        {
-            if (Target.IsVariable) step.Add(new XElement("Text"));
-            step.Add(Target.ToXml("Field"));
-        }
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: FileMaker shows Target before the query calculation, the
+    // reverse of the canonical XML order the shape must keep.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>();
         parts.Add($"Select: {(Select ? "On" : "Off")}");
         if (Target is not null) parts.Add($"Target: {Target.ToDisplayString()}");
-        parts.Add(Query.Text);
+        parts.Add(Query?.Text ?? "");
         return $"Execute FileMaker Data API [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var calcEl = step.Element("Calculation");
-        var query = calcEl is not null ? Calculation.FromXml(calcEl) : new Calculation("");
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new ExecuteFileMakerDataApiStep(select, target, query, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ExecuteFileMakerDataApiStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -90,11 +74,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/execute-filemaker-data-api.html",
-        Params =
+        // Canonical: SelectAll, then the optional bare <Calculation> (query) and
+        // field target (variable target gets the bare <Text/> marker).
+        Shape =
         [
-            new ParamMetadata { Name = "SelectAll", XmlElement = "SelectAll", XmlAttr = "state", Type = "boolean", HrLabel = "Select" },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", HrLabel = "Target" },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation", Required = true },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", Display = DisplayMode.Native },
+            new BareCalcChild { PocoProperty = "Query", Optional = true, Display = DisplayMode.Native },
+            new FieldChild("Field") { PocoProperty = "Target", HrLabel = "Target", Optional = true, VariableTextMarker = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ExecuteSqlStep.cs b/src/SharpFM.Model/Scripting/Steps/ExecuteSqlStep.cs
index 49b64f7..482506c 100644
--- a/src/SharpFM.Model/Scripting/Steps/ExecuteSqlStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ExecuteSqlStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +15,18 @@ public sealed class ExecuteSqlStep : ScriptStep, IStepFactory
     public bool WithDialog { get; set; }
     public SqlProfile? Profile { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    /// <summary>
+    /// Display edits are anchor-preserved when an ODBC profile is stored: the
+    /// display line carries only the dialog flag and the SQL text, not the
+    /// profile's connection settings.
+    /// </summary>
+    public override bool IsFullyEditable => Profile is null;
+
+    private ExecuteSqlStep() : base(false) { }
+
     public ExecuteSqlStep(bool withDialog = true, SqlProfile? profile = null, bool enabled = true)
         : base(enabled)
     {
@@ -20,17 +34,10 @@ public ExecuteSqlStep(bool withDialog = true, SqlProfile? profile = null, bool e
         Profile = profile;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")));
-        if (Profile is not null) step.Add(Profile.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the SQL Text / Calculated SQL Text token comes from the
+    // hidden Profile value type, which the shape-driven renderer cannot surface.
     public override string ToDisplayLine()
     {
         var dialog = $"With dialog: {(WithDialog ? "On" : "Off")}";
@@ -40,14 +47,8 @@ public override string ToDisplayLine()
         return $"Execute SQL [ {dialog} ; SQL Text: {Profile.Query ?? ""} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var profileEl = step.Element("Profile");
-        var profile = profileEl is not null ? SqlProfile.FromXml(profileEl) : null;
-        return new ExecuteSqlStep(withDialog, profile, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ExecuteSqlStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -56,6 +57,7 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         bool withDialog = true;
         string sql = "";
         bool isCalc = false;
+        bool sawSql = false;
         foreach (var tok in hrParams)
         {
             var t = tok.Trim();
@@ -65,15 +67,21 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
             {
                 sql = t.Substring(20).Trim();
                 isCalc = true;
+                sawSql = true;
             }
             else if (t.StartsWith("SQL Text:", StringComparison.OrdinalIgnoreCase))
+            {
                 sql = t.Substring(9).Trim();
+                sawSql = true;
+            }
         }
-        var profile = new SqlProfile(
-            isCalc ? "Calculation" : "Query",
-            "0", "", "", "", "\t", "-1", "0", "ODBC",
-            isCalc ? null : sql,
-            isCalc ? new Calculation(sql) : null);
+        var profile = sawSql
+            ? new SqlProfile(
+                isCalc ? "Calculation" : "Query",
+                "0", "", "", "", "\t", "-1", "0", "ODBC",
+                isCalc ? null : sql,
+                isCalc ? new Calculation(sql) : null)
+            : null;
         return new ExecuteSqlStep(withDialog, profile, enabled);
     }
 
@@ -83,10 +91,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/execute-sql.html",
-        Params =
+        // Canonical: NoInteract (inverts WithDialog), then the optional ODBC
+        // Profile which owns its own attribute/child shape.
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog", ValidValues = ["On", "Off"] },
-            new ParamMetadata { Name = "Profile", XmlElement = "Profile", Type = "complex" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", Display = DisplayMode.Augmented, DisplayInverted = true },
+            new ValueTypeChild("Profile") { PocoProperty = "Profile", Optional = true, Display = DisplayMode.Hidden },
+            new HrOnly("Profile"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ExitApplicationStep.cs b/src/SharpFM.Model/Scripting/Steps/ExitApplicationStep.cs
index e5a23ab..57ecd64 100644
--- a/src/SharpFM.Model/Scripting/Steps/ExitApplicationStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ExitApplicationStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class ExitApplicationStep : ScriptStep, IStepFactory
     public const int XmlId = 44;
     public const string XmlName = "Exit Application";
 
+    private ExitApplicationStep() : base(false) { }
+
     public ExitApplicationStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ExitApplicationStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ExitApplicationStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new ExitApplicationStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ExitApplicationStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/ExitScriptStep.cs b/src/SharpFM.Model/Scripting/Steps/ExitScriptStep.cs
index 6907339..22d00fe 100644
--- a/src/SharpFM.Model/Scripting/Steps/ExitScriptStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ExitScriptStep.cs
@@ -1,8 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +11,9 @@ public sealed class ExitScriptStep : ScriptStep, IStepFactory
     public const int XmlId = 103;
     public const string XmlName = "Exit Script";
 
-    public Calculation Calculation { get; set; }
+    public Calculation Calculation { get; set; } = new("");
+
+    private ExitScriptStep() : base(false) { }
 
     public ExitScriptStep(
         Calculation? calculation = null,
@@ -22,31 +23,15 @@ public ExitScriptStep(
         Calculation = calculation ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            Calculation.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Exit Script [ " + Calculation.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var calculation_vEl = step.Element("Calculation");
-        var calculation_v = calculation_vEl is not null ? Calculation.FromXml(calculation_vEl) : new Calculation("");
-        return new ExitScriptStep(calculation_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ExitScriptStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? calculation_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation_v = new Calculation(tok); break; } }
-        return new ExitScriptStep(calculation_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ExitScriptStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -54,14 +39,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/exit-script.html",
-        Params =
+        // The bare return Calculation is omitted by the unconfigured form (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-            },
+            new BareCalcChild { PocoProperty = "Calculation", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ExportFieldContentsStep.cs b/src/SharpFM.Model/Scripting/Steps/ExportFieldContentsStep.cs
index 3e72112..33dd1b2 100644
--- a/src/SharpFM.Model/Scripting/Steps/ExportFieldContentsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ExportFieldContentsStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -16,6 +18,8 @@ public sealed class ExportFieldContentsStep : ScriptStep, IStepFactory
     public bool CreateEmail { get; set; }
     public bool CreateDirectories { get; set; }
 
+    private ExportFieldContentsStep() : base(false) { }
+
     public ExportFieldContentsStep(
         FieldRef? field = null,
         string path = "",
@@ -32,20 +36,11 @@ public ExportFieldContentsStep(
         CreateDirectories = createDirectories;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("CreateDirectories", new XAttribute("state", CreateDirectories ? "True" : "False")),
-            new XElement("AutoOpen", new XAttribute("state", AutoOpen ? "True" : "False")),
-            new XElement("CreateEmail", new XAttribute("state", CreateEmail ? "True" : "False")),
-            new XElement("UniversalPathList", Path));
-        if (Field is not null) step.Add(Field.ToXml("Field"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: Field renders before Path (reverse of canonical XML order)
+    // and AutoOpen/CreateEmail are conditional bare tokens a BoolStateChild
+    // cannot produce.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>();
@@ -57,17 +52,8 @@ public override string ToDisplayLine()
         return $"Export Field Contents [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var createDirs = step.Element("CreateDirectories")?.Attribute("state")?.Value == "True";
-        var autoOpen = step.Element("AutoOpen")?.Attribute("state")?.Value == "True";
-        var createEmail = step.Element("CreateEmail")?.Attribute("state")?.Value == "True";
-        var path = step.Element("UniversalPathList")?.Value ?? "";
-        var fieldEl = step.Element("Field");
-        var field = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new ExportFieldContentsStep(field, path, autoOpen, createEmail, createDirs, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ExportFieldContentsStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -102,13 +88,15 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/export-field-contents.html",
-        Params =
+        // Canonical order: CreateDirectories, AutoOpen, CreateEmail, then the
+        // path list and Field which the unconfigured form omits (Optional).
+        Shape =
         [
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field" },
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text" },
-            new ParamMetadata { Name = "AutoOpen", XmlElement = "AutoOpen", XmlAttr = "state", Type = "boolean", HrLabel = "Automatically open" },
-            new ParamMetadata { Name = "CreateEmail", XmlElement = "CreateEmail", XmlAttr = "state", Type = "boolean", HrLabel = "Create email" },
-            new ParamMetadata { Name = "CreateDirectories", XmlElement = "CreateDirectories", XmlAttr = "state", Type = "boolean", HrLabel = "Create folders", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new BoolStateChild("CreateDirectories") { PocoProperty = "CreateDirectories", HrLabel = "Create folders", Display = DisplayMode.Augmented },
+            new BoolStateChild("AutoOpen") { PocoProperty = "AutoOpen", HrLabel = "Automatically open", Display = DisplayMode.Augmented },
+            new BoolStateChild("CreateEmail") { PocoProperty = "CreateEmail", HrLabel = "Create email", Display = DisplayMode.Augmented },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Optional = true, Display = DisplayMode.Native },
+            new FieldChild("Field") { PocoProperty = "Field", Optional = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ExportRecordsStep.cs b/src/SharpFM.Model/Scripting/Steps/ExportRecordsStep.cs
index f37d03b..5822c35 100644
--- a/src/SharpFM.Model/Scripting/Steps/ExportRecordsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ExportRecordsStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -28,6 +30,70 @@ public sealed class ExportRecordsStep : ScriptStep, IStepFactory
     public IReadOnlyList<ExportEntry> ExportEntries { get; set; }
     public IReadOnlyList<SummaryFieldEntry> SummaryFields { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    /// <summary>
+    /// Display edits are anchor-preserved once the export is configured: the
+    /// display line carries only the dialog flag and output path, so any
+    /// non-canonical-default flag, a stored format profile, export options or
+    /// field list seals the step.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        CreateDirectories && !RestoreStoredOrder && !AutoOpen && !CreateEmail
+        && Profile is null && ExportOptions is null
+        && ExportEntries.Count == 0 && SummaryFields.Count == 0;
+
+    /// <summary>
+    /// Shape-facing view of the complex children no primitive models. The
+    /// getter emits only <c>&lt;Profile&gt;</c> (this passthrough slot sits
+    /// before <c>&lt;UniversalPathList&gt;</c>); the setter receives every
+    /// unmodeled child — the parser populates only the first passthrough slot —
+    /// and demultiplexes Profile, ExportOptions, ExportEntries and
+    /// SummaryFields. <see cref="TrailingWire"/> re-emits the latter three
+    /// after the path.
+    /// </summary>
+    public List<XElement> ProfileWire
+    {
+        get => Profile is null ? [] : [AttrElement("Profile", Profile)];
+        set
+        {
+            static Dictionary<string, string>? AttrsOf(XElement? el) =>
+                el?.Attributes().ToDictionary(a => a.Name.LocalName, a => a.Value);
+            Profile = AttrsOf(value.FirstOrDefault(e => e.Name.LocalName == "Profile"));
+            ExportOptions = AttrsOf(value.FirstOrDefault(e => e.Name.LocalName == "ExportOptions"));
+            ExportEntries = value.FirstOrDefault(e => e.Name.LocalName == "ExportEntries")
+                ?.Elements("ExportEntry").Select(ExportEntry.FromXml).ToList() ?? new List<ExportEntry>();
+            SummaryFields = value.FirstOrDefault(e => e.Name.LocalName == "SummaryFields")
+                ?.Elements("Field").Select(SummaryFieldEntry.FromXml).ToList() ?? new List<SummaryFieldEntry>();
+        }
+    }
+
+    /// <summary>Emit-only wire view of the post-path complex children. Get-only, so the shape parser skips it.</summary>
+    public List<XElement> TrailingWire
+    {
+        get
+        {
+            var list = new List<XElement>();
+            if (ExportOptions is not null) list.Add(AttrElement("ExportOptions", ExportOptions));
+            if (ExportEntries.Count > 0) list.Add(new XElement("ExportEntries", ExportEntries.Select(e => e.ToXml())));
+            if (SummaryFields.Count > 0) list.Add(new XElement("SummaryFields", SummaryFields.Select(s => s.ToXml())));
+            return list;
+        }
+    }
+
+    private static XElement AttrElement(string name, IReadOnlyDictionary<string, string> attrs)
+    {
+        var el = new XElement(name);
+        foreach (var kv in attrs) el.Add(new XAttribute(kv.Key, kv.Value));
+        return el;
+    }
+
+    // Display-parse defaults: a bare display line means the canonical
+    // unconfigured form (Restore/AutoOpen/CreateEmail all False). XML parse
+    // always overwrites these, so this is display-only.
+    private ExportRecordsStep() : this(enabled: true) { RestoreStoredOrder = false; AutoOpen = false; CreateEmail = false; }
+
     public ExportRecordsStep(
         bool withDialog = false, bool createDirectories = true, bool restoreStoredOrder = true,
         bool autoOpen = true, bool createEmail = true,
@@ -51,70 +117,15 @@ public ExportRecordsStep(
         SummaryFields = summaryFields ?? new List<SummaryFieldEntry>();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("CreateDirectories", new XAttribute("state", CreateDirectories ? "True" : "False")),
-            new XElement("Restore", new XAttribute("state", RestoreStoredOrder ? "True" : "False")),
-            new XElement("AutoOpen", new XAttribute("state", AutoOpen ? "True" : "False")),
-            new XElement("CreateEmail", new XAttribute("state", CreateEmail ? "True" : "False")));
-        if (Profile is not null)
-        {
-            var prof = new XElement("Profile");
-            foreach (var kv in Profile) prof.Add(new XAttribute(kv.Key, kv.Value));
-            step.Add(prof);
-        }
-        step.Add(new XElement("UniversalPathList", Path));
-        if (ExportOptions is not null)
-        {
-            var opts = new XElement("ExportOptions");
-            foreach (var kv in ExportOptions) opts.Add(new XAttribute(kv.Key, kv.Value));
-            step.Add(opts);
-        }
-        if (ExportEntries.Count > 0)
-        {
-            var entries = new XElement("ExportEntries");
-            foreach (var e in ExportEntries) entries.Add(e.ToXml());
-            step.Add(entries);
-        }
-        if (SummaryFields.Count > 0)
-        {
-            var summaries = new XElement("SummaryFields");
-            foreach (var s in SummaryFields) summaries.Add(s.ToXml());
-            step.Add(summaries);
-        }
-        return step;
-    }
-
-    public override string ToDisplayLine() =>
-        $"Export Records [ With dialog: {(WithDialog ? "On" : "Off")} ; {Path} ]";
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        static Dictionary<string, string>? AttrsOf(XElement? el) =>
-            el is null ? null : el.Attributes().ToDictionary(a => a.Name.LocalName, a => a.Value);
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-        return new ExportRecordsStep(
-            step.Element("NoInteract")?.Attribute("state")?.Value != "True",
-            step.Element("CreateDirectories")?.Attribute("state")?.Value == "True",
-            step.Element("Restore")?.Attribute("state")?.Value == "True",
-            step.Element("AutoOpen")?.Attribute("state")?.Value == "True",
-            step.Element("CreateEmail")?.Attribute("state")?.Value == "True",
-            AttrsOf(step.Element("Profile")),
-            step.Element("UniversalPathList")?.Value ?? "",
-            AttrsOf(step.Element("ExportOptions")),
-            step.Element("ExportEntries")?.Elements("ExportEntry").Select(ExportEntry.FromXml).ToList(),
-            step.Element("SummaryFields")?.Elements("Field").Select(SummaryFieldEntry.FromXml).ToList(),
-            enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ExportRecordsStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new ExportRecordsStep(enabled: enabled);
+        StepDisplayParser.Parse<ExportRecordsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -122,18 +133,22 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
         Id = XmlId,
         Category = "records",
         HelpUrl = "https://help.claris.com/en/pro-help/content/export-records.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "CreateDirectories", XmlElement = "CreateDirectories", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "AutoOpen", XmlElement = "AutoOpen", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "CreateEmail", XmlElement = "CreateEmail", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Profile", XmlElement = "Profile", Type = "complex" },
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text" },
-            new ParamMetadata { Name = "ExportOptions", XmlElement = "ExportOptions", Type = "complex" },
-            new ParamMetadata { Name = "ExportEntries", XmlElement = "ExportEntries", Type = "complex" },
-            new ParamMetadata { Name = "SummaryFields", XmlElement = "SummaryFields", Type = "complex" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", DisplayInverted = true },
+            new BoolStateChild("CreateDirectories") { Display = DisplayMode.Hidden },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredOrder", Display = DisplayMode.Hidden },
+            new BoolStateChild("AutoOpen") { Display = DisplayMode.Hidden },
+            new BoolStateChild("CreateEmail") { Display = DisplayMode.Hidden },
+            // <Profile> precedes the path; the parse side of this slot also
+            // absorbs the trailing complex children (see ProfileWire).
+            new Passthrough { PocoProperty = "ProfileWire" },
+            new HrOnly("Profile"),
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Optional = true, DisplayEmptyAs = "" },
+            new Passthrough { PocoProperty = "TrailingWire" },
+            new HrOnly("ExportOptions"),
+            new HrOnly("ExportEntries"),
+            new HrOnly("SummaryFields"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ExtendFoundSetStep.cs b/src/SharpFM.Model/Scripting/Steps/ExtendFoundSetStep.cs
index 615c339..349fd1c 100644
--- a/src/SharpFM.Model/Scripting/Steps/ExtendFoundSetStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ExtendFoundSetStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,6 +14,8 @@ public sealed class ExtendFoundSetStep : ScriptStep, IStepFactory
     public bool RestoreStoredRequests { get; set; }
     public FindRequestList? Query { get; set; }
 
+    private ExtendFoundSetStep() : base(false) { RestoreStoredRequests = true; }
+
     public ExtendFoundSetStep(bool restoreStoredRequests = true, FindRequestList? query = null, bool enabled = true)
         : base(enabled)
     {
@@ -19,40 +23,15 @@ public ExtendFoundSetStep(bool restoreStoredRequests = true, FindRequestList? qu
         Query = query;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Restore", new XAttribute("state", RestoreStoredRequests ? "True" : "False")));
-        if (Query is not null) step.Add(Query.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Extend Found Set [ Restore: {(RestoreStoredRequests ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var restore = step.Element("Restore")?.Attribute("state")?.Value == "True";
-        var qEl = step.Element("Query");
-        var q = qEl is not null ? FindRequestList.FromXml(qEl) : null;
-        return new ExtendFoundSetStep(restore, q, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ExtendFoundSetStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        bool restore = true;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("Restore:", System.StringComparison.OrdinalIgnoreCase))
-                restore = t.Substring(8).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
-        }
-        return new ExtendFoundSetStep(restore, null, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ExtendFoundSetStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,10 +39,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "found sets",
         HelpUrl = "https://help.claris.com/en/pro-help/content/extend-found-set.html",
-        Params =
+        // Restore is always emitted; Query only when stored requests exist.
+        Shape =
         [
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Query", XmlElement = "Query", Type = "findRequests" },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredRequests", HrLabel = "Restore" },
+            new ValueTypeChild("Query") { PocoProperty = "Query", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/FindMatchingRecordsStep.cs b/src/SharpFM.Model/Scripting/Steps/FindMatchingRecordsStep.cs
index f7d202a..5e2ee9e 100644
--- a/src/SharpFM.Model/Scripting/Steps/FindMatchingRecordsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/FindMatchingRecordsStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -9,9 +11,11 @@ public sealed class FindMatchingRecordsStep : ScriptStep, IStepFactory
     public const int XmlId = 155;
     public const string XmlName = "Find Matching Records";
 
-    public string Mode { get; set; }
+    public string Mode { get; set; } = "FindMatchingReplace";
     public FieldRef? Field { get; set; }
 
+    private FindMatchingRecordsStep() : base(false) { }
+
     public FindMatchingRecordsStep(string mode = "FindMatchingReplace", FieldRef? field = null, bool enabled = true)
         : base(enabled)
     {
@@ -19,66 +23,15 @@ public FindMatchingRecordsStep(string mode = "FindMatchingReplace", FieldRef? fi
         Field = field;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("FindMatchingRecordsByField", new XAttribute("value", Mode)));
-        if (Field is not null) step.Add(Field.ToXml("Field"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine()
-    {
-        var mode = Mode switch
-        {
-            "FindMatchingReplace" or "Replace" => "Replace",
-            "FindMatchingConstrain" or "Constrain" => "Constrain",
-            "FindMatchingExtend" or "Extend" => "Extend",
-            _ => Mode,
-        };
-        return Field is null
-            ? $"Find Matching Records [ {mode} ]"
-            : $"Find Matching Records [ {mode} ; {Field.ToDisplayString()} ]";
-    }
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var mode = step.Element("FindMatchingRecordsByField")?.Attribute("value")?.Value ?? "FindMatchingReplace";
-        var fieldEl = step.Element("Field");
-        var field = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new FindMatchingRecordsStep(mode, field, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<FindMatchingRecordsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        string mode = "FindMatchingReplace";
-        FieldRef? field = null;
-        bool modeSeen = false;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (!modeSeen)
-            {
-                mode = t switch
-                {
-                    "Replace" => "FindMatchingReplace",
-                    "Constrain" => "FindMatchingConstrain",
-                    "Extend" => "FindMatchingExtend",
-                    _ => t,
-                };
-                modeSeen = true;
-            }
-            else if (!string.IsNullOrWhiteSpace(t))
-            {
-                field = FieldRef.FromDisplayToken(t);
-            }
-        }
-        return new FindMatchingRecordsStep(mode, field, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<FindMatchingRecordsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -86,18 +39,18 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "found sets",
         HelpUrl = "https://help.claris.com/en/pro-help/content/find-matching-records.html",
-        Params =
+        // Canonical: the always-present mode enum, then the optional target Field.
+        Shape =
         [
-            new ParamMetadata
+            new EnumValueChild("FindMatchingRecordsByField")
             {
-                Name = "FindMatchingRecordsByField",
-                XmlElement = "FindMatchingRecordsByField",
-                XmlAttr = "value",
-                Type = "enum",
-                ValidValues = ["Replace", "Constrain", "Extend"],
+                PocoProperty = "Mode",
                 DefaultValue = "FindMatchingReplace",
+                ValidValues = ["FindMatchingReplace", "FindMatchingConstrain", "FindMatchingExtend"],
+                DisplayValues = ["Replace", "Constrain", "Extend"],
+                Display = DisplayMode.Native,
             },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field" },
+            new FieldChild("Field") { PocoProperty = "Field", Optional = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/FineTuneModelStep.cs b/src/SharpFM.Model/Scripting/Steps/FineTuneModelStep.cs
index d189b08..a0356a6 100644
--- a/src/SharpFM.Model/Scripting/Steps/FineTuneModelStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/FineTuneModelStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,35 +13,42 @@ public sealed class FineTuneModelStep : ScriptStep, IStepFactory
 
     public StepChildBag Children { get; set; }
 
+    private FineTuneModelStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public FineTuneModelStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new FineTuneModelStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<FineTuneModelStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new FineTuneModelStep(enabled: enabled);
+        StepDisplayParser.Parse<FineTuneModelStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/FlushCacheToDiskStep.cs b/src/SharpFM.Model/Scripting/Steps/FlushCacheToDiskStep.cs
index 5287198..fe37d0c 100644
--- a/src/SharpFM.Model/Scripting/Steps/FlushCacheToDiskStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/FlushCacheToDiskStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class FlushCacheToDiskStep : ScriptStep, IStepFactory
     public const int XmlId = 102;
     public const string XmlName = "Flush Cache to Disk";
 
+    private FlushCacheToDiskStep() : base(false) { }
+
     public FlushCacheToDiskStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new FlushCacheToDiskStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<FlushCacheToDiskStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new FlushCacheToDiskStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<FlushCacheToDiskStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/FreezeWindowStep.cs b/src/SharpFM.Model/Scripting/Steps/FreezeWindowStep.cs
index 3d339ad..3373f63 100644
--- a/src/SharpFM.Model/Scripting/Steps/FreezeWindowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/FreezeWindowStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class FreezeWindowStep : ScriptStep, IStepFactory
     public const int XmlId = 79;
     public const string XmlName = "Freeze Window";
 
+    private FreezeWindowStep() : base(false) { }
+
     public FreezeWindowStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new FreezeWindowStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<FreezeWindowStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new FreezeWindowStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<FreezeWindowStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/GenerateResponseFromModelStep.cs b/src/SharpFM.Model/Scripting/Steps/GenerateResponseFromModelStep.cs
index 4b0c89b..bc12c34 100644
--- a/src/SharpFM.Model/Scripting/Steps/GenerateResponseFromModelStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GenerateResponseFromModelStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,35 +13,42 @@ public sealed class GenerateResponseFromModelStep : ScriptStep, IStepFactory
 
     public StepChildBag Children { get; set; }
 
+    private GenerateResponseFromModelStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public GenerateResponseFromModelStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new GenerateResponseFromModelStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<GenerateResponseFromModelStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new GenerateResponseFromModelStep(enabled: enabled);
+        StepDisplayParser.Parse<GenerateResponseFromModelStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/GetDataFilePositionStep.cs b/src/SharpFM.Model/Scripting/Steps/GetDataFilePositionStep.cs
index eb41418..699cc6c 100644
--- a/src/SharpFM.Model/Scripting/Steps/GetDataFilePositionStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GetDataFilePositionStep.cs
@@ -1,6 +1,7 @@
-using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -10,60 +11,27 @@ public sealed class GetDataFilePositionStep : ScriptStep, IStepFactory
     public const int XmlId = 194;
     public const string XmlName = "Get Data File Position";
 
-    public Calculation FileId { get; set; }
+    public Calculation? FileId { get; set; }
     public FieldRef? Target { get; set; }
 
+    private GetDataFilePositionStep() : base(false) { }
+
     public GetDataFilePositionStep(Calculation? fileId = null, FieldRef? target = null, bool enabled = true)
         : base(enabled)
     {
-        FileId = fileId ?? new Calculation("");
+        FileId = fileId;
         Target = target;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            FileId.ToXml("Calculation"));
-        if (Target is not null) step.Add(Target.ToXml("Field"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        Target is null
-            ? $"Get Data File Position [ File ID: {FileId.Text} ]"
-            : $"Get Data File Position [ File ID: {FileId.Text} ; Target: {Target.ToDisplayString()} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var calcEl = step.Element("Calculation");
-        var fileId = calcEl is not null ? Calculation.FromXml(calcEl) : new Calculation("");
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new GetDataFilePositionStep(fileId, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<GetDataFilePositionStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        Calculation fileId = new("");
-        FieldRef? target = null;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("File ID:", StringComparison.OrdinalIgnoreCase))
-            {
-                fileId = new Calculation(t.Substring(8).Trim());
-            }
-            else if (t.StartsWith("Target:", StringComparison.OrdinalIgnoreCase))
-            {
-                target = FieldRef.FromDisplayToken(t.Substring(7).Trim());
-            }
-        }
-        return new GetDataFilePositionStep(fileId, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<GetDataFilePositionStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -71,10 +39,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/get-data-file-position.html",
-        Params =
+        // Canonical unconfigured form is empty: the bare File ID calc and target are omitted when absent.
+        Shape =
         [
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation", HrLabel = "File ID", Required = true },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", HrLabel = "Target" },
+            new BareCalcChild { PocoProperty = "FileId", HrLabel = "File ID", Required = true, Optional = true, DisplayEmptyAs = "" },
+            new FieldChild() { PocoProperty = "Target", HrLabel = "Target", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/GetFileExistsStep.cs b/src/SharpFM.Model/Scripting/Steps/GetFileExistsStep.cs
index 243ff78..715857b 100644
--- a/src/SharpFM.Model/Scripting/Steps/GetFileExistsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GetFileExistsStep.cs
@@ -1,6 +1,7 @@
-using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +14,8 @@ public sealed class GetFileExistsStep : ScriptStep, IStepFactory
     public string Path { get; set; }
     public FieldRef? Target { get; set; }
 
+    private GetFileExistsStep() : base(false) { Path = ""; }
+
     public GetFileExistsStep(string path = "", FieldRef? target = null, bool enabled = true)
         : base(enabled)
     {
@@ -20,51 +23,15 @@ public GetFileExistsStep(string path = "", FieldRef? target = null, bool enabled
         Target = target;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UniversalPathList", Path));
-        if (Target is not null) step.Add(Target.ToXml("Field"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        Target is null
-            ? $"Get File Exists [ {Path} ]"
-            : $"Get File Exists [ {Path} ; Target: {Target.ToDisplayString()} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var path = step.Element("UniversalPathList")?.Value ?? "";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new GetFileExistsStep(path, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<GetFileExistsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        string path = "";
-        FieldRef? target = null;
-        bool pathSeen = false;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("Target:", StringComparison.OrdinalIgnoreCase))
-            {
-                target = FieldRef.FromDisplayToken(t.Substring(7).Trim());
-            }
-            else if (!pathSeen && !string.IsNullOrWhiteSpace(t))
-            {
-                path = t;
-                pathSeen = true;
-            }
-        }
-        return new GetFileExistsStep(path, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<GetFileExistsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -72,10 +39,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/get-file-exists.html",
-        Params =
+        // Canonical unconfigured form is empty: path and target are omitted when absent.
+        Shape =
         [
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text", Required = true },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", HrLabel = "Target" },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Required = true, Optional = true, DisplayEmptyAs = "" },
+            new FieldChild() { PocoProperty = "Target", HrLabel = "Target", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/GetFileSizeStep.cs b/src/SharpFM.Model/Scripting/Steps/GetFileSizeStep.cs
index efb282e..cdb8dd8 100644
--- a/src/SharpFM.Model/Scripting/Steps/GetFileSizeStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GetFileSizeStep.cs
@@ -1,6 +1,7 @@
-using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +14,8 @@ public sealed class GetFileSizeStep : ScriptStep, IStepFactory
     public string Path { get; set; }
     public FieldRef? Target { get; set; }
 
+    private GetFileSizeStep() : base(false) { Path = ""; }
+
     public GetFileSizeStep(string path = "", FieldRef? target = null, bool enabled = true)
         : base(enabled)
     {
@@ -20,51 +23,15 @@ public GetFileSizeStep(string path = "", FieldRef? target = null, bool enabled =
         Target = target;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UniversalPathList", Path));
-        if (Target is not null) step.Add(Target.ToXml("Field"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        Target is null
-            ? $"Get File Size [ {Path} ]"
-            : $"Get File Size [ {Path} ; Target: {Target.ToDisplayString()} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var path = step.Element("UniversalPathList")?.Value ?? "";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new GetFileSizeStep(path, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<GetFileSizeStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        string path = "";
-        FieldRef? target = null;
-        bool pathSeen = false;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("Target:", StringComparison.OrdinalIgnoreCase))
-            {
-                target = FieldRef.FromDisplayToken(t.Substring(7).Trim());
-            }
-            else if (!pathSeen && !string.IsNullOrWhiteSpace(t))
-            {
-                path = t;
-                pathSeen = true;
-            }
-        }
-        return new GetFileSizeStep(path, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<GetFileSizeStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -72,10 +39,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/get-file-size.html",
-        Params =
+        // Canonical unconfigured form is empty: path and target are omitted when absent.
+        Shape =
         [
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text", Required = true },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", HrLabel = "Target" },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Required = true, Optional = true, DisplayEmptyAs = "" },
+            new FieldChild() { PocoProperty = "Target", HrLabel = "Target", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/GetFolderPathStep.cs b/src/SharpFM.Model/Scripting/Steps/GetFolderPathStep.cs
index 8d0d3f5..5b54417 100644
--- a/src/SharpFM.Model/Scripting/Steps/GetFolderPathStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GetFolderPathStep.cs
@@ -1,8 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -14,9 +13,11 @@ public sealed class GetFolderPathStep : ScriptStep, IStepFactory
 
     public bool AllowFolderCreation { get; set; }
     public string Name { get; set; }
-    public Calculation Calculation { get; set; }
-    public Calculation Calculation2 { get; set; }
-    public Calculation Calculation3 { get; set; }
+    public Calculation? Calculation { get; set; }
+    public Calculation? Calculation2 { get; set; }
+    public Calculation? Calculation3 { get; set; }
+
+    private GetFolderPathStep() : base(false) { Name = ""; AllowFolderCreation = true; }
 
     public GetFolderPathStep(
         bool allowFolderCreation = true,
@@ -29,56 +30,20 @@ public GetFolderPathStep(
     {
         AllowFolderCreation = allowFolderCreation;
         Name = name;
-        Calculation = calculation ?? new Calculation("");
-        Calculation2 = calculation2 ?? new Calculation("");
-        Calculation3 = calculation3 ?? new Calculation("");
+        Calculation = calculation;
+        Calculation2 = calculation2;
+        Calculation3 = calculation3;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("AllowFolderCreation", new XAttribute("state", AllowFolderCreation ? "True" : "False")),
-            new XElement("Name", Name),
-            new XElement("DialogTitle", Calculation.ToXml("Calculation")),
-            new XElement("DefaultLocation", Calculation2.ToXml("Calculation")),
-            new XElement("Repetition", Calculation3.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Get Folder Path [ " + "Allow Folder Creation: " + (AllowFolderCreation ? "On" : "Off") + " ; " + Name + " ; " + Calculation.Text + " ; " + Calculation2.Text + " ; " + Calculation3.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var allowFolderCreation_v = step.Element("AllowFolderCreation")?.Attribute("state")?.Value == "True";
-        var name_v = step.Element("Name")?.Value ?? "";
-        var calculation_vWrapEl = step.Element("DialogTitle");
-        var calculation_vCalcEl = calculation_vWrapEl?.Element("Calculation");
-        var calculation_v = calculation_vCalcEl is not null ? Calculation.FromXml(calculation_vCalcEl) : new Calculation("");
-        var calculation2_vWrapEl = step.Element("DefaultLocation");
-        var calculation2_vCalcEl = calculation2_vWrapEl?.Element("Calculation");
-        var calculation2_v = calculation2_vCalcEl is not null ? Calculation.FromXml(calculation2_vCalcEl) : new Calculation("");
-        var calculation3_vWrapEl = step.Element("Repetition");
-        var calculation3_vCalcEl = calculation3_vWrapEl?.Element("Calculation");
-        var calculation3_v = calculation3_vCalcEl is not null ? Calculation.FromXml(calculation3_vCalcEl) : new Calculation("");
-        return new GetFolderPathStep(allowFolderCreation_v, name_v, calculation_v, calculation2_v, calculation3_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<GetFolderPathStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool allowFolderCreation_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Allow Folder Creation:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(22).Trim(); allowFolderCreation_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        string name_v = "";
-        Calculation? calculation_v = null;
-        foreach (var tok in tokens) { if (!(tok.StartsWith("Allow Folder Creation:", StringComparison.OrdinalIgnoreCase))) { calculation_v = new Calculation(tok); break; } }
-        Calculation? calculation2_v = null;
-        foreach (var tok in tokens) { if (!(tok.StartsWith("Allow Folder Creation:", StringComparison.OrdinalIgnoreCase))) { calculation2_v = new Calculation(tok); break; } }
-        Calculation? calculation3_v = null;
-        foreach (var tok in tokens) { if (!(tok.StartsWith("Allow Folder Creation:", StringComparison.OrdinalIgnoreCase))) { calculation3_v = new Calculation(tok); break; } }
-        return new GetFolderPathStep(allowFolderCreation_v, name_v, calculation_v, calculation2_v, calculation3_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<GetFolderPathStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -86,42 +51,15 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/get-directory.html",
-        Params =
+        // Canonical form carries only AllowFolderCreation; name and the three
+        // calc options (DialogTitle, DefaultLocation, Repetition) are omitted when blank.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "AllowFolderCreation",
-                XmlElement = "AllowFolderCreation",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Allow Folder Creation",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Name",
-                XmlElement = "Name",
-                Type = "text",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
+            new BoolStateChild("AllowFolderCreation") { PocoProperty = "AllowFolderCreation", HrLabel = "Allow Folder Creation" },
+            new NamedTextChild("Name") { PocoProperty = "Name", Optional = true, DisplayEmptyAs = "" },
+            new NamedCalcChild("DialogTitle") { PocoProperty = "Calculation", Optional = true, DisplayEmptyAs = "" },
+            new NamedCalcChild("DefaultLocation") { PocoProperty = "Calculation2", Optional = true, DisplayEmptyAs = "" },
+            new NamedCalcChild("Repetition") { PocoProperty = "Calculation3", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/GoToFieldStep.cs b/src/SharpFM.Model/Scripting/Steps/GoToFieldStep.cs
index 75b22f7..679a9e8 100644
--- a/src/SharpFM.Model/Scripting/Steps/GoToFieldStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GoToFieldStep.cs
@@ -1,7 +1,7 @@
-using System;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +12,9 @@ public sealed class GoToFieldStep : ScriptStep, IStepFactory
     public const string XmlName = "Go to Field";
 
     public bool SelectPerform { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private GoToFieldStep() : base(false) { SelectPerform = true; }
 
     public GoToFieldStep(
         bool selectPerform = true,
@@ -21,38 +23,18 @@ public GoToFieldStep(
         : base(enabled)
     {
         SelectPerform = selectPerform;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", SelectPerform ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Go to Field [ " + "Select/perform: " + (SelectPerform ? "On" : "Off") + " ; " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var selectPerform_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new GoToFieldStep(selectPerform_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<GoToFieldStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool selectPerform_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select/perform:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(15).Trim(); selectPerform_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (!tok.StartsWith("Select/perform:", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(tok)) { target = FieldRef.FromDisplayToken(tok); break; } }
-        return new GoToFieldStep(selectPerform_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<GoToFieldStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,24 +42,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "navigation",
         HelpUrl = "https://help.claris.com/en/pro-help/content/go-to-field.html",
-        Params =
+        // Canonical 017-GoToField: unconfigured form is <SelectAll> only;
+        // the configured variant (-2) adds <Field>, so it is Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Select/perform",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-            },
+            new BoolStateChild("SelectAll") { PocoProperty = "SelectPerform", HrLabel = "Select/perform", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/GoToLayoutStep.cs b/src/SharpFM.Model/Scripting/Steps/GoToLayoutStep.cs
index 3f431e5..2f67724 100644
--- a/src/SharpFM.Model/Scripting/Steps/GoToLayoutStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GoToLayoutStep.cs
@@ -3,6 +3,8 @@
 using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -39,6 +41,10 @@ public GoToLayoutStep(bool enabled, LayoutTarget target, Animation? animation =
 
     // --- XML parse ---
 
+    // Hand-written rather than StepXmlParser: the reader is deliberately more
+    // tolerant than the canonical shape — it accepts legacy wire-value aliases
+    // and degrades a SelectedLayout with no named reference to Original
+    // instead of materializing an empty target.
     public static new ScriptStep FromXml(XElement step)
     {
         var enabled = step.Attribute("enable")?.Value != "False";
@@ -78,46 +84,12 @@ private static Calculation ReadCalculationFromLayout(XElement? layoutEl)
 
     // --- XML emit ---
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-
-        step.Add(new XElement("LayoutDestination",
-            new XAttribute("value", Target.WireValue)));
-
-        switch (Target)
-        {
-            case LayoutTarget.Original:
-                // No <Layout> element at all.
-                break;
-
-            case LayoutTarget.Named named:
-                // NamedRef.ToXml emits id+name attributes — the real id is
-                // carried from FromXml through the POCO, not silently
-                // replaced with zero.
-                step.Add(named.Layout.ToXml("Layout"));
-                break;
-
-            case LayoutTarget.ByNameCalc byName:
-                step.Add(new XElement("Layout", byName.Calc.ToXml()));
-                break;
-
-            case LayoutTarget.ByNumberCalc byNumber:
-                step.Add(new XElement("Layout", byNumber.Calc.ToXml()));
-                break;
-        }
-
-        if (Animation is not null)
-            step.Add(Animation.ToXml());
-
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
     // --- Display text render ---
 
+    // Hand-written: quoted "layout name" / original-layout variant grammar
+    // the shape renderer cannot produce.
     public override string ToDisplayLine()
     {
         var parts = new List<string>();
@@ -218,11 +190,35 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "navigation",
         HelpUrl = "https://help.claris.com/en/pro-help/content/go-to-layout.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "LayoutDestination", XmlElement = "LayoutDestination", XmlAttr = "value", Type = "enum", ValidValues = ["OriginalLayout", "SelectedLayout", "LayoutNameByCalc", "LayoutNumberByCalc"], DefaultValue = "SelectedLayout" },
-            new ParamMetadata { Name = "Layout", XmlElement = "Layout", Type = "layout" },
-            new ParamMetadata { Name = "Animation", XmlElement = "Animation", Type = "enum" },
+            new VariantBlock(
+            [
+                new VariantCase(typeof(LayoutTarget.Original),
+                    [new EnumValueChild("LayoutDestination") { PocoProperty = "WireValue" }])
+                { MatchElement = "LayoutDestination", MatchValues = ["OriginalLayout"] },
+                new VariantCase(typeof(LayoutTarget.ByNameCalc),
+                    [
+                        new EnumValueChild("LayoutDestination") { PocoProperty = "WireValue" },
+                        new NamedCalcChild("Layout") { PocoProperty = "Calc" },
+                    ])
+                { MatchElement = "LayoutDestination", MatchValues = ["LayoutNameByCalc", "LayoutNameByCalculation"] },
+                new VariantCase(typeof(LayoutTarget.ByNumberCalc),
+                    [
+                        new EnumValueChild("LayoutDestination") { PocoProperty = "WireValue" },
+                        new NamedCalcChild("Layout") { PocoProperty = "Calc" },
+                    ])
+                { MatchElement = "LayoutDestination", MatchValues = ["LayoutNumberByCalc", "LayoutNumberByCalculation"] },
+                new VariantCase(typeof(LayoutTarget.Named),
+                    [
+                        new EnumValueChild("LayoutDestination") { PocoProperty = "WireValue" },
+                        new NamedRefChild("Layout"),
+                    ])
+                { MatchElement = "LayoutDestination" },
+            ]) { PocoProperty = "Target", Required = true, Display = DisplayMode.Hidden },
+            new HrOnly("LayoutDestination") { DisplayValues = ["OriginalLayout", "SelectedLayout", "LayoutNameByCalc", "LayoutNumberByCalc"] },
+            new HrOnly("Layout"),
+            new ValueTypeChild("Animation") { Display = DisplayMode.Augmented },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/GoToListOfRecordsStep.cs b/src/SharpFM.Model/Scripting/Steps/GoToListOfRecordsStep.cs
index fe0d3a9..6b4fa97 100644
--- a/src/SharpFM.Model/Scripting/Steps/GoToListOfRecordsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GoToListOfRecordsStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -15,9 +17,11 @@ public sealed class GoToListOfRecordsStep : ScriptStep, IStepFactory
     public const string XmlName = "Go to List of Records";
 
     public bool ShowInNewWindow { get; set; }
-    public string LayoutDestination { get; set; }
-    public Calculation RowList { get; set; }
-    public NewWindowStyles WindowStyles { get; set; }
+    public string LayoutDestination { get; set; } = "CurrentLayout";
+    public Calculation? RowList { get; set; }
+    public NewWindowStyles WindowStyles { get; set; } = NewWindowStyles.Default();
+
+    private GoToListOfRecordsStep() : base(false) { }
 
     public GoToListOfRecordsStep(
         bool showInNewWindow = false,
@@ -29,46 +33,32 @@ public GoToListOfRecordsStep(
     {
         ShowInNewWindow = showInNewWindow;
         LayoutDestination = layoutDestination;
-        RowList = rowList ?? new Calculation("");
+        RowList = rowList;
         WindowStyles = windowStyles ?? NewWindowStyles.Default();
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ShowInNewWindow", new XAttribute("state", ShowInNewWindow ? "True" : "False")),
-            new XElement("LayoutDestination", new XAttribute("value", LayoutDestination)),
-            new XElement("RowList", RowList.ToXml("Calculation")),
-            WindowStyles.ToXml());
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: shows RowList/Layout in the reverse of canonical XML order
+    // and "New window" as a conditional bare token a BoolStateChild cannot render.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>
         {
-            $"Records: {RowList.Text}",
+            $"Records: {RowList?.Text ?? ""}",
             $"Layout: {LayoutDestination}",
         };
         if (ShowInNewWindow) parts.Add("New window");
         return $"Go to List of Records [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var newWin = step.Element("ShowInNewWindow")?.Attribute("state")?.Value == "True";
-        var dest = step.Element("LayoutDestination")?.Attribute("value")?.Value ?? "CurrentLayout";
-        var listEl = step.Element("RowList")?.Element("Calculation");
-        var rowList = listEl is not null ? Calculation.FromXml(listEl) : new Calculation("");
-        var stylesEl = step.Element("NewWndStyles");
-        var styles = stylesEl is not null ? NewWindowStyles.FromXml(stylesEl) : NewWindowStyles.Default();
-        return new GoToListOfRecordsStep(newWin, dest, rowList, styles, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<GoToListOfRecordsStep>(step, Metadata);
 
+    // Hand-written: display is lossy (RowList is the only parseable field) and
+    // an unlabeled shape parse would mis-bind the labeled Records/Layout tokens.
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        // Lossy display — RowList calc is the only field meaningful to parse.
         Calculation rowList = new("");
         foreach (var tok in hrParams)
         {
@@ -85,12 +75,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "navigation",
         HelpUrl = "https://help.claris.com/en/pro-help/content/go-to-list-of-records.html",
-        Params =
+        // Canonical: ShowInNewWindow, LayoutDestination, the optional <RowList>
+        // calculation, then the NewWndStyles value type.
+        Shape =
         [
-            new ParamMetadata { Name = "ShowInNewWindow", XmlElement = "ShowInNewWindow", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "LayoutDestination", XmlElement = "LayoutDestination", XmlAttr = "value", Type = "enum" },
-            new ParamMetadata { Name = "RowList", XmlElement = "RowList", Type = "namedCalc", Required = true },
-            new ParamMetadata { Name = "NewWndStyles", XmlElement = "NewWndStyles", Type = "complex" },
+            new BoolStateChild("ShowInNewWindow") { PocoProperty = "ShowInNewWindow", Display = DisplayMode.Native },
+            new EnumValueChild("LayoutDestination") { PocoProperty = "LayoutDestination", DefaultValue = "CurrentLayout", Display = DisplayMode.Native },
+            new NamedCalcChild("RowList") { PocoProperty = "RowList", Optional = true, Display = DisplayMode.Native },
+            new ValueTypeChild("NewWndStyles") { PocoProperty = "WindowStyles", Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/GoToNextFieldStep.cs b/src/SharpFM.Model/Scripting/Steps/GoToNextFieldStep.cs
index 106c632..f89de3d 100644
--- a/src/SharpFM.Model/Scripting/Steps/GoToNextFieldStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GoToNextFieldStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -10,24 +11,22 @@ namespace SharpFM.Model.Scripting.Steps;
 /// </summary>
 public sealed class GoToNextFieldStep : ScriptStep, IStepFactory
 {
-    public const int XmlId = 5;
+    public const int XmlId = 4;
     public const string XmlName = "Go to Next Field";
 
+    private GoToNextFieldStep() : base(false) { }
+
     public GoToNextFieldStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new GoToNextFieldStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<GoToNextFieldStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new GoToNextFieldStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<GoToNextFieldStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/GoToObjectStep.cs b/src/SharpFM.Model/Scripting/Steps/GoToObjectStep.cs
index 675469c..854964e 100644
--- a/src/SharpFM.Model/Scripting/Steps/GoToObjectStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GoToObjectStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,8 +14,10 @@ public sealed class GoToObjectStep : ScriptStep, IStepFactory
     public const int XmlId = 145;
     public const string XmlName = "Go to Object";
 
-    public Calculation Calculation { get; set; }
-    public Calculation Calculation2 { get; set; }
+    public Calculation Calculation { get; set; } = new("");
+    public Calculation Calculation2 { get; set; } = new("");
+
+    private GoToObjectStep() : base(false) { }
 
     public GoToObjectStep(
         Calculation? calculation = null,
@@ -25,36 +29,27 @@ public GoToObjectStep(
         Calculation2 = calculation2 ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ObjectName", Calculation.ToXml("Calculation")),
-            new XElement("Repetition", Calculation2.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: quoted "object name" token form the shape renderer
+    // cannot produce.
     public override string ToDisplayLine() =>
         "Go to Object [ " + Calculation.Text + " ; " + Calculation2.Text + " ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var calculation_vWrapEl = step.Element("ObjectName");
-        var calculation_vCalcEl = calculation_vWrapEl?.Element("Calculation");
-        var calculation_v = calculation_vCalcEl is not null ? Calculation.FromXml(calculation_vCalcEl) : new Calculation("");
-        var calculation2_vWrapEl = step.Element("Repetition");
-        var calculation2_vCalcEl = calculation2_vWrapEl?.Element("Calculation");
-        var calculation2_v = calculation2_vCalcEl is not null ? Calculation.FromXml(calculation2_vCalcEl) : new Calculation("");
-        return new GoToObjectStep(calculation_v, calculation2_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<GoToObjectStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
+        // Positional display grammar: [ object-name ; repetition ]. Trailing
+        // empty tokens are dropped by the param splitter.
         var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? calculation_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation_v = new Calculation(tok); break; } }
-        Calculation? calculation2_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation2_v = new Calculation(tok); break; } }
+        Calculation? calculation_v = tokens.Length > 0 && tokens[0].Length > 0
+            ? new Calculation(tokens[0])
+            : null;
+        Calculation? calculation2_v = tokens.Length > 1 && tokens[1].Length > 0
+            ? new Calculation(tokens[1])
+            : null;
         return new GoToObjectStep(calculation_v, calculation2_v, enabled);
     }
 
@@ -64,20 +59,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "navigation",
         HelpUrl = "https://help.claris.com/en/pro-help/content/go-to-object.html",
-        Params =
+        // ObjectName and Repetition wrappers are omitted by the unconfigured
+        // form (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
+            new NamedCalcChild("ObjectName") { PocoProperty = "Calculation", Optional = true, Display = DisplayMode.Native },
+            new NamedCalcChild("Repetition") { PocoProperty = "Calculation2", Optional = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/GoToPortalRowStep.cs b/src/SharpFM.Model/Scripting/Steps/GoToPortalRowStep.cs
index 5f90f41..d466fd4 100644
--- a/src/SharpFM.Model/Scripting/Steps/GoToPortalRowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GoToPortalRowStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,10 +14,35 @@ public sealed class GoToPortalRowStep : ScriptStep, IStepFactory
 
     public bool WithDialog { get; set; }
     public bool SelectAll { get; set; }
-    public string Location { get; set; }
+    public string Location { get; set; } = "Next";
     public bool ExitAfterLast { get; set; }
     public Calculation? Calculation { get; set; }
 
+    /// <summary>
+    /// Display edits are anchor-preserved when the dialog is suppressed —
+    /// the display line never shows a "With dialog" segment, so only the
+    /// default (dialog on) state survives a display round-trip.
+    /// </summary>
+    public override bool IsFullyEditable => WithDialog;
+
+    // Wire bridges for the shape engine. NoInteract inverts WithDialog;
+    // <Exit> is emitted (always state="True") only for Previous/Next, and the
+    // bare <Calculation> only for ByCalculation — the getters return null
+    // outside those locations so the Optional nodes are omitted.
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+    public bool? ExitWire
+    {
+        get => ExitAfterLast && Location is "Previous" or "Next" ? true : null;
+        set => ExitAfterLast = value ?? false;
+    }
+    public Calculation? CalculationWire
+    {
+        get => Location == "ByCalculation" ? Calculation : null;
+        set => Calculation = value;
+    }
+
+    private GoToPortalRowStep() : base(false) { }
+
     public GoToPortalRowStep(
         bool withDialog = true,
         bool selectAll = false,
@@ -32,22 +59,10 @@ public GoToPortalRowStep(
         Calculation = calculation;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("SelectAll", new XAttribute("state", SelectAll ? "True" : "False")),
-            new XElement("RowPageLocation", new XAttribute("value", Location)));
-        if (ExitAfterLast && (Location == "Previous" || Location == "Next"))
-            step.Add(new XElement("Exit", new XAttribute("state", "True")));
-        if (Location == "ByCalculation" && Calculation is not null)
-            step.Add(Calculation.ToXml("Calculation"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: per-mode conditional token grammar (First/Last/Previous/
+    // Next/ByCalculation) the shape renderer cannot produce.
     public override string ToDisplayLine()
     {
         var loc = Location == "ByCalculation" ? (Calculation?.Text ?? "") : Location;
@@ -57,17 +72,8 @@ public override string ToDisplayLine()
         return $"Go to Portal Row [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var selectAll = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var location = step.Element("RowPageLocation")?.Attribute("value")?.Value ?? "Next";
-        var exit = step.Element("Exit")?.Attribute("state")?.Value == "True";
-        var calcEl = step.Element("Calculation");
-        var calc = calcEl is not null ? Calculation.FromXml(calcEl) : null;
-        return new GoToPortalRowStep(withDialog, selectAll, location, exit, calc, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<GoToPortalRowStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -97,13 +103,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "navigation",
         HelpUrl = "https://help.claris.com/en/pro-help/content/go-to-portal-row.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "SelectAll", XmlElement = "SelectAll", XmlAttr = "state", Type = "boolean", HrLabel = "Select" },
-            new ParamMetadata { Name = "RowPageLocation", XmlElement = "RowPageLocation", XmlAttr = "value", Type = "enum", ValidValues = ["First", "Last", "Previous", "Next", "ByCalculation"] },
-            new ParamMetadata { Name = "Exit", XmlElement = "Exit", XmlAttr = "state", Type = "boolean", HrLabel = "Exit after last" },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation" },
+            new BoolStateChild("NoInteract") { HrLabel = "With dialog" },
+            new BoolStateChild("SelectAll") { HrLabel = "Select" },
+            new EnumValueChild("RowPageLocation") { PocoProperty = "Location", ValidValues = ["First", "Last", "Previous", "Next", "ByCalculation"], DefaultValue = "Next" },
+            new BoolStateChild("Exit") { PocoProperty = "ExitWire", Optional = true, HrLabel = "Exit after last" },
+            new BareCalcChild { PocoProperty = "CalculationWire", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/GoToPreviousFieldStep.cs b/src/SharpFM.Model/Scripting/Steps/GoToPreviousFieldStep.cs
index 730c68f..1c3a41c 100644
--- a/src/SharpFM.Model/Scripting/Steps/GoToPreviousFieldStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GoToPreviousFieldStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -10,24 +11,22 @@ namespace SharpFM.Model.Scripting.Steps;
 /// </summary>
 public sealed class GoToPreviousFieldStep : ScriptStep, IStepFactory
 {
-    public const int XmlId = 4;
+    public const int XmlId = 5;
     public const string XmlName = "Go to Previous Field";
 
+    private GoToPreviousFieldStep() : base(false) { }
+
     public GoToPreviousFieldStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new GoToPreviousFieldStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<GoToPreviousFieldStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new GoToPreviousFieldStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<GoToPreviousFieldStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/GoToRecordStep.cs b/src/SharpFM.Model/Scripting/Steps/GoToRecordStep.cs
index 87b13d0..5b68dc9 100644
--- a/src/SharpFM.Model/Scripting/Steps/GoToRecordStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GoToRecordStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -28,6 +30,15 @@ public sealed class GoToRecordStep : ScriptStep, IStepFactory
     public bool ExitAfterLast { get; set; }
     public bool NoInteract { get; set; }
 
+    // Emit-only wire projections for the shape renderer: get-only, so the
+    // shape parser skips them (FromXml stays hand-written for the typed enum).
+    // Null means "element not emitted for this location".
+    public string LocationWire => LocationWireValue(Location);
+    public bool? ExitWire =>
+        Location is RowPageLocationKind.Next or RowPageLocationKind.Previous ? ExitAfterLast : null;
+    public Calculation? LocationCalcWire =>
+        Location == RowPageLocationKind.ByCalculation ? LocationCalc : null;
+
     public GoToRecordStep(
         bool enabled,
         RowPageLocationKind location,
@@ -62,33 +73,10 @@ public GoToRecordStep(
         return new GoToRecordStep(enabled, location, locationCalc, exitAfterLast, noInteract);
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-
-        // FM Pro always emits <NoInteract> regardless of location.
-        step.Add(new XElement("NoInteract",
-            new XAttribute("state", NoInteract ? "True" : "False")));
-
-        // <Exit> is emitted only for Next / Previous.
-        if (Location is RowPageLocationKind.Next or RowPageLocationKind.Previous)
-        {
-            step.Add(new XElement("Exit",
-                new XAttribute("state", ExitAfterLast ? "True" : "False")));
-        }
-
-        step.Add(new XElement("RowPageLocation",
-            new XAttribute("value", LocationWireValue(Location))));
-
-        if (Location == RowPageLocationKind.ByCalculation && LocationCalc is not null)
-            step.Add(LocationCalc.ToXml());
-
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: per-mode conditional token grammar (First/Last/Previous/
+    // Next/ByCalculation) the shape renderer cannot produce.
     public override string ToDisplayLine()
     {
         var parts = new List<string>();
@@ -163,12 +151,15 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "navigation",
         HelpUrl = "https://help.claris.com/en/pro-help/content/go-to-record-request-page.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "RowPageLocation", XmlElement = "RowPageLocation", XmlAttr = "value", Type = "enum", ValidValues = ["First", "Last", "Previous", "Next", "ByCalculation"], DefaultValue = "Next" },
-            new ParamMetadata { Name = "Exit", XmlElement = "Exit", XmlAttr = "state", Type = "boolean", HrLabel = "Exit after last" },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation" },
+            // FM Pro always emits <NoInteract>; <Exit> only for Next/Previous;
+            // a bare <Calculation> only for ByCalculation (the emit-only wire
+            // projections above return null outside those locations).
+            new BoolStateChild("NoInteract") { HrLabel = "With dialog" },
+            new BoolStateChild("Exit") { PocoProperty = "ExitWire", Optional = true, HrLabel = "Exit after last" },
+            new EnumValueChild("RowPageLocation") { PocoProperty = "LocationWire", ValidValues = ["First", "Last", "Previous", "Next", "ByCalculation"], DefaultValue = "Next" },
+            new BareCalcChild { PocoProperty = "LocationCalcWire", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/GoToRelatedRecordStep.cs b/src/SharpFM.Model/Scripting/Steps/GoToRelatedRecordStep.cs
index 4676145..20c3826 100644
--- a/src/SharpFM.Model/Scripting/Steps/GoToRelatedRecordStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/GoToRelatedRecordStep.cs
@@ -1,15 +1,18 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
 /// <summary>
-/// Go to Related Record. Required Table reference (source relationship).
-/// Optional Layout, ShowInNewWindow (mutually exclusive with Animation),
-/// plus MatchAllRecords and Option flags. When ShowInNewWindow is True,
-/// window geometry is carried by NewWndStyles.
+/// Go to Related Record (74). Canonical form (skill, navigation reference):
+/// Option, MatchAllRecords, ShowInNewWindow and Restore flags, then
+/// LayoutDestination, the NewWndStyles attribute element, the always-present
+/// Table reference, and an optional Layout. The skill documents no
+/// <c>&lt;Animation&gt;</c> element for this step, so SharpFM no longer emits one.
 /// </summary>
 public sealed class GoToRelatedRecordStep : ScriptStep, IStepFactory
 {
@@ -20,11 +23,21 @@ public sealed class GoToRelatedRecordStep : ScriptStep, IStepFactory
     public bool MatchAllRecords { get; set; }
     public bool ShowInNewWindow { get; set; }
     public bool RestoreWindowGeometry { get; set; }
-    public string LayoutDestination { get; set; }
-    public NewWindowStyles WindowStyles { get; set; }
-    public NamedRef Table { get; set; }
-    public NamedRef Layout { get; set; }
-    public string Animation { get; set; }
+    public string LayoutDestination { get; set; } = "SelectedLayout";
+    public NewWindowStyles WindowStyles { get; set; } = NewWindowStyles.Default();
+    public NamedRef Table { get; set; } = new(0, "");
+    public NamedRef? Layout { get; set; }
+
+    /// <summary>
+    /// Display edits are anchor-preserved when the step carries state the
+    /// display line cannot express: a Restore-off flag, a non-default layout
+    /// destination, or customized new-window styles.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        RestoreWindowGeometry && LayoutDestination == "SelectedLayout"
+        && WindowStyles == NewWindowStyles.Default();
+
+    private GoToRelatedRecordStep() : base(false) { }
 
     public GoToRelatedRecordStep(
         bool showOnlyRelated = false,
@@ -35,7 +48,6 @@ public GoToRelatedRecordStep(
         NewWindowStyles? windowStyles = null,
         NamedRef? table = null,
         NamedRef? layout = null,
-        string animation = "None",
         bool enabled = true)
         : base(enabled)
     {
@@ -46,30 +58,18 @@ public GoToRelatedRecordStep(
         LayoutDestination = layoutDestination;
         WindowStyles = windowStyles ?? NewWindowStyles.Default();
         Table = table ?? new NamedRef(0, "");
-        Layout = layout ?? new NamedRef(0, "");
-        Animation = animation;
+        Layout = layout;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Option", new XAttribute("state", ShowOnlyRelated ? "True" : "False")),
-            new XElement("MatchAllRecords", new XAttribute("state", MatchAllRecords ? "True" : "False")),
-            new XElement("ShowInNewWindow", new XAttribute("state", ShowInNewWindow ? "True" : "False")),
-            new XElement("Restore", new XAttribute("state", RestoreWindowGeometry ? "True" : "False")),
-            new XElement("LayoutDestination", new XAttribute("value", LayoutDestination)),
-            WindowStyles.ToXml(),
-            Table.ToXml("Table"),
-            Layout.ToXml("Layout"),
-            new XElement("Animation", new XAttribute("value", Animation)));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: quoted "From table:"/"Using layout:" grammar the shape
+    // renderer cannot produce.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>();
         parts.Add($"From table: \"{Table.Name}\"");
-        if (Layout.Id != 0 || !string.IsNullOrEmpty(Layout.Name))
+        if (Layout is not null && (Layout.Id != 0 || !string.IsNullOrEmpty(Layout.Name)))
             parts.Add($"Using layout: \"{Layout.Name}\"");
         if (ShowOnlyRelated) parts.Add("Show only related records");
         if (MatchAllRecords) parts.Add("Match found set");
@@ -77,30 +77,15 @@ public override string ToDisplayLine()
         return $"Go to Related Record [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var option = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var matchAll = step.Element("MatchAllRecords")?.Attribute("state")?.Value == "True";
-        var newWin = step.Element("ShowInNewWindow")?.Attribute("state")?.Value == "True";
-        var restore = step.Element("Restore")?.Attribute("state")?.Value == "True";
-        var dest = step.Element("LayoutDestination")?.Attribute("value")?.Value ?? "SelectedLayout";
-        var stylesEl = step.Element("NewWndStyles");
-        var styles = stylesEl is not null ? NewWindowStyles.FromXml(stylesEl) : NewWindowStyles.Default();
-        var tableEl = step.Element("Table");
-        var table = tableEl is not null ? NamedRef.FromXml(tableEl) : new NamedRef(0, "");
-        var layoutEl = step.Element("Layout");
-        var layout = layoutEl is not null ? NamedRef.FromXml(layoutEl) : new NamedRef(0, "");
-        var animation = step.Element("Animation")?.Attribute("value")?.Value ?? "None";
-        return new GoToRelatedRecordStep(option, matchAll, newWin, restore, dest, styles, table, layout, animation, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<GoToRelatedRecordStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        // Display form is lossy — NewWndStyles attrs, animation, and
-        // LayoutDestination calc variants can't all round-trip.
+        // Display form is lossy — NewWndStyles attrs and LayoutDestination calc
+        // variants can't all round-trip.
         NamedRef table = new(0, "");
-        NamedRef layout = new(0, "");
+        NamedRef? layout = null;
         bool showOnly = false, matchAll = false, newWindow = false;
         foreach (var tok in hrParams)
         {
@@ -116,7 +101,7 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
             else if (t.Equals("New window", StringComparison.OrdinalIgnoreCase))
                 newWindow = true;
         }
-        return new GoToRelatedRecordStep(showOnly, matchAll, newWindow, true, "SelectedLayout", null, table, layout, "None", enabled);
+        return new GoToRelatedRecordStep(showOnly, matchAll, newWindow, true, "SelectedLayout", null, table, layout, enabled);
     }
 
     private static string Unquote(string s)
@@ -131,17 +116,22 @@ private static string Unquote(string s)
         Id = XmlId,
         Category = "navigation",
         HelpUrl = "https://help.claris.com/en/pro-help/content/go-to-related-record.html",
-        Params =
+        // Canonical order: Option, MatchAllRecords, ShowInNewWindow, Restore,
+        // LayoutDestination, NewWndStyles, Table (always), optional Layout.
+        // No <Animation> for this step (skill).
+        Shape =
         [
-            new ParamMetadata { Name = "Option", XmlElement = "Option", XmlAttr = "state", Type = "boolean", HrLabel = "Show only related records" },
-            new ParamMetadata { Name = "MatchAllRecords", XmlElement = "MatchAllRecords", XmlAttr = "state", Type = "boolean", HrLabel = "Match found set" },
-            new ParamMetadata { Name = "ShowInNewWindow", XmlElement = "ShowInNewWindow", XmlAttr = "state", Type = "boolean", HrLabel = "New window" },
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "LayoutDestination", XmlElement = "LayoutDestination", XmlAttr = "value", Type = "enum", ValidValues = ["CurrentLayout", "SelectedLayout", "LayoutNameByCalc", "LayoutNumberByCalc", "UseExternalTableLayouts"] },
-            new ParamMetadata { Name = "Table", XmlElement = "Table", Type = "tableOccurrence", Required = true },
-            new ParamMetadata { Name = "Layout", XmlElement = "Layout", Type = "layoutRef" },
-            new ParamMetadata { Name = "NewWndStyles", XmlElement = "NewWndStyles", Type = "complex" },
-            new ParamMetadata { Name = "Animation", XmlElement = "Animation", XmlAttr = "value", Type = "enum" },
+            new BoolStateChild("Option") { PocoProperty = "ShowOnlyRelated", HrLabel = "Show only related records", Display = DisplayMode.Augmented },
+            new BoolStateChild("MatchAllRecords") { PocoProperty = "MatchAllRecords", HrLabel = "Match found set", Display = DisplayMode.Augmented },
+            new BoolStateChild("ShowInNewWindow") { PocoProperty = "ShowInNewWindow", HrLabel = "New window", Display = DisplayMode.Augmented },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreWindowGeometry", Display = DisplayMode.Hidden },
+            new EnumValueChild("LayoutDestination") { PocoProperty = "LayoutDestination", DefaultValue = "SelectedLayout", Display = DisplayMode.Hidden },
+            new ValueTypeChild("NewWndStyles") { PocoProperty = "WindowStyles", Display = DisplayMode.Hidden },
+            new HrOnly("Restore") { Boolean = true },
+            new HrOnly("LayoutDestination") { DisplayValues = ["CurrentLayout", "SelectedLayout", "LayoutNameByCalc", "LayoutNumberByCalc", "UseExternalTableLayouts"] },
+            new NamedRefChild("Table") { PocoProperty = "Table", Required = true, Display = DisplayMode.Native },
+            new NamedRefChild("Layout") { PocoProperty = "Layout", Optional = true, Display = DisplayMode.Native },
+            new HrOnly("NewWndStyles"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/HaltScriptStep.cs b/src/SharpFM.Model/Scripting/Steps/HaltScriptStep.cs
index 5b0e1f6..4d115ee 100644
--- a/src/SharpFM.Model/Scripting/Steps/HaltScriptStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/HaltScriptStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class HaltScriptStep : ScriptStep, IStepFactory
     public const int XmlId = 90;
     public const string XmlName = "Halt Script";
 
+    private HaltScriptStep() : base(false) { }
+
     public HaltScriptStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new HaltScriptStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<HaltScriptStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new HaltScriptStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<HaltScriptStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/ImportRecordsStep.cs b/src/SharpFM.Model/Scripting/Steps/ImportRecordsStep.cs
index bf86deb..7dd61ad 100644
--- a/src/SharpFM.Model/Scripting/Steps/ImportRecordsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ImportRecordsStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -26,6 +28,67 @@ public sealed class ImportRecordsStep : ScriptStep, IStepFactory
     public NamedRef? Table { get; set; }
     public IReadOnlyList<ImportTargetField> TargetFields { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    /// <summary>
+    /// Display edits are anchor-preserved once the import is configured: the
+    /// display line carries only the dialog flag and source path, so a stored
+    /// restore/SSL flag, non-File data source, import options, target table or
+    /// field map seals the step.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        !RestoreStoredOrder && !VerifySslCertificates && DataSourceType == "File"
+        && ImportOptions is null && Table is null && TargetFields.Count == 0;
+
+    /// <summary>
+    /// <c>&lt;DataSourceType&gt;</c> wire projection: the descriptor is emitted
+    /// only when a source path is configured (null suppresses the element).
+    /// </summary>
+    public string? DataSourceTypeWire
+    {
+        get => string.IsNullOrEmpty(Path) ? null : DataSourceType;
+        set => DataSourceType = string.IsNullOrEmpty(value) ? "File" : value;
+    }
+
+    /// <summary>
+    /// Shape-facing view of the trailing complex children no primitive models
+    /// (attribute-dictionary <c>&lt;ImportOptions&gt;</c>, the target
+    /// <c>&lt;Table&gt;</c> reference and the <c>&lt;TargetFields&gt;</c> map),
+    /// emitted and parsed back through the shape's passthrough slot.
+    /// </summary>
+    public List<XElement> ComplexWire
+    {
+        get
+        {
+            var list = new List<XElement>();
+            if (ImportOptions is not null)
+            {
+                var opts = new XElement("ImportOptions");
+                foreach (var kv in ImportOptions) opts.Add(new XAttribute(kv.Key, kv.Value));
+                list.Add(opts);
+            }
+            if (Table is not null) list.Add(Table.ToXml("Table"));
+            if (TargetFields.Count > 0)
+                list.Add(new XElement("TargetFields", TargetFields.Select(f => f.ToXml())));
+            return list;
+        }
+        set
+        {
+            ImportOptions = value.FirstOrDefault(e => e.Name.LocalName == "ImportOptions")
+                ?.Attributes().ToDictionary(a => a.Name.LocalName, a => a.Value);
+            var tableEl = value.FirstOrDefault(e => e.Name.LocalName == "Table");
+            Table = tableEl is not null ? NamedRef.FromXml(tableEl) : null;
+            TargetFields = value.FirstOrDefault(e => e.Name.LocalName == "TargetFields")
+                ?.Elements("Field").Select(ImportTargetField.FromXml).ToList() ?? new List<ImportTargetField>();
+        }
+    }
+
+    // Display-parse defaults: a bare display line means the canonical
+    // unconfigured form, whose Restore state is False. XML parse always
+    // overwrites these, so this is display-only.
+    private ImportRecordsStep() : this(enabled: true) { RestoreStoredOrder = false; }
+
     public ImportRecordsStep(
         bool withDialog = false, bool restoreStoredOrder = true, bool verifySslCertificates = false,
         string dataSourceType = "File", string path = "",
@@ -45,62 +108,15 @@ public ImportRecordsStep(
         TargetFields = targetFields ?? new List<ImportTargetField>();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("Restore", new XAttribute("state", RestoreStoredOrder ? "True" : "False")),
-            new XElement("VerifySSLCertificates", new XAttribute("state", VerifySslCertificates ? "True" : "False")),
-            new XElement("DataSourceType", new XAttribute("value", DataSourceType)),
-            new XElement("UniversalPathList", Path));
-        if (ImportOptions is not null)
-        {
-            var opts = new XElement("ImportOptions");
-            foreach (var kv in ImportOptions) opts.Add(new XAttribute(kv.Key, kv.Value));
-            step.Add(opts);
-        }
-        if (Table is not null) step.Add(Table.ToXml("Table"));
-        if (TargetFields.Count > 0)
-        {
-            var tf = new XElement("TargetFields");
-            foreach (var f in TargetFields) tf.Add(f.ToXml());
-            step.Add(tf);
-        }
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Import Records [ With dialog: {(WithDialog ? "On" : "Off")} ; {Path} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var optsEl = step.Element("ImportOptions");
-        Dictionary<string, string>? opts = null;
-        if (optsEl is not null)
-        {
-            opts = new Dictionary<string, string>();
-            foreach (var a in optsEl.Attributes()) opts[a.Name.LocalName] = a.Value;
-        }
-        var tableEl = step.Element("Table");
-        var targetEl = step.Element("TargetFields");
-        return new ImportRecordsStep(
-            step.Element("NoInteract")?.Attribute("state")?.Value != "True",
-            step.Element("Restore")?.Attribute("state")?.Value == "True",
-            step.Element("VerifySSLCertificates")?.Attribute("state")?.Value == "True",
-            step.Element("DataSourceType")?.Attribute("value")?.Value ?? "File",
-            step.Element("UniversalPathList")?.Value ?? "",
-            opts,
-            tableEl is not null ? NamedRef.FromXml(tableEl) : null,
-            targetEl?.Elements("Field").Select(ImportTargetField.FromXml).ToList(),
-            enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ImportRecordsStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new ImportRecordsStep(enabled: enabled);
+        StepDisplayParser.Parse<ImportRecordsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -108,16 +124,19 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
         Id = XmlId,
         Category = "records",
         HelpUrl = "https://help.claris.com/en/pro-help/content/import-records.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "VerifySSLCertificates", XmlElement = "VerifySSLCertificates", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "DataSourceType", XmlElement = "DataSourceType", XmlAttr = "value", Type = "enum", ValidValues = ["File", "Folder", "XMLSource"] },
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text" },
-            new ParamMetadata { Name = "ImportOptions", XmlElement = "ImportOptions", Type = "complex" },
-            new ParamMetadata { Name = "Table", XmlElement = "Table", Type = "tableRef" },
-            new ParamMetadata { Name = "TargetFields", XmlElement = "TargetFields", Type = "complex" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", DisplayInverted = true },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredOrder", Display = DisplayMode.Hidden },
+            new BoolStateChild("VerifySSLCertificates") { PocoProperty = "VerifySslCertificates", Display = DisplayMode.Hidden },
+            // The data-source descriptor and path are emitted only when a
+            // source is configured; the canonical unconfigured form omits them.
+            new EnumValueChild("DataSourceType") { PocoProperty = "DataSourceTypeWire", Optional = true, ValidValues = ["File", "Folder", "XMLSource"], DefaultValue = "File", Display = DisplayMode.Hidden },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Optional = true, DisplayEmptyAs = "" },
+            new Passthrough { PocoProperty = "ComplexWire" },
+            new HrOnly("ImportOptions"),
+            new HrOnly("Table"),
+            new HrOnly("TargetFields"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertAudioVideoStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertAudioVideoStep.cs
index eef69fd..70c259d 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertAudioVideoStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertAudioVideoStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -19,6 +21,8 @@ public sealed class InsertAudioVideoStep : ScriptStep, IStepFactory
     public string Path { get; set; }
     public string Reference { get; set; }
 
+    private InsertAudioVideoStep() : this("") { }
+
     public InsertAudioVideoStep(
         string path = "",
         string reference = "Embedded",
@@ -29,23 +33,15 @@ public InsertAudioVideoStep(
         Reference = reference;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UniversalPathList", new XAttribute("type", Reference), Path));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the single wire element splits into two display tokens
+    // (path text + type attribute), which the shape renderer cannot produce.
     public override string ToDisplayLine() =>
         $"Insert Audio/Video [ {Path} ; Reference: {Reference} ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var path = step.Element("UniversalPathList")?.Value ?? "";
-        var type = step.Element("UniversalPathList")?.Attribute("type")?.Value ?? "Embedded";
-        return new InsertAudioVideoStep(path, type, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertAudioVideoStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -68,18 +64,19 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         Name = XmlName, Id = XmlId, Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-audio-video.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "UniversalPathList", XmlElement = "UniversalPathList",
-                Type = "text",
-            },
-            new ParamMetadata
+            // The wire element surfaces as the labeled Reference slot; the path
+            // text it also carries gets its own HR-only positional slot.
+            new HrOnly("UniversalPathList"),
+            new NamedTextChild("UniversalPathList")
             {
-                Name = "Reference", XmlElement = "UniversalPathList", Type = "enum",
-                XmlAttr = "type", HrLabel = "Reference",
-                ValidValues = ["Embedded", "Reference"], DefaultValue = "Embedded",
+                PocoProperty = "Path",
+                Attr = "type",
+                AttrProperty = "Reference",
+                AttrDefault = "Embedded",
+                HrLabel = "Reference",
+                ValidValues = ["Embedded", "Reference"],
             },
         ],
         FromXml = FromXml,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertCalculatedResultStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertCalculatedResultStep.cs
index 27cc56e..6e155e5 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertCalculatedResultStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertCalculatedResultStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -20,7 +22,9 @@ public sealed class InsertCalculatedResultStep : ScriptStep, IStepFactory
 
     public bool SelectAll { get; set; }
     public FieldRef? Target { get; set; }
-    public Calculation Calculation { get; set; }
+    public Calculation? Calculation { get; set; }
+
+    private InsertCalculatedResultStep() : base(false) { }
 
     public InsertCalculatedResultStep(
         bool selectAll = true,
@@ -31,42 +35,22 @@ public InsertCalculatedResultStep(
     {
         SelectAll = selectAll;
         Target = target;
-        Calculation = calculation ?? new Calculation("");
+        Calculation = calculation;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", SelectAll ? "True" : "False")),
-            Calculation.ToXml("Calculation"));
-        if (Target is not null)
-        {
-            if (Target.IsVariable) step.Add(new XElement("Text"));
-            step.Add(Target.ToXml("Field"));
-        }
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: bare "Select" presence token from a BoolStateChild, which
+    // always renders labeled On/Off.
     public override string ToDisplayLine()
     {
         var selectPart = SelectAll ? "Select ; " : "";
         var targetPart = Target is null ? "" : $"Target: {Target.ToDisplayString()} ; ";
-        return $"Insert Calculated Result [ {selectPart}{targetPart}{Calculation.Text} ]";
+        return $"Insert Calculated Result [ {selectPart}{targetPart}{Calculation?.Text ?? ""} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var selectAll = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var calcEl = step.Element("Calculation");
-        var calc = calcEl is not null ? Calculation.FromXml(calcEl) : new Calculation("");
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new InsertCalculatedResultStep(selectAll, target, calc, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertCalculatedResultStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -96,11 +80,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-calculated-result.html",
-        Params =
+        // Canonical: SelectAll, then the optional calculation and field target.
+        // The bare <Calculation> and <Field> are emitted only when configured;
+        // a variable target is preceded by the bare <Text/> marker.
+        Shape =
         [
-            new ParamMetadata { Name = "SelectAll", XmlElement = "SelectAll", XmlAttr = "state", Type = "boolean", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "fieldOrVariable", HrLabel = "Target" },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation" },
+            new BoolStateChild("SelectAll") { PocoProperty = "SelectAll", HrLabel = "Select", Display = DisplayMode.Augmented },
+            new BareCalcChild { PocoProperty = "Calculation", Optional = true, Display = DisplayMode.Native },
+            new FieldChild("Field") { PocoProperty = "Target", HrLabel = "Target", Optional = true, VariableTextMarker = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertCurrentDateStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertCurrentDateStep.cs
index 35c4c81..25e20fa 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertCurrentDateStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertCurrentDateStep.cs
@@ -1,7 +1,7 @@
-using System;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +12,9 @@ public sealed class InsertCurrentDateStep : ScriptStep, IStepFactory
     public const string XmlName = "Insert Current Date";
 
     public bool Select { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private InsertCurrentDateStep() : base(false) { Select = true; }
 
     public InsertCurrentDateStep(
         bool select = true,
@@ -21,38 +23,18 @@ public InsertCurrentDateStep(
         : base(enabled)
     {
         Select = select;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Insert Current Date [ " + "Select: " + (Select ? "On" : "Off") + " ; " + "Target: " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new InsertCurrentDateStep(select_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertCurrentDateStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool select_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); select_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (tok.StartsWith("Target:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); target = FieldRef.FromDisplayToken(v); break; } }
-        return new InsertCurrentDateStep(select_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<InsertCurrentDateStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,25 +42,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-current-date.html",
-        Params =
+        // Canonical 013-InsertCurrentDate: only <SelectAll>; <Field> is omitted
+        // until a target is bound, so it is Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Select",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "fieldOrVariable",
-                HrLabel = "Target",
-            },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new FieldChild("Field") { PocoProperty = "Target", HrLabel = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertCurrentTimeStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertCurrentTimeStep.cs
index 9f48fcf..e55d6e7 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertCurrentTimeStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertCurrentTimeStep.cs
@@ -1,7 +1,7 @@
-using System;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +12,9 @@ public sealed class InsertCurrentTimeStep : ScriptStep, IStepFactory
     public const string XmlName = "Insert Current Time";
 
     public bool Select { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private InsertCurrentTimeStep() : base(false) { Select = true; }
 
     public InsertCurrentTimeStep(
         bool select = true,
@@ -21,38 +23,18 @@ public InsertCurrentTimeStep(
         : base(enabled)
     {
         Select = select;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Insert Current Time [ " + "Select: " + (Select ? "On" : "Off") + " ; " + "Target: " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new InsertCurrentTimeStep(select_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertCurrentTimeStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool select_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); select_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (tok.StartsWith("Target:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); target = FieldRef.FromDisplayToken(v); break; } }
-        return new InsertCurrentTimeStep(select_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<InsertCurrentTimeStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,25 +42,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-current-time.html",
-        Params =
+        // Canonical 014-InsertCurrentTime: only <SelectAll>; <Field> is omitted
+        // until a target is bound, so it is Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Select",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "fieldOrVariable",
-                HrLabel = "Target",
-            },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new FieldChild("Field") { PocoProperty = "Target", HrLabel = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertCurrentUserNameStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertCurrentUserNameStep.cs
index b23fe41..3763793 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertCurrentUserNameStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertCurrentUserNameStep.cs
@@ -1,7 +1,7 @@
-using System;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +12,9 @@ public sealed class InsertCurrentUserNameStep : ScriptStep, IStepFactory
     public const string XmlName = "Insert Current User Name";
 
     public bool Select { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private InsertCurrentUserNameStep() : base(false) { Select = true; }
 
     public InsertCurrentUserNameStep(
         bool select = true,
@@ -21,38 +23,18 @@ public InsertCurrentUserNameStep(
         : base(enabled)
     {
         Select = select;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Insert Current User Name [ " + "Select: " + (Select ? "On" : "Off") + " ; " + "Target: " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new InsertCurrentUserNameStep(select_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertCurrentUserNameStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool select_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); select_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (tok.StartsWith("Target:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); target = FieldRef.FromDisplayToken(v); break; } }
-        return new InsertCurrentUserNameStep(select_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<InsertCurrentUserNameStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,25 +42,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-current-user-name.html",
-        Params =
+        // Canonical 060-InsertCurrentUserName: only <SelectAll>; <Field> is
+        // omitted until a target is bound, so it is Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Select",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "fieldOrVariable",
-                HrLabel = "Target",
-            },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new FieldChild("Field") { PocoProperty = "Target", HrLabel = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertEmbeddingInFoundSetStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertEmbeddingInFoundSetStep.cs
index af5e990..0525353 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertEmbeddingInFoundSetStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertEmbeddingInFoundSetStep.cs
@@ -1,24 +1,26 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
 /// <summary>
-/// Insert Embedding in Found Set: The LLMBulkEmbedding parent element
-/// carries most params. The Target field is a sibling of LLMBulkEmbedding
-/// (outside it); SourceField is a Field element inside LLMBulkEmbedding.
-/// Flag elements (Overwrite, ContinueOnError, ShowSummary) use
-/// presence = On, absence = Off.
+/// Insert Embedding in Found Set (216). Canonical form (skill, AI reference): an
+/// optional target <c>Field</c> sibling, then an <c>&lt;LLMBulkEmbedding&gt;</c>
+/// wrapper holding the optional account/model calcs, the source <c>Field</c>,
+/// the presence-flag options (Overwrite / ContinueOnError / ShowSummary) and the
+/// optional parameters calc. Emitted as an empty wrapper when unconfigured.
 /// </summary>
 public sealed class InsertEmbeddingInFoundSetStep : ScriptStep, IStepFactory
 {
     public const int XmlId = 216;
     public const string XmlName = "Insert Embedding in Found Set";
 
-    public Calculation AccountName { get; set; }
-    public Calculation Model { get; set; }
+    public Calculation AccountName { get; set; } = new("");
+    public Calculation Model { get; set; } = new("");
     public FieldRef? SourceField { get; set; }
     public FieldRef? TargetField { get; set; }
     public bool Overwrite { get; set; }
@@ -26,6 +28,8 @@ public sealed class InsertEmbeddingInFoundSetStep : ScriptStep, IStepFactory
     public bool ShowSummary { get; set; }
     public Calculation? Parameters { get; set; }
 
+    private InsertEmbeddingInFoundSetStep() : base(false) { }
+
     public InsertEmbeddingInFoundSetStep(
         Calculation? accountName = null,
         Calculation? model = null,
@@ -48,30 +52,10 @@ public InsertEmbeddingInFoundSetStep(
         Parameters = parameters;
     }
 
-    public override XElement ToXml()
-    {
-        var bulk = new XElement("LLMBulkEmbedding",
-            new XElement("AccountName", AccountName.ToXml("Calculation")),
-            new XElement("Model", Model.ToXml("Calculation")));
-        if (SourceField is not null) bulk.Add(SourceField.ToXml("Field"));
-        if (Overwrite) bulk.Add(new XElement("Overwrite"));
-        if (ContinueOnError) bulk.Add(new XElement("ContinueOnError"));
-        if (ShowSummary) bulk.Add(new XElement("ShowSummary"));
-        if (Parameters is not null) bulk.Add(new XElement("Parameters", Parameters.ToXml("Calculation")));
-
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        if (TargetField is not null)
-        {
-            if (TargetField.IsVariable) step.Add(new XElement("Text"));
-            step.Add(TargetField.ToXml("Field"));
-        }
-        step.Add(bulk);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: FileMaker's token order (account/model first, target
+    // mid-line) diverges from the canonical XML order the shape must keep.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>
@@ -88,76 +72,33 @@ public override string ToDisplayLine()
         return $"Insert Embedding in Found Set [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var bulk = step.Element("LLMBulkEmbedding");
-        var account = bulk?.Element("AccountName")?.Element("Calculation");
-        var model = bulk?.Element("Model")?.Element("Calculation");
-        var sourceEl = bulk?.Element("Field");
-        var source = sourceEl is not null ? FieldRef.FromXml(sourceEl) : null;
-        var overwrite = bulk?.Element("Overwrite") is not null;
-        var continueErr = bulk?.Element("ContinueOnError") is not null;
-        var summary = bulk?.Element("ShowSummary") is not null;
-        var paramsEl = bulk?.Element("Parameters")?.Element("Calculation");
-        var targetEl = step.Element("Field");
-        var target = targetEl is not null ? FieldRef.FromXml(targetEl) : null;
-        return new InsertEmbeddingInFoundSetStep(
-            account is not null ? Calculation.FromXml(account) : new Calculation(""),
-            model is not null ? Calculation.FromXml(model) : new Calculation(""),
-            source,
-            target,
-            overwrite,
-            continueErr,
-            summary,
-            paramsEl is not null ? Calculation.FromXml(paramsEl) : null,
-            enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertEmbeddingInFoundSetStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        Calculation account = new(""), model = new("");
-        FieldRef? source = null, target = null;
-        bool overwrite = false, continueErr = false, summary = false;
-        Calculation? parameters = null;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("Account Name:", StringComparison.OrdinalIgnoreCase))
-                account = new Calculation(t.Substring(13).Trim());
-            else if (t.StartsWith("Embedding Model:", StringComparison.OrdinalIgnoreCase))
-                model = new Calculation(t.Substring(16).Trim());
-            else if (t.StartsWith("Source Field:", StringComparison.OrdinalIgnoreCase))
-                source = FieldRef.FromDisplayToken(t.Substring(13).Trim());
-            else if (t.StartsWith("Target Field:", StringComparison.OrdinalIgnoreCase))
-                target = FieldRef.FromDisplayToken(t.Substring(13).Trim());
-            else if (t.Equals("Replace target contents", StringComparison.OrdinalIgnoreCase))
-                overwrite = true;
-            else if (t.Equals("Continue on error", StringComparison.OrdinalIgnoreCase))
-                continueErr = true;
-            else if (t.Equals("Show summary", StringComparison.OrdinalIgnoreCase))
-                summary = true;
-            else if (t.StartsWith("Parameters:", StringComparison.OrdinalIgnoreCase))
-                parameters = new Calculation(t.Substring(11).Trim());
-        }
-        return new InsertEmbeddingInFoundSetStep(account, model, source, target, overwrite, continueErr, summary, parameters, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<InsertEmbeddingInFoundSetStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
-        Params =
+        // Canonical: optional target Field sibling, then the <LLMBulkEmbedding>
+        // wrapper with optional account/model, source Field, presence-flag
+        // options, and the optional parameters calc.
+        Shape =
         [
-            new ParamMetadata { Name = "AccountName", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Account Name", Required = true },
-            new ParamMetadata { Name = "Model", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Embedding Model", Required = true },
-            new ParamMetadata { Name = "SourceField", XmlElement = "Field", Type = "field", HrLabel = "Source Field" },
-            new ParamMetadata { Name = "TargetField", XmlElement = "Field", Type = "field", HrLabel = "Target Field" },
-            new ParamMetadata { Name = "Overwrite", XmlElement = "Overwrite", Type = "flagElement", HrLabel = "Replace target contents" },
-            new ParamMetadata { Name = "ContinueOnError", XmlElement = "ContinueOnError", Type = "flagElement", HrLabel = "Continue on error" },
-            new ParamMetadata { Name = "ShowSummary", XmlElement = "ShowSummary", Type = "flagElement", HrLabel = "Show summary" },
-            new ParamMetadata { Name = "Parameters", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Parameters" },
+            new FieldChild("Field") { PocoProperty = "TargetField", HrLabel = "Target Field", Optional = true, VariableTextMarker = true, Display = DisplayMode.Native },
+            new WrapperChild("LLMBulkEmbedding",
+            [
+                new NamedCalcChild("AccountName") { PocoProperty = "AccountName", HrLabel = "Account Name", Optional = true, Display = DisplayMode.Augmented },
+                new NamedCalcChild("Model") { PocoProperty = "Model", HrLabel = "Embedding Model", Optional = true, Display = DisplayMode.Augmented },
+                new FieldChild("Field") { PocoProperty = "SourceField", HrLabel = "Source Field", Optional = true, Display = DisplayMode.Native },
+                new FlagChild("Overwrite") { PocoProperty = "Overwrite", HrLabel = "Replace target contents" },
+                new FlagChild("ContinueOnError") { PocoProperty = "ContinueOnError", HrLabel = "Continue on error" },
+                new FlagChild("ShowSummary") { PocoProperty = "ShowSummary", HrLabel = "Show summary" },
+                new NamedCalcChild("Parameters") { PocoProperty = "Parameters", HrLabel = "Parameters", Optional = true, Display = DisplayMode.Augmented },
+            ]),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertEmbeddingStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertEmbeddingStep.cs
index c940e11..4aae6a2 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertEmbeddingStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertEmbeddingStep.cs
@@ -1,20 +1,30 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
+/// <summary>
+/// Insert Embedding (215). Canonical form (skill, AI reference): an optional
+/// target <c>Field</c> then an <c>&lt;LLMEmbedding&gt;</c> wrapper holding the
+/// account/model/input calculations; the wrapper is emitted empty when the step
+/// is unconfigured.
+/// </summary>
 public sealed class InsertEmbeddingStep : ScriptStep, IStepFactory
 {
     public const int XmlId = 215;
     public const string XmlName = "Insert Embedding";
 
-    public Calculation AccountName { get; set; }
-    public Calculation Model { get; set; }
-    public Calculation InputText { get; set; }
+    public Calculation AccountName { get; set; } = new("");
+    public Calculation Model { get; set; } = new("");
+    public Calculation InputText { get; set; } = new("");
     public FieldRef? Target { get; set; }
 
+    private InsertEmbeddingStep() : base(false) { }
+
     public InsertEmbeddingStep(
         Calculation? accountName = null,
         Calculation? model = null,
@@ -29,24 +39,10 @@ public InsertEmbeddingStep(
         Target = target;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        if (Target is not null)
-        {
-            if (Target.IsVariable) step.Add(new XElement("Text"));
-            step.Add(Target.ToXml("Field"));
-        }
-        step.Add(new XElement("LLMEmbedding",
-            new XElement("AccountName", AccountName.ToXml("Calculation")),
-            new XElement("Model", Model.ToXml("Calculation")),
-            new XElement("InputText", InputText.ToXml("Calculation"))));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: FileMaker shows the Target last, but the shape must keep
+    // the canonical XML order (Field before the LLMEmbedding wrapper).
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>
@@ -59,53 +55,28 @@ public override string ToDisplayLine()
         return $"Insert Embedding [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var llm = step.Element("LLMEmbedding");
-        var account = llm?.Element("AccountName")?.Element("Calculation");
-        var model = llm?.Element("Model")?.Element("Calculation");
-        var input = llm?.Element("InputText")?.Element("Calculation");
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new InsertEmbeddingStep(
-            account is not null ? Calculation.FromXml(account) : new Calculation(""),
-            model is not null ? Calculation.FromXml(model) : new Calculation(""),
-            input is not null ? Calculation.FromXml(input) : new Calculation(""),
-            target,
-            enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertEmbeddingStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        Calculation account = new(""), model = new(""), input = new("");
-        FieldRef? target = null;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("Account Name:", StringComparison.OrdinalIgnoreCase))
-                account = new Calculation(t.Substring(13).Trim());
-            else if (t.StartsWith("Embedding Model:", StringComparison.OrdinalIgnoreCase))
-                model = new Calculation(t.Substring(16).Trim());
-            else if (t.StartsWith("Input:", StringComparison.OrdinalIgnoreCase))
-                input = new Calculation(t.Substring(6).Trim());
-            else if (t.StartsWith("Target:", StringComparison.OrdinalIgnoreCase))
-                target = FieldRef.FromDisplayToken(t.Substring(7).Trim());
-        }
-        return new InsertEmbeddingStep(account, model, input, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<InsertEmbeddingStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
-        Params =
+        // Canonical: optional Field target, then the <LLMEmbedding> wrapper whose
+        // account/model/input children are emitted only when set.
+        Shape =
         [
-            new ParamMetadata { Name = "AccountName", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Account Name", Required = true },
-            new ParamMetadata { Name = "Model", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Embedding Model", Required = true },
-            new ParamMetadata { Name = "InputText", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Input", Required = true },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "fieldOrVariable", HrLabel = "Target" },
+            new FieldChild("Field") { PocoProperty = "Target", HrLabel = "Target", Optional = true, Display = DisplayMode.Native },
+            new WrapperChild("LLMEmbedding",
+            [
+                new NamedCalcChild("AccountName") { PocoProperty = "AccountName", HrLabel = "Account Name", Optional = true, Display = DisplayMode.Augmented },
+                new NamedCalcChild("Model") { PocoProperty = "Model", HrLabel = "Embedding Model", Optional = true, Display = DisplayMode.Augmented },
+                new NamedCalcChild("InputText") { PocoProperty = "InputText", HrLabel = "Input", Optional = true, Display = DisplayMode.Augmented },
+            ]),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertFileStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertFileStep.cs
index 2b23901..6a18e92 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertFileStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -15,6 +17,8 @@ public sealed class InsertFileStep : ScriptStep, IStepFactory
     public FieldRef? Target { get; set; }
     public InsertFileDialogOptions? DialogOptions { get; set; }
 
+    private InsertFileStep() : this(enabled: true) { }
+
     public InsertFileStep(
         string path = "",
         string pathType = "Embedded",
@@ -29,22 +33,11 @@ public InsertFileStep(
         DialogOptions = dialogOptions;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UniversalPathList", new XAttribute("type", PathType), Path));
-        if (Target is not null)
-        {
-            if (Target.IsVariable) step.Add(new XElement("Text"));
-            step.Add(Target.ToXml("Field"));
-        }
-        if (DialogOptions is not null) step.Add(DialogOptions.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the storage/compression/display-content tokens live inside
+    // the DialogOptions value type, which the shape-driven renderer cannot
+    // surface; token order also differs from shape order (Path renders last).
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>();
@@ -72,34 +65,42 @@ public override string ToDisplayLine()
         return parts.Count == 0 ? "Insert File" : $"Insert File [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var pathEl = step.Element("UniversalPathList");
-        var path = pathEl?.Value ?? "";
-        var pathType = pathEl?.Attribute("type")?.Value ?? "Embedded";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        var dialogEl = step.Element("DialogOptions");
-        var dialog = dialogEl is not null ? InsertFileDialogOptions.FromXml(dialogEl) : null;
-        return new InsertFileStep(path, pathType, target, dialog, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertFileStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when dialog state the display line
+    /// cannot carry is present: a missing DialogOptions block, a custom
+    /// dialog title (or the enable flag for one), or a compression filter
+    /// list. Storage, compression, and display-content choices are carried
+    /// by the display grammar.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        DialogOptions is { Enable: false, Title: null, FilterListXml: null };
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        // Display is lossy for Insert File — DialogOptions attributes don't
-        // all round-trip. Best-effort: capture path and target.
         string path = "";
         FieldRef? target = null;
+        var asFile = true;
+        var storage = "UserChoice";
+        var compress = "UserChoice";
         foreach (var tok in hrParams)
         {
             var t = tok.Trim();
             if (t.StartsWith("Target:", StringComparison.OrdinalIgnoreCase))
                 target = FieldRef.FromDisplayToken(t.Substring(7).Trim());
-            else if (!string.IsNullOrWhiteSpace(t) && !t.Contains(':') && t != "Insert" && t != "Reference" && t != "Display content" && !t.Contains("ompress"))
+            else if (t == "Insert") storage = "InsertOnly";
+            else if (t == "Reference") storage = "ReferenceOnly";
+            else if (t == "Insert and Reference") storage = "InsertAndReference";
+            else if (t == "Display content") asFile = false;
+            else if (t == "Compress when possible") compress = "WhenPossible";
+            else if (t == "Never compress") compress = "Never";
+            else if (!string.IsNullOrWhiteSpace(t))
                 path = t;
         }
-        return new InsertFileStep(path, "Embedded", target, null, enabled);
+        var dialogOptions = new InsertFileDialogOptions(asFile, false, null, storage, compress, null);
+        return new InsertFileStep(path, "Embedded", target, dialogOptions, enabled);
     }
 
     public static StepMetadata Metadata { get; } = new()
@@ -108,11 +109,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-file.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text" },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "fieldOrVariable", HrLabel = "Target" },
-            new ParamMetadata { Name = "DialogOptions", XmlElement = "DialogOptions", Type = "complex" },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Attr = "type", AttrProperty = "PathType", AttrDefault = "Embedded" },
+            new FieldChild { PocoProperty = "Target", Optional = true, VariableTextMarker = true, HrLabel = "Target" },
+            new ValueTypeChild("DialogOptions"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertFromDeviceStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertFromDeviceStep.cs
index 3699cb1..04e622c 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertFromDeviceStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertFromDeviceStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -17,9 +19,15 @@ public sealed class InsertFromDeviceStep : ScriptStep, IStepFactory
     public const string XmlName = "Insert from Device";
 
     public string InsertFrom { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
     public StepChildBag DeviceOptions { get; set; }
 
+    private InsertFromDeviceStep() : base(false)
+    {
+        InsertFrom = "Camera";
+        DeviceOptions = new StepChildBag();
+    }
+
     public InsertFromDeviceStep(
         string insertFrom = "Camera",
         FieldRef? target = null,
@@ -28,40 +36,26 @@ public InsertFromDeviceStep(
         : base(enabled)
     {
         InsertFrom = insertFrom;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
         DeviceOptions = deviceOptions ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("InsertFrom", new XAttribute("value", InsertFrom)),
-            Target.ToXml("Field"));
-        var opts = new XElement("DeviceOptions");
-        DeviceOptions.AppendTo(opts);
-        step.Add(opts);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Insert from Device [ {InsertFrom} ; {Target.ToDisplayString()} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var insertFrom = step.Element("InsertFrom")?.Attribute("value")?.Value ?? "Camera";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        var optsEl = step.Element("DeviceOptions");
-        var opts = optsEl is not null ? StepChildBag.FromParent(optsEl) : new StepChildBag();
-        return new InsertFromDeviceStep(insertFrom, target, opts, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertFromDeviceStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when a device-specific options
+    /// subtree is present — the display line shows only the source and
+    /// target, never the DeviceOptions children.
+    /// </summary>
+    public override bool IsFullyEditable => DeviceOptions.Children.Count == 0;
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new InsertFromDeviceStep(enabled: enabled);
+        StepDisplayParser.Parse<InsertFromDeviceStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -69,11 +63,18 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-from-device.html",
-        Params =
+        // InsertFrom, optional target Field, then the always-present
+        // DeviceOptions wrapper whose device-specific subtree is preserved
+        // verbatim (preserve-don't-synthesize).
+        Shape =
         [
-            new ParamMetadata { Name = "InsertFrom", XmlElement = "InsertFrom", XmlAttr = "value", Type = "enum", ValidValues = ["Camera", "Video Camera", "Microphone", "Photo Library", "Music Library", "Barcode", "Signature"] },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", Required = true },
-            new ParamMetadata { Name = "DeviceOptions", XmlElement = "DeviceOptions", Type = "complex" },
+            new EnumValueChild("InsertFrom") { PocoProperty = "InsertFrom", DefaultValue = "Camera", ValidValues = ["Camera", "Video Camera", "Microphone", "Photo Library", "Music Library", "Barcode", "Signature"] },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true },
+            new WrapperChild("DeviceOptions",
+            [
+                new Passthrough { PocoProperty = "DeviceOptions" },
+            ]),
+            new HrOnly("DeviceOptions"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertFromIndexStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertFromIndexStep.cs
index b3e0cb3..071228c 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertFromIndexStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertFromIndexStep.cs
@@ -1,7 +1,7 @@
-using System;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +12,9 @@ public sealed class InsertFromIndexStep : ScriptStep, IStepFactory
     public const string XmlName = "Insert from Index";
 
     public bool Select { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private InsertFromIndexStep() : base(false) { Select = true; }
 
     public InsertFromIndexStep(
         bool select = true,
@@ -21,38 +23,18 @@ public InsertFromIndexStep(
         : base(enabled)
     {
         Select = select;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Insert from Index [ " + "Select: " + (Select ? "On" : "Off") + " ; " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new InsertFromIndexStep(select_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertFromIndexStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool select_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); select_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (!tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(tok)) { target = FieldRef.FromDisplayToken(tok); break; } }
-        return new InsertFromIndexStep(select_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<InsertFromIndexStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,24 +42,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-from-index.html",
-        Params =
+        // Canonical 011-InsertFromIndex: only <SelectAll>; <Field> is omitted
+        // until a target is bound, so it is Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Select",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-            },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertFromLastVisitedStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertFromLastVisitedStep.cs
index 4f45492..1476a25 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertFromLastVisitedStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertFromLastVisitedStep.cs
@@ -1,7 +1,7 @@
-using System;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +12,9 @@ public sealed class InsertFromLastVisitedStep : ScriptStep, IStepFactory
     public const string XmlName = "Insert from Last Visited";
 
     public bool Select { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private InsertFromLastVisitedStep() : base(false) { Select = true; }
 
     public InsertFromLastVisitedStep(
         bool select = true,
@@ -21,38 +23,18 @@ public InsertFromLastVisitedStep(
         : base(enabled)
     {
         Select = select;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Insert from Last Visited [ " + "Select: " + (Select ? "On" : "Off") + " ; " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new InsertFromLastVisitedStep(select_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertFromLastVisitedStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool select_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); select_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (!tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(tok)) { target = FieldRef.FromDisplayToken(tok); break; } }
-        return new InsertFromLastVisitedStep(select_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<InsertFromLastVisitedStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,24 +42,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-from-last-visited.html",
-        Params =
+        // Canonical 012-InsertFromLastVisited: only <SelectAll>; <Field> is
+        // omitted until a target is bound, so it is Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Select",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-            },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertFromUrlStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertFromUrlStep.cs
index 4467aba..8ab8003 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertFromUrlStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertFromUrlStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -18,6 +20,20 @@ public sealed class InsertFromUrlStep : ScriptStep, IStepFactory
     public Calculation? Url { get; set; }
     public Calculation? CurlOptions { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    /// <summary>
+    /// Emit-only projection of FileMaker's bare <c>&lt;Text/&gt;</c> marker,
+    /// written before <c>&lt;Field&gt;</c> when the target is a variable.
+    /// Declared as an explicit shape node (rather than
+    /// <c>FieldChild.VariableTextMarker</c>) so the canonical-shape validator
+    /// recognizes the marker element. Get-only, so the shape parser skips it.
+    /// </summary>
+    public bool TargetIsVariable => Target?.IsVariable == true;
+
+    private InsertFromUrlStep() : this(enabled: true) { }
+
     public InsertFromUrlStep(
         bool selectAll = true,
         bool withDialog = true,
@@ -38,29 +54,10 @@ public InsertFromUrlStep(
         CurlOptions = curlOptions;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            // NoInteract is inverted: state="True" suppresses the dialog
-            // (= With dialog: Off). state="False" shows it.
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("DontEncodeURL", new XAttribute("state", DontEncodeUrl ? "True" : "False")),
-            new XElement("SelectAll", new XAttribute("state", SelectAll ? "True" : "False")),
-            new XElement("VerifySSLCertificates", new XAttribute("state", VerifySslCertificates ? "True" : "False")));
-        if (CurlOptions is not null)
-            step.Add(new XElement("CURLOptions", CurlOptions.ToXml("Calculation")));
-        if (Url is not null) step.Add(Url.ToXml("Calculation"));
-        if (Target is not null)
-        {
-            if (Target.IsVariable) step.Add(new XElement("Text"));
-            step.Add(Target.ToXml("Field"));
-        }
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: bare "Select" presence token and conditional per-flag
+    // grammar the shape renderer cannot produce.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>();
@@ -74,22 +71,8 @@ public override string ToDisplayLine()
         return $"Insert from URL [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        // NoInteract inverted: state="True" = dialog suppressed = WithDialog: Off.
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var dontEncode = step.Element("DontEncodeURL")?.Attribute("state")?.Value == "True";
-        var selectAll = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var verify = step.Element("VerifySSLCertificates")?.Attribute("state")?.Value == "True";
-        var curlEl = step.Element("CURLOptions")?.Element("Calculation");
-        var curl = curlEl is not null ? Calculation.FromXml(curlEl) : null;
-        var urlEl = step.Element("Calculation");
-        var url = urlEl is not null ? Calculation.FromXml(urlEl) : null;
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new InsertFromUrlStep(selectAll, withDialog, verify, dontEncode, target, url, curl, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertFromUrlStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -131,15 +114,16 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-from-url.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "SelectAll", XmlElement = "SelectAll", XmlAttr = "state", Type = "boolean", HrLabel = "Select" },
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog", ValidValues = ["On", "Off"] },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "fieldOrVariable", HrLabel = "Target" },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation" },
-            new ParamMetadata { Name = "VerifySSLCertificates", XmlElement = "VerifySSLCertificates", XmlAttr = "state", Type = "boolean", HrLabel = "Verify SSL Certificates" },
-            new ParamMetadata { Name = "CURLOptions", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "cURL options" },
-            new ParamMetadata { Name = "DontEncodeURL", XmlElement = "DontEncodeURL", XmlAttr = "state", Type = "boolean" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog" },
+            new BoolStateChild("DontEncodeURL") { PocoProperty = "DontEncodeUrl", Display = DisplayMode.Augmented },
+            new BoolStateChild("SelectAll") { HrLabel = "Select" },
+            new BoolStateChild("VerifySSLCertificates") { PocoProperty = "VerifySslCertificates", HrLabel = "Verify SSL Certificates" },
+            new NamedCalcChild("CURLOptions") { PocoProperty = "CurlOptions", Optional = true, HrLabel = "cURL options" },
+            new BareCalcChild { PocoProperty = "Url", Optional = true },
+            new FlagChild("Text") { PocoProperty = "TargetIsVariable", Display = DisplayMode.Hidden },
+            new FieldChild { PocoProperty = "Target", Optional = true, HrLabel = "Target" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertPdfStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertPdfStep.cs
index cd83e77..0efd89a 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertPdfStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertPdfStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -18,6 +20,8 @@ public sealed class InsertPdfStep : ScriptStep, IStepFactory
     public string Path { get; set; }
     public string StorageType { get; set; }
 
+    private InsertPdfStep() : this("") { }
+
     public InsertPdfStep(string path = "", string storageType = "Embedded", bool enabled = true)
         : base(enabled)
     {
@@ -25,25 +29,15 @@ public InsertPdfStep(string path = "", string storageType = "Embedded", bool ena
         StorageType = storageType;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UniversalPathList", new XAttribute("type", StorageType), Path));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the single wire element splits into two display tokens
+    // (path text + type attribute) via HrOnly slots the renderer cannot drive.
     public override string ToDisplayLine() =>
         string.IsNullOrEmpty(Path) ? XmlName : $"Insert PDF [ {Path} ; {StorageType} ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var pathEl = step.Element("UniversalPathList");
-        return new InsertPdfStep(
-            pathEl?.Value ?? "",
-            pathEl?.Attribute("type")?.Value ?? "Embedded",
-            enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertPdfStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -59,10 +53,22 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-pdf.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text" },
-            new ParamMetadata { Name = "StorageType", XmlElement = "UniversalPathList", XmlAttr = "type", Type = "enum", ValidValues = ["Embedded", "Reference"], DefaultValue = "Embedded" },
+            new NamedTextChild("UniversalPathList")
+            {
+                PocoProperty = "Path",
+                Attr = "type",
+                AttrProperty = "StorageType",
+                AttrDefault = "Embedded",
+                ValidValues = ["Embedded", "Reference"],
+                Display = DisplayMode.Hidden,
+            },
+            // The single wire element carries both the path text and the type
+            // attribute; these HR-only slots surface them as the two separate
+            // display tokens.
+            new HrOnly("UniversalPathList"),
+            new HrOnly("StorageType") { DisplayValues = ["Embedded", "Reference"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertPictureStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertPictureStep.cs
index 8967308..ee8f93f 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertPictureStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertPictureStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -16,6 +18,8 @@ public sealed class InsertPictureStep : ScriptStep, IStepFactory
     public string Path { get; set; }
     public string StorageType { get; set; }
 
+    private InsertPictureStep() : this("") { }
+
     public InsertPictureStep(string path = "", string storageType = "Embedded", bool enabled = true)
         : base(enabled)
     {
@@ -23,25 +27,15 @@ public InsertPictureStep(string path = "", string storageType = "Embedded", bool
         StorageType = storageType;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UniversalPathList", new XAttribute("type", StorageType), Path));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the single wire element splits into two display tokens
+    // (path text + type attribute) via HrOnly slots the renderer cannot drive.
     public override string ToDisplayLine() =>
         string.IsNullOrEmpty(Path) ? XmlName : $"Insert Picture [ {Path} ; {StorageType} ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var pathEl = step.Element("UniversalPathList");
-        return new InsertPictureStep(
-            pathEl?.Value ?? "",
-            pathEl?.Attribute("type")?.Value ?? "Embedded",
-            enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertPictureStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -57,10 +51,19 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-picture.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text" },
-            new ParamMetadata { Name = "StorageType", XmlElement = "UniversalPathList", XmlAttr = "type", Type = "enum", ValidValues = ["Embedded", "Reference"], DefaultValue = "Embedded" },
+            new NamedTextChild("UniversalPathList")
+            {
+                PocoProperty = "Path",
+                Attr = "type",
+                AttrProperty = "StorageType",
+                AttrDefault = "Embedded",
+                ValidValues = ["Embedded", "Reference"],
+                Display = DisplayMode.Hidden,
+            },
+            new HrOnly("UniversalPathList"),
+            new HrOnly("StorageType") { DisplayValues = ["Embedded", "Reference"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InsertTextStep.cs b/src/SharpFM.Model/Scripting/Steps/InsertTextStep.cs
index 036eedd..a7da5f0 100644
--- a/src/SharpFM.Model/Scripting/Steps/InsertTextStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InsertTextStep.cs
@@ -1,14 +1,17 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
 /// <summary>
 /// Insert Text carries a literal <c>&lt;Text&gt;...&lt;/Text&gt;</c>
-/// (not a Calculation/CDATA block) and a dual-format Field target. The
-/// Text element is required.
+/// (not a Calculation/CDATA block) and a dual-format Field target. Both the
+/// Text content and the Field target are omitted from the unconfigured
+/// canonical form, so each is Optional.
 /// </summary>
 public sealed class InsertTextStep : ScriptStep, IStepFactory
 {
@@ -19,6 +22,8 @@ public sealed class InsertTextStep : ScriptStep, IStepFactory
     public FieldRef? Target { get; set; }
     public string Text { get; set; }
 
+    private InsertTextStep() : base(false) { Text = ""; }
+
     public InsertTextStep(bool selectAll = true, FieldRef? target = null, string text = "", bool enabled = true)
         : base(enabled)
     {
@@ -27,18 +32,10 @@ public InsertTextStep(bool selectAll = true, FieldRef? target = null, string tex
         Text = text;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", SelectAll ? "True" : "False")),
-            new XElement("Text", Text));
-        if (Target is not null) step.Add(Target.ToXml("Field"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: bare "Select" presence token and quoted text literal the
+    // shape renderer cannot produce.
     public override string ToDisplayLine()
     {
         var selectPart = SelectAll ? "Select ; " : "";
@@ -46,15 +43,8 @@ public override string ToDisplayLine()
         return $"Insert Text [ {selectPart}{targetPart}\"{Text}\" ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var selectAll = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var text = step.Element("Text")?.Value ?? "";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new InsertTextStep(selectAll, target, text, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InsertTextStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -86,11 +76,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/insert-text.html",
-        Params =
+        // Canonical 061-InsertText: only <SelectAll>; both <Text> and <Field>
+        // are omitted until configured, so both are Optional.
+        Shape =
         [
-            new ParamMetadata { Name = "SelectAll", XmlElement = "SelectAll", XmlAttr = "state", Type = "boolean", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "fieldOrVariable", HrLabel = "Target" },
-            new ParamMetadata { Name = "Text", XmlElement = "Text", Type = "text", Required = true },
+            new BoolStateChild("SelectAll") { PocoProperty = "SelectAll", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "True" },
+            new NamedTextChild("Text") { PocoProperty = "Text", Optional = true },
+            new FieldChild("Field") { PocoProperty = "Target", HrLabel = "Target", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InstallMenuSetStep.cs b/src/SharpFM.Model/Scripting/Steps/InstallMenuSetStep.cs
index 7107785..23b9fa3 100644
--- a/src/SharpFM.Model/Scripting/Steps/InstallMenuSetStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InstallMenuSetStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -10,9 +12,11 @@ public sealed class InstallMenuSetStep : ScriptStep, IStepFactory
     public const int XmlId = 142;
     public const string XmlName = "Install Menu Set";
 
-    public NamedRef MenuSet { get; set; }
+    public NamedRef MenuSet { get; set; } = new(0, "");
     public bool UseAsFileDefault { get; set; }
 
+    private InstallMenuSetStep() : base(false) { }
+
     public InstallMenuSetStep(NamedRef? menuSet = null, bool useAsFileDefault = false, bool enabled = true)
         : base(enabled)
     {
@@ -20,25 +24,14 @@ public InstallMenuSetStep(NamedRef? menuSet = null, bool useAsFileDefault = fals
         UseAsFileDefault = useAsFileDefault;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UseAsFileDefault", new XAttribute("state", UseAsFileDefault ? "True" : "False")),
-            MenuSet.ToXml("CustomMenuSet"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: quoted menu-set name token the shape renderer cannot produce.
     public override string ToDisplayLine() =>
         $"Install Menu Set [ \"{MenuSet.Name}\" ; Use as file default: {(UseAsFileDefault ? "On" : "Off")} ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var useDefault = step.Element("UseAsFileDefault")?.Attribute("state")?.Value == "True";
-        var menuEl = step.Element("CustomMenuSet");
-        var menu = menuEl is not null ? NamedRef.FromXml(menuEl) : new NamedRef(0, "");
-        return new InstallMenuSetStep(menu, useDefault, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InstallMenuSetStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -57,7 +50,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
                 var name = t;
                 if (name.StartsWith("\"") && name.EndsWith("\"") && name.Length >= 2)
                     name = name.Substring(1, name.Length - 2);
-                menu = new NamedRef(0, name);
+                // The built-in menu set has the fixed id 1; custom menu sets
+                // carry file-specific ids the canonical form wildcards.
+                menu = new NamedRef(name == "[Standard FileMaker Menus]" ? 1 : 0, name);
                 menuSeen = true;
             }
         }
@@ -70,19 +65,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/install-menu-set.html",
-        Params =
+        // Canonical: UseAsFileDefault, then the always-present CustomMenuSet ref.
+        Shape =
         [
-            new ParamMetadata { Name = "CustomMenuSet", XmlElement = "CustomMenuSet", Type = "menuSet", Required = true },
-            new ParamMetadata
-            {
-                Name = "UseAsFileDefault",
-                XmlElement = "UseAsFileDefault",
-                XmlAttr = "state",
-                Type = "boolean",
-                HrLabel = "Use as file default",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
+            new BoolStateChild("UseAsFileDefault") { PocoProperty = "UseAsFileDefault", HrLabel = "Use as file default", Display = DisplayMode.Augmented },
+            new NamedRefChild("CustomMenuSet") { PocoProperty = "MenuSet", Required = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InstallOnTimerScriptStep.cs b/src/SharpFM.Model/Scripting/Steps/InstallOnTimerScriptStep.cs
index 09997a6..12532f4 100644
--- a/src/SharpFM.Model/Scripting/Steps/InstallOnTimerScriptStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InstallOnTimerScriptStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -18,6 +20,8 @@ public sealed class InstallOnTimerScriptStep : ScriptStep, IStepFactory
     public NamedRef? Script { get; set; }
     public Calculation? Interval { get; set; }
 
+    private InstallOnTimerScriptStep() : base(false) { }
+
     public InstallOnTimerScriptStep(NamedRef? script = null, Calculation? interval = null, bool enabled = true)
         : base(enabled)
     {
@@ -25,17 +29,10 @@ public InstallOnTimerScriptStep(NamedRef? script = null, Calculation? interval =
         Interval = interval;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        if (Script is not null) step.Add(Script.ToXml("Script"));
-        if (Interval is not null) step.Add(new XElement("Interval", Interval.ToXml("Calculation")));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: quoted "script name" and <no script> placeholder grammar
+    // the shape renderer cannot produce.
     public override string ToDisplayLine()
     {
         var script = Script is null ? "<no script>" : $"\"{Script.Name}\"";
@@ -44,15 +41,8 @@ public override string ToDisplayLine()
             : $"Install OnTimer Script [ {script} ; Interval: {Interval.Text} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var scriptEl = step.Element("Script");
-        var script = scriptEl is not null ? NamedRef.FromXml(scriptEl) : null;
-        var intervalEl = step.Element("Interval")?.Element("Calculation");
-        var interval = intervalEl is not null ? Calculation.FromXml(intervalEl) : null;
-        return new InstallOnTimerScriptStep(script, interval, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InstallOnTimerScriptStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -84,10 +74,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/install-ontimer-script.html",
-        Params =
+        // Canonical §8.1: element order Interval -> Script (the §7.3 trap is the
+        // interval being wrapped in <Interval>, which NamedCalcChild guarantees).
+        // Both are optional — the cancel-all form has neither child.
+        Shape =
         [
-            new ParamMetadata { Name = "Script", XmlElement = "Script", Type = "script" },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Interval" },
+            new NamedCalcChild("Interval") { PocoProperty = "Interval", HrLabel = "Interval", Optional = true, Display = DisplayMode.Augmented },
+            new NamedRefChild("Script") { PocoProperty = "Script", Optional = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/InstallPlugInFileStep.cs b/src/SharpFM.Model/Scripting/Steps/InstallPlugInFileStep.cs
index 7b7a119..47d4465 100644
--- a/src/SharpFM.Model/Scripting/Steps/InstallPlugInFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/InstallPlugInFileStep.cs
@@ -1,7 +1,7 @@
-using System;
-using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,41 +11,28 @@ public sealed class InstallPlugInFileStep : ScriptStep, IStepFactory
     public const int XmlId = 157;
     public const string XmlName = "Install Plug-In File";
 
-    public FieldRef Target { get; set; }
+    // Nullable so the unconfigured form (no Field) omits the optional <Field> node.
+    public FieldRef? Target { get; set; }
+
+    private InstallPlugInFileStep() : base(false) { }
 
     public InstallPlugInFileStep(
         FieldRef? target = null,
         bool enabled = true)
         : base(enabled)
     {
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Install Plug-In File [ " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new InstallPlugInFileStep(target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<InstallPlugInFileStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (true && !string.IsNullOrWhiteSpace(tok)) { target = FieldRef.FromDisplayToken(tok); break; } }
-        return new InstallPlugInFileStep(target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<InstallPlugInFileStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -53,14 +40,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/install-plug-in-file.html",
-        Params =
+        // The target Field is omitted by the unconfigured form (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-            },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ModifyLastFindStep.cs b/src/SharpFM.Model/Scripting/Steps/ModifyLastFindStep.cs
index 1630443..d28423f 100644
--- a/src/SharpFM.Model/Scripting/Steps/ModifyLastFindStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ModifyLastFindStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class ModifyLastFindStep : ScriptStep, IStepFactory
     public const int XmlId = 24;
     public const string XmlName = "Modify Last Find";
 
+    private ModifyLastFindStep() : base(false) { }
+
     public ModifyLastFindStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ModifyLastFindStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ModifyLastFindStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new ModifyLastFindStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ModifyLastFindStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/MoveResizeWindowStep.cs b/src/SharpFM.Model/Scripting/Steps/MoveResizeWindowStep.cs
index 1e5bccf..6e084ee 100644
--- a/src/SharpFM.Model/Scripting/Steps/MoveResizeWindowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/MoveResizeWindowStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,13 +14,15 @@ public sealed class MoveResizeWindowStep : ScriptStep, IStepFactory
     public const int XmlId = 119;
     public const string XmlName = "Move/Resize Window";
 
-    public string Window { get; set; }
-    public Calculation Name { get; set; }
+    public string Window { get; set; } = "ByName";
+    public Calculation Name { get; set; } = new("");
     public bool CurrentFile { get; set; }
-    public Calculation Height { get; set; }
-    public Calculation Width { get; set; }
-    public Calculation Top { get; set; }
-    public Calculation Left { get; set; }
+    public Calculation Height { get; set; } = new("");
+    public Calculation Width { get; set; } = new("");
+    public Calculation Top { get; set; } = new("");
+    public Calculation Left { get; set; } = new("");
+
+    private MoveResizeWindowStep() : base(false) { }
 
     public MoveResizeWindowStep(
         string window = "ByName",
@@ -40,76 +44,15 @@ public MoveResizeWindowStep(
         Left = left ?? new Calculation("");
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _WindowToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal) {
-        ["ByName"] = "ByName",
-        ["Current"] = "Current Window",
-    };
-    private static readonly IReadOnlyDictionary<string, string> _WindowFromHr =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {
-        ["ByName"] = "ByName",
-        ["Current Window"] = "Current",
-    };
-    private static string WindowHr(string x) => _WindowToHr.TryGetValue(x, out var h) ? h : x;
-    private static string WindowXml(string h) => _WindowFromHr.TryGetValue(h, out var x) ? x : h;
-
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Window", new XAttribute("value", Window)),
-            new XElement("Name", Name.ToXml("Calculation")),
-            new XElement("LimitToWindowsOfCurrentFile", new XAttribute("state", CurrentFile ? "True" : "False")),
-            new XElement("Height", Height.ToXml("Calculation")),
-            new XElement("Width", Width.ToXml("Calculation")),
-            new XElement("DistanceFromTop", Top.ToXml("Calculation")),
-            new XElement("DistanceFromLeft", Left.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Move/Resize Window [ " + WindowHr(Window) + " ; " + "Name: " + Name.Text + " ; " + "Current file: " + (CurrentFile ? "On" : "Off") + " ; " + "Height: " + Height.Text + " ; " + "Width: " + Width.Text + " ; " + "Top: " + Top.Text + " ; " + "Left: " + Left.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var window_v = step.Element("Window")?.Attribute("value")?.Value ?? "ByName";
-        var name_vWrapEl = step.Element("Name");
-        var name_vCalcEl = name_vWrapEl?.Element("Calculation");
-        var name_v = name_vCalcEl is not null ? Calculation.FromXml(name_vCalcEl) : new Calculation("");
-        var currentFile_v = step.Element("LimitToWindowsOfCurrentFile")?.Attribute("state")?.Value == "True";
-        var height_vWrapEl = step.Element("Height");
-        var height_vCalcEl = height_vWrapEl?.Element("Calculation");
-        var height_v = height_vCalcEl is not null ? Calculation.FromXml(height_vCalcEl) : new Calculation("");
-        var width_vWrapEl = step.Element("Width");
-        var width_vCalcEl = width_vWrapEl?.Element("Calculation");
-        var width_v = width_vCalcEl is not null ? Calculation.FromXml(width_vCalcEl) : new Calculation("");
-        var top_vWrapEl = step.Element("DistanceFromTop");
-        var top_vCalcEl = top_vWrapEl?.Element("Calculation");
-        var top_v = top_vCalcEl is not null ? Calculation.FromXml(top_vCalcEl) : new Calculation("");
-        var left_vWrapEl = step.Element("DistanceFromLeft");
-        var left_vCalcEl = left_vWrapEl?.Element("Calculation");
-        var left_v = left_vCalcEl is not null ? Calculation.FromXml(left_vCalcEl) : new Calculation("");
-        return new MoveResizeWindowStep(window_v, name_v, currentFile_v, height_v, width_v, top_v, left_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<MoveResizeWindowStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        string window_v = "ByName";
-        Calculation? name_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Name:", StringComparison.OrdinalIgnoreCase)) { name_v = new Calculation(tok.Substring(5).Trim()); break; } }
-        bool currentFile_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Current file:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(13).Trim(); currentFile_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        Calculation? height_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Height:", StringComparison.OrdinalIgnoreCase)) { height_v = new Calculation(tok.Substring(7).Trim()); break; } }
-        Calculation? width_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Width:", StringComparison.OrdinalIgnoreCase)) { width_v = new Calculation(tok.Substring(6).Trim()); break; } }
-        Calculation? top_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Top:", StringComparison.OrdinalIgnoreCase)) { top_v = new Calculation(tok.Substring(4).Trim()); break; } }
-        Calculation? left_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Left:", StringComparison.OrdinalIgnoreCase)) { left_v = new Calculation(tok.Substring(5).Trim()); break; } }
-        return new MoveResizeWindowStep(window_v, name_v, currentFile_v, height_v, width_v, top_v, left_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<MoveResizeWindowStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -117,62 +60,19 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/move-resize-window.html",
-        Params =
+        // Canonical: LimitToWindowsOfCurrentFile leads, then Window, then the
+        // optional Name and geometry calculations (omitted when unconfigured).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Window",
-                XmlElement = "Window",
-                Type = "enum",
-                XmlAttr = "value",
-                ValidValues = ["ByName", "Current Window"],
-                DefaultValue = "ByName",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Name",
-            },
-            new ParamMetadata
-            {
-                Name = "LimitToWindowsOfCurrentFile",
-                XmlElement = "LimitToWindowsOfCurrentFile",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Current file",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Height",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Width",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Top",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Left",
-            },
+            // Native slots (Window, Name) lead the display line; Augmented
+            // (Current file, geometry) follow in shape order — XML order unchanged.
+            new BoolStateChild("LimitToWindowsOfCurrentFile") { PocoProperty = "CurrentFile", HrLabel = "Current file", Display = DisplayMode.Augmented },
+            new EnumValueChild("Window") { PocoProperty = "Window", DefaultValue = "ByName", ValidValues = ["ByName", "Current"], DisplayValues = ["ByName", "Current Window"], Display = DisplayMode.Native },
+            new NamedCalcChild("Name") { PocoProperty = "Name", HrLabel = "Name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new NamedCalcChild("Height") { PocoProperty = "Height", HrLabel = "Height", Optional = true, Display = DisplayMode.Augmented, DisplayEmptyAs = "" },
+            new NamedCalcChild("Width") { PocoProperty = "Width", HrLabel = "Width", Optional = true, Display = DisplayMode.Augmented, DisplayEmptyAs = "" },
+            new NamedCalcChild("DistanceFromTop") { PocoProperty = "Top", HrLabel = "Top", Optional = true, Display = DisplayMode.Augmented, DisplayEmptyAs = "" },
+            new NamedCalcChild("DistanceFromLeft") { PocoProperty = "Left", HrLabel = "Left", Optional = true, Display = DisplayMode.Augmented, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/NewFileStep.cs b/src/SharpFM.Model/Scripting/Steps/NewFileStep.cs
index b265b86..b211d3e 100644
--- a/src/SharpFM.Model/Scripting/Steps/NewFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/NewFileStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class NewFileStep : ScriptStep, IStepFactory
     public const int XmlId = 82;
     public const string XmlName = "New File";
 
+    private NewFileStep() : base(false) { }
+
     public NewFileStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new NewFileStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<NewFileStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new NewFileStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<NewFileStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/NewRecordRequestStep.cs b/src/SharpFM.Model/Scripting/Steps/NewRecordRequestStep.cs
index 11171e9..7edabca 100644
--- a/src/SharpFM.Model/Scripting/Steps/NewRecordRequestStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/NewRecordRequestStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class NewRecordRequestStep : ScriptStep, IStepFactory
     public const int XmlId = 7;
     public const string XmlName = "New Record/Request";
 
+    private NewRecordRequestStep() : base(false) { }
+
     public NewRecordRequestStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new NewRecordRequestStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<NewRecordRequestStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new NewRecordRequestStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<NewRecordRequestStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/NewWindowStep.cs b/src/SharpFM.Model/Scripting/Steps/NewWindowStep.cs
index 5b48feb..eb594cd 100644
--- a/src/SharpFM.Model/Scripting/Steps/NewWindowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/NewWindowStep.cs
@@ -1,111 +1,68 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
+/// <summary>
+/// New Window (122). Canonical form (skill, windows reference): <c>LayoutDestination</c>,
+/// then the optional window <c>Name</c> and the optional dimension calculations
+/// (<c>Height</c>, <c>Width</c>, <c>DistanceFromTop</c>, <c>DistanceFromLeft</c>),
+/// then the always-present <c>NewWndStyles</c> attribute element (driven by the
+/// <see cref="NewWindowStyles"/> value type), then the optional target
+/// <c>Layout</c>. Unconfigured windows omit every optional child.
+/// </summary>
 public sealed class NewWindowStep : ScriptStep, IStepFactory
 {
     public const int XmlId = 122;
     public const string XmlName = "New Window";
 
-    public string LayoutDestination { get; set; }
-    public Calculation Calculation { get; set; }
-    public Calculation Calculation2 { get; set; }
-    public Calculation Calculation3 { get; set; }
-    public Calculation Calculation4 { get; set; }
-    public Calculation Calculation5 { get; set; }
-    public string NewWndStyles { get; set; }
+    public string LayoutDestination { get; set; } = "SelectedLayout";
+    public Calculation? Name { get; set; }
+    public Calculation? Height { get; set; }
+    public Calculation? Width { get; set; }
+    public Calculation? DistanceFromTop { get; set; }
+    public Calculation? DistanceFromLeft { get; set; }
+    public NewWindowStyles Styles { get; set; } = NewWindowStyles.Default();
+    public NamedRef? Layout { get; set; }
 
-    public NewWindowStep(
-        string layoutDestination = "SelectedLayout",
-        Calculation? calculation = null,
-        Calculation? calculation2 = null,
-        Calculation? calculation3 = null,
-        Calculation? calculation4 = null,
-        Calculation? calculation5 = null,
-        string newWndStyles = "",
-        bool enabled = true)
-        : base(enabled)
-    {
-        LayoutDestination = layoutDestination;
-        Calculation = calculation ?? new Calculation("");
-        Calculation2 = calculation2 ?? new Calculation("");
-        Calculation3 = calculation3 ?? new Calculation("");
-        Calculation4 = calculation4 ?? new Calculation("");
-        Calculation5 = calculation5 ?? new Calculation("");
-        NewWndStyles = newWndStyles;
-    }
+    private NewWindowStep() : base(false) { }
 
-    private static readonly IReadOnlyDictionary<string, string> _LayoutDestinationToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal) {
-        ["SelectedLayout"] = "SelectedLayout",
-    };
-    private static readonly IReadOnlyDictionary<string, string> _LayoutDestinationFromHr =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {
-        ["SelectedLayout"] = "SelectedLayout",
-    };
-    private static string LayoutDestinationHr(string x) => _LayoutDestinationToHr.TryGetValue(x, out var h) ? h : x;
-    private static string LayoutDestinationXml(string h) => _LayoutDestinationFromHr.TryGetValue(h, out var x) ? x : h;
+    public NewWindowStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("LayoutDestination", new XAttribute("value", LayoutDestination)),
-            new XElement("Name", Calculation.ToXml("Calculation")),
-            new XElement("Height", Calculation2.ToXml("Calculation")),
-            new XElement("Width", Calculation3.ToXml("Calculation")),
-            new XElement("DistanceFromTop", Calculation4.ToXml("Calculation")),
-            new XElement("DistanceFromLeft", Calculation5.ToXml("Calculation")),
-            new XElement("NewWndStyles", NewWndStyles));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "New Window [ " + LayoutDestinationHr(LayoutDestination) + " ; " + Calculation.Text + " ; " + Calculation2.Text + " ; " + Calculation3.Text + " ; " + Calculation4.Text + " ; " + Calculation5.Text + " ; " + NewWndStyles + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var layoutDestination_v = step.Element("LayoutDestination")?.Attribute("value")?.Value ?? "SelectedLayout";
-        var calculation_vWrapEl = step.Element("Name");
-        var calculation_vCalcEl = calculation_vWrapEl?.Element("Calculation");
-        var calculation_v = calculation_vCalcEl is not null ? Calculation.FromXml(calculation_vCalcEl) : new Calculation("");
-        var calculation2_vWrapEl = step.Element("Height");
-        var calculation2_vCalcEl = calculation2_vWrapEl?.Element("Calculation");
-        var calculation2_v = calculation2_vCalcEl is not null ? Calculation.FromXml(calculation2_vCalcEl) : new Calculation("");
-        var calculation3_vWrapEl = step.Element("Width");
-        var calculation3_vCalcEl = calculation3_vWrapEl?.Element("Calculation");
-        var calculation3_v = calculation3_vCalcEl is not null ? Calculation.FromXml(calculation3_vCalcEl) : new Calculation("");
-        var calculation4_vWrapEl = step.Element("DistanceFromTop");
-        var calculation4_vCalcEl = calculation4_vWrapEl?.Element("Calculation");
-        var calculation4_v = calculation4_vCalcEl is not null ? Calculation.FromXml(calculation4_vCalcEl) : new Calculation("");
-        var calculation5_vWrapEl = step.Element("DistanceFromLeft");
-        var calculation5_vCalcEl = calculation5_vWrapEl?.Element("Calculation");
-        var calculation5_v = calculation5_vCalcEl is not null ? Calculation.FromXml(calculation5_vCalcEl) : new Calculation("");
-        var newWndStyles_v = step.Element("NewWndStyles")?.Value ?? "";
-        return new NewWindowStep(layoutDestination_v, calculation_v, calculation2_v, calculation3_v, calculation4_v, calculation5_v, newWndStyles_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<NewWindowStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when state the display line cannot
+    /// carry is present: a target layout, window dimensions, a non-default
+    /// styles block, or a layout destination other than the unconfigured
+    /// <c>CurrentLayout</c> form the display parser reconstructs.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        LayoutDestination == "CurrentLayout"
+        && Layout is null
+        && Height is null && Width is null
+        && DistanceFromTop is null && DistanceFromLeft is null
+        && Styles == NewWindowStyles.Default();
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        string layoutDestination_v = "SelectedLayout";
-        Calculation? calculation_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation_v = new Calculation(tok); break; } }
-        Calculation? calculation2_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation2_v = new Calculation(tok); break; } }
-        Calculation? calculation3_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation3_v = new Calculation(tok); break; } }
-        Calculation? calculation4_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation4_v = new Calculation(tok); break; } }
-        Calculation? calculation5_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation5_v = new Calculation(tok); break; } }
-        string newWndStyles_v = "";
-        return new NewWindowStep(layoutDestination_v, calculation_v, calculation2_v, calculation3_v, calculation4_v, calculation5_v, newWndStyles_v, enabled);
+        // Hand-written: reconstructs the unconfigured LayoutDestination
+        // "CurrentLayout" wire form, which the shape parser cannot synthesize
+        // for a display-hidden slot; anything beyond a window name is sealed state.
+        var step = new NewWindowStep(enabled) { LayoutDestination = "CurrentLayout" };
+        var name = hrParams.Select(h => h.Trim()).FirstOrDefault(t => t.Length > 0);
+        if (!string.IsNullOrEmpty(name)) step.Name = new Calculation(name);
+        return step;
     }
 
     public static StepMetadata Metadata { get; } = new()
@@ -114,53 +71,18 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/new-window.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "LayoutDestination",
-                XmlElement = "LayoutDestination",
-                Type = "enum",
-                XmlAttr = "value",
-                ValidValues = ["SelectedLayout"],
-                DefaultValue = "SelectedLayout",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-            },
-            new ParamMetadata
-            {
-                Name = "NewWndStyles",
-                XmlElement = "NewWndStyles",
-                Type = "text",
-            },
+            new EnumValueChild("LayoutDestination") { PocoProperty = "LayoutDestination", DefaultValue = "SelectedLayout", Display = DisplayMode.Hidden },
+            // Name renders as a bare token; the geometry is sealed state the
+            // display line never carries (see IsFullyEditable).
+            new NamedCalcChild("Name") { PocoProperty = "Name", Optional = true, Display = DisplayMode.Native },
+            new NamedCalcChild("Height") { PocoProperty = "Height", HrLabel = "Height", Optional = true, Display = DisplayMode.Hidden },
+            new NamedCalcChild("Width") { PocoProperty = "Width", HrLabel = "Width", Optional = true, Display = DisplayMode.Hidden },
+            new NamedCalcChild("DistanceFromTop") { PocoProperty = "DistanceFromTop", HrLabel = "Top", Optional = true, Display = DisplayMode.Hidden },
+            new NamedCalcChild("DistanceFromLeft") { PocoProperty = "DistanceFromLeft", HrLabel = "Left", Optional = true, Display = DisplayMode.Hidden },
+            new ValueTypeChild("NewWndStyles") { PocoProperty = "Styles", Display = DisplayMode.Hidden },
+            new NamedRefChild("Layout") { PocoProperty = "Layout", Optional = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/OmitMultipleRecordsStep.cs b/src/SharpFM.Model/Scripting/Steps/OmitMultipleRecordsStep.cs
index 1c54aea..0e93154 100644
--- a/src/SharpFM.Model/Scripting/Steps/OmitMultipleRecordsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OmitMultipleRecordsStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,7 +15,17 @@ public sealed class OmitMultipleRecordsStep : ScriptStep, IStepFactory
     public const string XmlName = "Omit Multiple Records";
 
     public bool WithDialog { get; set; }
-    public Calculation Calculation { get; set; }
+    public Calculation? Calculation { get; set; }
+
+    /// <summary>
+    /// XML-facing inverse of <see cref="WithDialog"/>: canonical
+    /// <c>&lt;NoInteract state="…"/&gt;</c> suppresses the dialog, so it is the
+    /// negation of the display-facing flag. The shape binds this so the raw
+    /// state round-trips without re-applying the inversion.
+    /// </summary>
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+
+    private OmitMultipleRecordsStep() : base(false) { }
 
     public OmitMultipleRecordsStep(
         bool withDialog = true,
@@ -22,38 +34,18 @@ public OmitMultipleRecordsStep(
         : base(enabled)
     {
         WithDialog = withDialog;
-        Calculation = calculation ?? new Calculation("");
+        Calculation = calculation;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            Calculation.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Omit Multiple Records [ " + "With dialog: " + (WithDialog ? "On" : "Off") + " ; " + Calculation.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog_v = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var calculation_vEl = step.Element("Calculation");
-        var calculation_v = calculation_vEl is not null ? Calculation.FromXml(calculation_vEl) : new Calculation("");
-        return new OmitMultipleRecordsStep(withDialog_v, calculation_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<OmitMultipleRecordsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool withDialog_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(12).Trim(); withDialog_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        Calculation? calculation_v = null;
-        foreach (var tok in tokens) { if (!(tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase))) { calculation_v = new Calculation(tok); break; } }
-        return new OmitMultipleRecordsStep(withDialog_v, calculation_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OmitMultipleRecordsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -61,24 +53,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "found sets",
         HelpUrl = "https://help.claris.com/en/pro-help/content/omit-multiple-records.html",
-        Params =
+        // Canonical 026-OmitMultipleRecords: NoInteract (always present, the
+        // inverse of WithDialog) then a bare <Calculation> that is omitted when
+        // blank (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteract", HrLabel = "With dialog", DisplayInverted = true },
+            new BareCalcChild { PocoProperty = "Calculation", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/OmitRecordStep.cs b/src/SharpFM.Model/Scripting/Steps/OmitRecordStep.cs
index a88577c..99e5277 100644
--- a/src/SharpFM.Model/Scripting/Steps/OmitRecordStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OmitRecordStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OmitRecordStep : ScriptStep, IStepFactory
     public const int XmlId = 25;
     public const string XmlName = "Omit Record";
 
+    private OmitRecordStep() : base(false) { }
+
     public OmitRecordStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OmitRecordStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OmitRecordStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OmitRecordStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OmitRecordStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenDataFileStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenDataFileStep.cs
index 74197cc..8f3b3a5 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenDataFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenDataFileStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +15,8 @@ public sealed class OpenDataFileStep : ScriptStep, IStepFactory
     public string Path { get; set; }
     public FieldRef? Target { get; set; }
 
+    private OpenDataFileStep() : base(false) { Path = ""; }
+
     public OpenDataFileStep(string path = "", FieldRef? target = null, bool enabled = true)
         : base(enabled)
     {
@@ -20,51 +24,15 @@ public OpenDataFileStep(string path = "", FieldRef? target = null, bool enabled
         Target = target;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UniversalPathList", Path));
-        if (Target is not null) step.Add(Target.ToXml("Field"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        Target is null
-            ? $"Open Data File [ {Path} ]"
-            : $"Open Data File [ {Path} ; Target: {Target.ToDisplayString()} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var path = step.Element("UniversalPathList")?.Value ?? "";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new OpenDataFileStep(path, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<OpenDataFileStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        string path = "";
-        FieldRef? target = null;
-        bool pathSeen = false;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("Target:", StringComparison.OrdinalIgnoreCase))
-            {
-                target = FieldRef.FromDisplayToken(t.Substring(7).Trim());
-            }
-            else if (!pathSeen && !string.IsNullOrWhiteSpace(t))
-            {
-                path = t;
-                pathSeen = true;
-            }
-        }
-        return new OpenDataFileStep(path, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenDataFileStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -72,22 +40,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/open-data-file.html",
-        Params =
+        // Canonical unconfigured form is empty: path and target are omitted when absent.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "UniversalPathList",
-                XmlElement = "UniversalPathList",
-                Type = "text",
-                Required = true,
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-                HrLabel = "Target",
-            },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Required = true, Optional = true, DisplayEmptyAs = "" },
+            new FieldChild() { PocoProperty = "Target", HrLabel = "Target", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenEditSavedFindsStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenEditSavedFindsStep.cs
index 5f58294..77df315 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenEditSavedFindsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenEditSavedFindsStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenEditSavedFindsStep : ScriptStep, IStepFactory
     public const int XmlId = 149;
     public const string XmlName = "Open Edit Saved Finds";
 
+    private OpenEditSavedFindsStep() : base(false) { }
+
     public OpenEditSavedFindsStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenEditSavedFindsStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenEditSavedFindsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenEditSavedFindsStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenEditSavedFindsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenFavoritesStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenFavoritesStep.cs
index 76c1fcb..58649a7 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenFavoritesStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenFavoritesStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenFavoritesStep : ScriptStep, IStepFactory
     public const int XmlId = 183;
     public const string XmlName = "Open Favorites";
 
+    private OpenFavoritesStep() : base(false) { }
+
     public OpenFavoritesStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenFavoritesStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenFavoritesStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenFavoritesStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenFavoritesStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenFileOptionsStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenFileOptionsStep.cs
index 7a84ada..2778583 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenFileOptionsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenFileOptionsStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenFileOptionsStep : ScriptStep, IStepFactory
     public const int XmlId = 114;
     public const string XmlName = "Open File Options";
 
+    private OpenFileOptionsStep() : base(false) { }
+
     public OpenFileOptionsStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenFileOptionsStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenFileOptionsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenFileOptionsStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenFileOptionsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenFileStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenFileStep.cs
index d7797c3..81bfcdf 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenFileStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +15,8 @@ public sealed class OpenFileStep : ScriptStep, IStepFactory
     public bool OpenHidden { get; set; }
     public FileReference? File { get; set; }
 
+    private OpenFileStep() : base(false) { }
+
     public OpenFileStep(bool openHidden = false, FileReference? file = null, bool enabled = true)
         : base(enabled)
     {
@@ -20,16 +24,7 @@ public OpenFileStep(bool openHidden = false, FileReference? file = null, bool en
         File = file;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Option", new XAttribute("state", OpenHidden ? "True" : "False")));
-        if (File is not null) step.Add(File.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
     public override string ToDisplayLine()
     {
@@ -39,14 +34,8 @@ public override string ToDisplayLine()
             : $"Open File [ {hidden} ; {File.ToDisplayString()} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var hidden = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var fileEl = step.Element("FileReference");
-        var file = fileEl is not null ? FileReference.FromXml(fileEl) : null;
-        return new OpenFileStep(hidden, file, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<OpenFileStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -73,24 +62,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/open-file.html",
-        Params =
+        // Canonical: the Option (open hidden) toggle, then the optional
+        // FileReference which owns its own id/name/UniversalPathList shape.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Option",
-                XmlElement = "Option",
-                XmlAttr = "state",
-                Type = "boolean",
-                HrLabel = "Open hidden",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "FileReference",
-                XmlElement = "FileReference",
-                Type = "fileReference",
-            },
+            new BoolStateChild("Option") { PocoProperty = "OpenHidden", HrLabel = "Open hidden", Display = DisplayMode.Augmented },
+            new ValueTypeChild("FileReference") { PocoProperty = "File", Optional = true, Display = DisplayMode.Native },
         ],
         Notes = new StepNotes
         {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenFindReplaceStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenFindReplaceStep.cs
index 2bb40de..cf804aa 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenFindReplaceStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenFindReplaceStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenFindReplaceStep : ScriptStep, IStepFactory
     public const int XmlId = 129;
     public const string XmlName = "Open Find/Replace";
 
+    private OpenFindReplaceStep() : base(false) { }
+
     public OpenFindReplaceStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenFindReplaceStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenFindReplaceStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenFindReplaceStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenFindReplaceStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenHelpStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenHelpStep.cs
index 6953d01..5685375 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenHelpStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenHelpStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenHelpStep : ScriptStep, IStepFactory
     public const int XmlId = 32;
     public const string XmlName = "Open Help";
 
+    private OpenHelpStep() : base(false) { }
+
     public OpenHelpStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenHelpStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenHelpStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenHelpStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenHelpStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenHostsStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenHostsStep.cs
index 7f9ac61..0aa4f60 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenHostsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenHostsStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenHostsStep : ScriptStep, IStepFactory
     public const int XmlId = 118;
     public const string XmlName = "Open Hosts";
 
+    private OpenHostsStep() : base(false) { }
+
     public OpenHostsStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenHostsStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenHostsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenHostsStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenHostsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenManageContainersStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenManageContainersStep.cs
index 4046dea..af5f95f 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenManageContainersStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenManageContainersStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenManageContainersStep : ScriptStep, IStepFactory
     public const int XmlId = 156;
     public const string XmlName = "Open Manage Containers";
 
+    private OpenManageContainersStep() : base(false) { }
+
     public OpenManageContainersStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenManageContainersStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenManageContainersStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenManageContainersStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenManageContainersStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenManageDataSourcesStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenManageDataSourcesStep.cs
index e7ac8a9..b8d3cb6 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenManageDataSourcesStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenManageDataSourcesStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenManageDataSourcesStep : ScriptStep, IStepFactory
     public const int XmlId = 140;
     public const string XmlName = "Open Manage Data Sources";
 
+    private OpenManageDataSourcesStep() : base(false) { }
+
     public OpenManageDataSourcesStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenManageDataSourcesStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenManageDataSourcesStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenManageDataSourcesStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenManageDataSourcesStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenManageDatabaseStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenManageDatabaseStep.cs
index 18b4342..2fa9610 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenManageDatabaseStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenManageDatabaseStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenManageDatabaseStep : ScriptStep, IStepFactory
     public const int XmlId = 38;
     public const string XmlName = "Open Manage Database";
 
+    private OpenManageDatabaseStep() : base(false) { }
+
     public OpenManageDatabaseStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenManageDatabaseStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenManageDatabaseStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenManageDatabaseStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenManageDatabaseStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenManageLayoutsStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenManageLayoutsStep.cs
index b563018..bc384eb 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenManageLayoutsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenManageLayoutsStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenManageLayoutsStep : ScriptStep, IStepFactory
     public const int XmlId = 151;
     public const string XmlName = "Open Manage Layouts";
 
+    private OpenManageLayoutsStep() : base(false) { }
+
     public OpenManageLayoutsStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenManageLayoutsStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenManageLayoutsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenManageLayoutsStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenManageLayoutsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenManageThemesStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenManageThemesStep.cs
index 7ea65f2..3d48d57 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenManageThemesStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenManageThemesStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenManageThemesStep : ScriptStep, IStepFactory
     public const int XmlId = 165;
     public const string XmlName = "Open Manage Themes";
 
+    private OpenManageThemesStep() : base(false) { }
+
     public OpenManageThemesStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenManageThemesStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenManageThemesStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenManageThemesStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenManageThemesStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenManageValueListsStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenManageValueListsStep.cs
index d8fcfbf..5d7bbd2 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenManageValueListsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenManageValueListsStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenManageValueListsStep : ScriptStep, IStepFactory
     public const int XmlId = 112;
     public const string XmlName = "Open Manage Value Lists";
 
+    private OpenManageValueListsStep() : base(false) { }
+
     public OpenManageValueListsStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenManageValueListsStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenManageValueListsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenManageValueListsStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenManageValueListsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenPdfStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenPdfStep.cs
new file mode 100644
index 0000000..5b2a663
--- /dev/null
+++ b/src/SharpFM.Model/Scripting/Steps/OpenPdfStep.cs
@@ -0,0 +1,95 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Values;
+
+namespace SharpFM.Model.Scripting.Steps;
+
+/// <summary>
+/// Open PDF starts a multi-step PDF from an existing file. The
+/// <c>&lt;Option&gt;</c> toggle pairs with the optional
+/// <c>&lt;UniversalPathList&gt;</c>, and the <c>&lt;OpenPDFFile&gt;</c>
+/// wrapper carries the save type plus an optional open-password calculation.
+/// </summary>
+public sealed class OpenPdfStep : ScriptStep, IStepFactory
+{
+    public const int XmlId = 246;
+    public const string XmlName = "Open PDF";
+
+    public bool SpecifyFile { get; set; }
+    public string Path { get; set; } = "";
+    public string SaveType { get; set; } = "File";
+    public Calculation? OpenPassword { get; set; }
+
+    private OpenPdfStep() : base(false) { }
+
+    public OpenPdfStep(
+        bool specifyFile = false,
+        string path = "",
+        string saveType = "File",
+        Calculation? openPassword = null,
+        bool enabled = true)
+        : base(enabled)
+    {
+        SpecifyFile = specifyFile;
+        Path = path;
+        SaveType = saveType;
+        OpenPassword = openPassword;
+    }
+
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
+
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<OpenPdfStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when state the display line cannot
+    /// carry is present: an open-password calculation or a non-default save
+    /// type (the display shows only the path).
+    /// </summary>
+    public override bool IsFullyEditable => OpenPassword is null && SaveType == "File";
+
+    // Hand-written: derives the SpecifyFile toggle from the path's presence,
+    // a coupling the shape parser cannot express for a display-hidden slot.
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
+    {
+        string path = "";
+        foreach (var tok in hrParams)
+        {
+            var t = tok.Trim();
+            if (!string.IsNullOrWhiteSpace(t)) { path = t; break; }
+        }
+        return new OpenPdfStep(!string.IsNullOrEmpty(path), path, "File", null, enabled);
+    }
+
+    public static StepMetadata Metadata { get; } = new()
+    {
+        Name = XmlName,
+        Id = XmlId,
+        Category = "files",
+        HelpUrl = "https://help.claris.com/en/pro-help/content/open-pdf.html",
+        // Canonical: Option, the optional UniversalPathList, then the
+        // always-present OpenPDFFile wrapper holding the save type and the
+        // optional open-password calc.
+        Shape =
+        [
+            // The specify-file toggle never shows: the display line carries the
+            // bare path alone (its presence implies the toggle).
+            new BoolStateChild("Option") { PocoProperty = "SpecifyFile", Display = DisplayMode.Hidden },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Optional = true, Display = DisplayMode.Native },
+            new WrapperChild("OpenPDFFile",
+            [
+                new NamedTextChild("PDFSaveType") { PocoProperty = "SaveType", Required = true, DefaultValue = "File", Display = DisplayMode.Hidden },
+                new NamedCalcChild("OpenPassword") { PocoProperty = "OpenPassword", Optional = true, Display = DisplayMode.Hidden },
+            ]),
+            // The wrapper's save type / password surface as one opaque display
+            // slot, mirroring the legacy OpenPDFFile param.
+            new HrOnly("OpenPDFFile"),
+        ],
+        FromXml = FromXml,
+        FromDisplay = FromDisplayParams,
+    };
+}
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenRecordRequestStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenRecordRequestStep.cs
index a94771c..b3c7445 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenRecordRequestStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenRecordRequestStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenRecordRequestStep : ScriptStep, IStepFactory
     public const int XmlId = 133;
     public const string XmlName = "Open Record/Request";
 
+    private OpenRecordRequestStep() : base(false) { }
+
     public OpenRecordRequestStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenRecordRequestStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenRecordRequestStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenRecordRequestStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenRecordRequestStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenScriptWorkspaceStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenScriptWorkspaceStep.cs
index 530a0d9..f45b5c6 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenScriptWorkspaceStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenScriptWorkspaceStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenScriptWorkspaceStep : ScriptStep, IStepFactory
     public const int XmlId = 88;
     public const string XmlName = "Open Script Workspace";
 
+    private OpenScriptWorkspaceStep() : base(false) { }
+
     public OpenScriptWorkspaceStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenScriptWorkspaceStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenScriptWorkspaceStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenScriptWorkspaceStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenScriptWorkspaceStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenSettingsStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenSettingsStep.cs
index 9ffd999..653b1da 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenSettingsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenSettingsStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenSettingsStep : ScriptStep, IStepFactory
     public const int XmlId = 105;
     public const string XmlName = "Open Settings";
 
+    private OpenSettingsStep() : base(false) { }
+
     public OpenSettingsStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenSettingsStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenSettingsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenSettingsStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenSettingsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenSharingStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenSharingStep.cs
index 7db1e66..ef10c25 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenSharingStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenSharingStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenSharingStep : ScriptStep, IStepFactory
     public const int XmlId = 113;
     public const string XmlName = "Open Sharing";
 
+    private OpenSharingStep() : base(false) { }
+
     public OpenSharingStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenSharingStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenSharingStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenSharingStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenSharingStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenTransactionStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenTransactionStep.cs
index d60a86d..3e2c725 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenTransactionStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenTransactionStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -26,91 +28,48 @@ public sealed class OpenTransactionStep : ScriptStep, IStepFactory
     public bool SkipAutoEnterOptions { get; set; }
     public bool SkipDataEntryValidation { get; set; }
     public bool OverrideESSLockingConflicts { get; set; }
+    public bool RestoreState { get; set; }
+
+    private OpenTransactionStep() : base(false) { }
 
     public OpenTransactionStep(
         bool skipAutoEnterOptions = false,
         bool skipDataEntryValidation = false,
         bool overrideESSLockingConflicts = false,
+        bool restoreState = false,
         bool enabled = true)
         : base(enabled)
     {
         SkipAutoEnterOptions = skipAutoEnterOptions;
         SkipDataEntryValidation = skipDataEntryValidation;
         OverrideESSLockingConflicts = overrideESSLockingConflicts;
+        RestoreState = restoreState;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SkipAutoEntry", new XAttribute("state", SkipAutoEnterOptions ? "True" : "False")),
-            new XElement("Option", new XAttribute("state", SkipDataEntryValidation ? "True" : "False")),
-            new XElement("ESSForceCommit", new XAttribute("state", OverrideESSLockingConflicts ? "True" : "False")));
-
-    public override string ToDisplayLine() =>
-        "Open Transaction [ "
-        + "Skip auto-enter options: " + (SkipAutoEnterOptions ? "On" : "Off")
-        + " ; Skip data entry validation: " + (SkipDataEntryValidation ? "On" : "Off")
-        + " ; Override ESS locking conflicts: " + (OverrideESSLockingConflicts ? "On" : "Off")
-        + " ]";
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var a = step.Element("SkipAutoEntry")?.Attribute("state")?.Value == "True";
-        var b = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var c = step.Element("ESSForceCommit")?.Attribute("state")?.Value == "True";
-        return new OpenTransactionStep(a, b, c, enabled);
-    }
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool a = ParseLabeled(tokens, "Skip auto-enter options:");
-        bool b = ParseLabeled(tokens, "Skip data entry validation:");
-        bool c = ParseLabeled(tokens, "Override ESS locking conflicts:");
-        return new OpenTransactionStep(a, b, c, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<OpenTransactionStep>(step, Metadata);
 
-    private static bool ParseLabeled(string[] tokens, string prefix)
-    {
-        foreach (var tok in tokens)
-        {
-            if (tok.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
-            {
-                var v = tok.Substring(prefix.Length).Trim();
-                return v.Equals("On", StringComparison.OrdinalIgnoreCase);
-            }
-        }
-        return false;
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenTransactionStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "control",
-        Params =
+        // Canonical order: Option, ESSForceCommit, SkipAutoEntry, Restore.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SkipAutoEntry", XmlElement = "SkipAutoEntry", Type = "boolean",
-                XmlAttr = "state", HrLabel = "Skip auto-enter options",
-                ValidValues = ["On", "Off"], DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Option", XmlElement = "Option", Type = "boolean",
-                XmlAttr = "state", HrLabel = "Skip data entry validation",
-                ValidValues = ["On", "Off"], DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "ESSForceCommit", XmlElement = "ESSForceCommit", Type = "boolean",
-                XmlAttr = "state", HrLabel = "Override ESS locking conflicts",
-                ValidValues = ["On", "Off"], DefaultValue = "False",
-            },
+            new BoolStateChild("Option") { PocoProperty = "SkipDataEntryValidation", HrLabel = "Skip data entry validation", Display = DisplayMode.Augmented },
+            new BoolStateChild("ESSForceCommit") { PocoProperty = "OverrideESSLockingConflicts", HrLabel = "Override ESS locking conflicts", Display = DisplayMode.Augmented },
+            // Native so the auto-enter token leads the display line (shape order
+            // stays canonical for XML; Native slots render before Augmented).
+            new BoolStateChild("SkipAutoEntry") { PocoProperty = "SkipAutoEnterOptions", HrLabel = "Skip auto-enter options", Display = DisplayMode.Native },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreState", Display = DisplayMode.Hidden },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenURLStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenURLStep.cs
index d0ab560..d1437f1 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenURLStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenURLStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -14,7 +16,12 @@ public sealed class OpenURLStep : ScriptStep, IStepFactory
 
     public bool WithDialog { get; set; }
     public bool InExternalBrowser { get; set; }
-    public Calculation Calculation { get; set; }
+    public Calculation Calculation { get; set; } = new("");
+
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    private OpenURLStep() : base(false) { }
 
     public OpenURLStep(
         bool withDialog = true,
@@ -28,39 +35,15 @@ public OpenURLStep(
         Calculation = calculation ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("Option", new XAttribute("state", InExternalBrowser ? "True" : "False")),
-            Calculation.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Open URL [ " + "With dialog: " + (WithDialog ? "On" : "Off") + " ; " + "In external browser: " + (InExternalBrowser ? "On" : "Off") + " ; " + Calculation.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog_v = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var inExternalBrowser_v = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var calculation_vEl = step.Element("Calculation");
-        var calculation_v = calculation_vEl is not null ? Calculation.FromXml(calculation_vEl) : new Calculation("");
-        return new OpenURLStep(withDialog_v, inExternalBrowser_v, calculation_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<OpenURLStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool withDialog_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(12).Trim(); withDialog_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool inExternalBrowser_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("In external browser:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(20).Trim(); inExternalBrowser_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        Calculation? calculation_v = null;
-        foreach (var tok in tokens) { if (!(tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase) || tok.StartsWith("In external browser:", StringComparison.OrdinalIgnoreCase))) { calculation_v = new Calculation(tok); break; } }
-        return new OpenURLStep(withDialog_v, inExternalBrowser_v, calculation_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenURLStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -68,34 +51,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/open-url.html",
-        Params =
+        // Canonical: NoInteract, Option, then the URL Calculation which the
+        // unconfigured form omits (Optional). <NoInteract state> inverts WithDialog.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Option",
-                XmlElement = "Option",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "In external browser",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", Display = DisplayMode.Augmented, DisplayInverted = true },
+            new BoolStateChild("Option") { PocoProperty = "InExternalBrowser", HrLabel = "In external browser", Display = DisplayMode.Augmented },
+            new BareCalcChild { PocoProperty = "Calculation", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/OpenUploadToHostStep.cs b/src/SharpFM.Model/Scripting/Steps/OpenUploadToHostStep.cs
index e4e2a46..09b84c7 100644
--- a/src/SharpFM.Model/Scripting/Steps/OpenUploadToHostStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/OpenUploadToHostStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class OpenUploadToHostStep : ScriptStep, IStepFactory
     public const int XmlId = 172;
     public const string XmlName = "Open Upload to Host";
 
+    private OpenUploadToHostStep() : base(false) { }
+
     public OpenUploadToHostStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new OpenUploadToHostStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<OpenUploadToHostStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new OpenUploadToHostStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<OpenUploadToHostStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/PasteStep.cs b/src/SharpFM.Model/Scripting/Steps/PasteStep.cs
index 8383d4d..a38a73d 100644
--- a/src/SharpFM.Model/Scripting/Steps/PasteStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PasteStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -14,7 +16,9 @@ public sealed class PasteStep : ScriptStep, IStepFactory
     public bool Select { get; set; }
     public bool NoStyle { get; set; }
     public bool LinkIfAvailable { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    private PasteStep() : base(false) { }
 
     public PasteStep(
         bool select = false,
@@ -27,46 +31,18 @@ public PasteStep(
         Select = select;
         NoStyle = noStyle;
         LinkIfAvailable = linkIfAvailable;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SelectAll", new XAttribute("state", Select ? "True" : "False")),
-            new XElement("NoStyle", new XAttribute("state", NoStyle ? "True" : "False")),
-            new XElement("LinkAvail", new XAttribute("state", LinkIfAvailable ? "True" : "False")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Paste [ " + "Select: " + (Select ? "On" : "Off") + " ; " + "No style: " + (NoStyle ? "On" : "Off") + " ; " + "Link if available: " + (LinkIfAvailable ? "On" : "Off") + " ; " + "Table::Field: " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var select_v = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var noStyle_v = step.Element("NoStyle")?.Attribute("state")?.Value == "True";
-        var linkIfAvailable_v = step.Element("LinkAvail")?.Attribute("state")?.Value == "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new PasteStep(select_v, noStyle_v, linkIfAvailable_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<PasteStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool select_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Select:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); select_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool noStyle_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("No style:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(9).Trim(); noStyle_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool linkIfAvailable_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Link if available:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(18).Trim(); linkIfAvailable_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (tok.StartsWith("Table::Field:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(13).Trim(); target = FieldRef.FromDisplayToken(v); break; } }
-        return new PasteStep(select_v, noStyle_v, linkIfAvailable_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<PasteStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -74,45 +50,16 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "editing",
         HelpUrl = "https://help.claris.com/en/pro-help/content/paste.html",
-        Params =
+        // Canonical 048-Paste child order is NoStyle, SelectAll, LinkAvail;
+        // <Field> follows and is omitted until a target is bound (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SelectAll",
-                XmlElement = "SelectAll",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "Select",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "NoStyle",
-                XmlElement = "NoStyle",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "No style",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "LinkAvail",
-                XmlElement = "LinkAvail",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "Link if available",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-                HrLabel = "Table::Field",
-            },
+            // Select leads the display line (Native renders before Augmented)
+            // while shape order stays the canonical NoStyle, SelectAll, LinkAvail.
+            new BoolStateChild("NoStyle") { PocoProperty = "NoStyle", HrLabel = "No style", ValidValues = ["On", "Off"], DefaultValue = "False", Display = DisplayMode.Augmented },
+            new BoolStateChild("SelectAll") { PocoProperty = "Select", HrLabel = "Select", ValidValues = ["On", "Off"], DefaultValue = "False", Display = DisplayMode.Native },
+            new BoolStateChild("LinkAvail") { PocoProperty = "LinkIfAvailable", HrLabel = "Link if available", ValidValues = ["On", "Off"], DefaultValue = "False", Display = DisplayMode.Augmented },
+            new FieldChild("Field") { PocoProperty = "Target", HrLabel = "Table::Field", Optional = true, Display = DisplayMode.Augmented, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PauseResumeScriptStep.cs b/src/SharpFM.Model/Scripting/Steps/PauseResumeScriptStep.cs
index 6963fb0..31a6e9d 100644
--- a/src/SharpFM.Model/Scripting/Steps/PauseResumeScriptStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PauseResumeScriptStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,7 +15,9 @@ public sealed class PauseResumeScriptStep : ScriptStep, IStepFactory
     public const string XmlName = "Pause/Resume Script";
 
     public string PauseTime { get; set; }
-    public Calculation DurationSeconds { get; set; }
+    public Calculation? DurationSeconds { get; set; }
+
+    private PauseResumeScriptStep() : base(false) { PauseTime = "ForDuration"; }
 
     public PauseResumeScriptStep(
         string pauseTime = "ForDuration",
@@ -22,50 +26,18 @@ public PauseResumeScriptStep(
         : base(enabled)
     {
         PauseTime = pauseTime;
-        DurationSeconds = durationSeconds ?? new Calculation("");
+        DurationSeconds = durationSeconds;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _PauseTimeToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal) {
-        ["Indefinitely"] = "Indefinitely",
-        ["ForDuration"] = "Duration (seconds)",
-    };
-    private static readonly IReadOnlyDictionary<string, string> _PauseTimeFromHr =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {
-        ["Indefinitely"] = "Indefinitely",
-        ["Duration (seconds)"] = "ForDuration",
-    };
-    private static string PauseTimeHr(string x) => _PauseTimeToHr.TryGetValue(x, out var h) ? h : x;
-    private static string PauseTimeXml(string h) => _PauseTimeFromHr.TryGetValue(h, out var x) ? x : h;
-
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("PauseTime", new XAttribute("value", PauseTime)),
-            DurationSeconds.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Pause/Resume Script [ " + PauseTimeHr(PauseTime) + " ; " + "Duration (seconds): " + DurationSeconds.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var pauseTime_v = step.Element("PauseTime")?.Attribute("value")?.Value ?? "ForDuration";
-        var durationSeconds_vEl = step.Element("Calculation");
-        var durationSeconds_v = durationSeconds_vEl is not null ? Calculation.FromXml(durationSeconds_vEl) : new Calculation("");
-        return new PauseResumeScriptStep(pauseTime_v, durationSeconds_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<PauseResumeScriptStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        string pauseTime_v = "ForDuration";
-        Calculation? durationSeconds_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Duration (seconds):", StringComparison.OrdinalIgnoreCase)) { durationSeconds_v = new Calculation(tok.Substring(19).Trim()); break; } }
-        return new PauseResumeScriptStep(pauseTime_v, durationSeconds_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<PauseResumeScriptStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -73,24 +45,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/pause-resume-script.html",
-        Params =
+        // Canonical 062-PauseResumeScript: only <PauseTime>; the bare
+        // <Calculation> duration is omitted when blank (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "PauseTime",
-                XmlElement = "PauseTime",
-                Type = "enum",
-                XmlAttr = "value",
-                ValidValues = ["Indefinitely", "Duration (seconds)"],
-                DefaultValue = "ForDuration",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                HrLabel = "Duration (seconds)",
-            },
+            new EnumValueChild("PauseTime") { PocoProperty = "PauseTime", DefaultValue = "ForDuration", ValidValues = ["Indefinitely", "ForDuration"], DisplayValues = ["Indefinitely", "Duration (seconds)"] },
+            new BareCalcChild { PocoProperty = "DurationSeconds", HrLabel = "Duration (seconds)", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformAppleScriptStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformAppleScriptStep.cs
index 7b78a0e..09825b7 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformAppleScriptStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformAppleScriptStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,9 +15,11 @@ public sealed class PerformAppleScriptStep : ScriptStep, IStepFactory
     public const string XmlName = "Perform AppleScript";
 
     public string ContentType { get; set; }
-    public Calculation Calculation { get; set; }
+    public Calculation? Calculation { get; set; }
     public string Text { get; set; }
 
+    private PerformAppleScriptStep() : base(false) { ContentType = "Calculation"; Text = ""; }
+
     public PerformAppleScriptStep(
         string contentType = "Calculation",
         Calculation? calculation = null,
@@ -24,54 +28,19 @@ public PerformAppleScriptStep(
         : base(enabled)
     {
         ContentType = contentType;
-        Calculation = calculation ?? new Calculation("");
+        Calculation = calculation;
         Text = text;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _ContentTypeToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal) {
-        ["Calculation"] = "Calculation",
-        ["Text"] = "Text",
-    };
-    private static readonly IReadOnlyDictionary<string, string> _ContentTypeFromHr =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {
-        ["Calculation"] = "Calculation",
-        ["Text"] = "Text",
-    };
-    private static string ContentTypeHr(string x) => _ContentTypeToHr.TryGetValue(x, out var h) ? h : x;
-    private static string ContentTypeXml(string h) => _ContentTypeFromHr.TryGetValue(h, out var x) ? x : h;
-
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ContentType", new XAttribute("value", ContentType)),
-            Calculation.ToXml("Calculation"),
-            new XElement("Text", Text));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Perform AppleScript [ " + ContentTypeHr(ContentType) + " ; " + Calculation.Text + " ; " + Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var contentType_v = step.Element("ContentType")?.Attribute("value")?.Value ?? "Calculation";
-        var calculation_vEl = step.Element("Calculation");
-        var calculation_v = calculation_vEl is not null ? Calculation.FromXml(calculation_vEl) : new Calculation("");
-        var text_v = step.Element("Text")?.Value ?? "";
-        return new PerformAppleScriptStep(contentType_v, calculation_v, text_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<PerformAppleScriptStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        string contentType_v = "Calculation";
-        Calculation? calculation_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation_v = new Calculation(tok); break; } }
-        string text_v = "";
-        return new PerformAppleScriptStep(contentType_v, calculation_v, text_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<PerformAppleScriptStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -79,29 +48,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/perform-applescript-os-x.html",
-        Params =
+        // Canonical 067-PerformAppleScript: only <ContentType>; the bare
+        // <Calculation> and the <Text> element are omitted until configured,
+        // so both are Optional.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "ContentType",
-                XmlElement = "ContentType",
-                Type = "enum",
-                XmlAttr = "value",
-                ValidValues = ["Calculation", "Text"],
-                DefaultValue = "Calculation",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-            },
-            new ParamMetadata
-            {
-                Name = "Text",
-                XmlElement = "Text",
-                Type = "text",
-            },
+            new EnumValueChild("ContentType") { PocoProperty = "ContentType", DefaultValue = "Calculation", ValidValues = ["Calculation", "Text"], DisplayValues = ["Calculation", "Text"] },
+            new BareCalcChild { PocoProperty = "Calculation", Optional = true, DisplayEmptyAs = "" },
+            new NamedTextChild("Text") { PocoProperty = "Text", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformFindByNaturalLanguageStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformFindByNaturalLanguageStep.cs
index 37722cb..5b66cd7 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformFindByNaturalLanguageStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformFindByNaturalLanguageStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,35 +13,42 @@ public sealed class PerformFindByNaturalLanguageStep : ScriptStep, IStepFactory
 
     public StepChildBag Children { get; set; }
 
+    private PerformFindByNaturalLanguageStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public PerformFindByNaturalLanguageStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new PerformFindByNaturalLanguageStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<PerformFindByNaturalLanguageStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new PerformFindByNaturalLanguageStep(enabled: enabled);
+        StepDisplayParser.Parse<PerformFindByNaturalLanguageStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformFindReplaceStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformFindReplaceStep.cs
index de04149..b2b7a63 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformFindReplaceStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformFindReplaceStep.cs
@@ -1,6 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -16,10 +19,15 @@ public sealed class PerformFindReplaceStep : ScriptStep, IStepFactory
     public const string XmlName = "Perform Find/Replace";
 
     public bool WithDialog { get; set; }
-    public FindReplaceOperation Operation { get; set; }
-    public Calculation FindText { get; set; }
+    public FindReplaceOperation Operation { get; set; } = FindReplaceOperation.Default();
+    public Calculation FindText { get; set; } = new("");
     public Calculation? ReplaceText { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    private PerformFindReplaceStep() : base(false) { }
+
     public PerformFindReplaceStep(
         bool withDialog = true,
         FindReplaceOperation? operation = null,
@@ -34,20 +42,11 @@ public PerformFindReplaceStep(
         ReplaceText = replaceText;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            Operation.ToXml(),
-            new XElement("FindCalc", FindText.ToXml("Calculation")));
-        if (ReplaceText is not null)
-            step.Add(new XElement("ReplaceCalc", ReplaceText.ToXml("Calculation")));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the operation type lives inside a ValueTypeChild and the
+    // replace calc is a conditional positional token — variant grammar the
+    // shape renderer cannot express.
     public override string ToDisplayLine()
     {
         var opDisplay = Operation.Type switch
@@ -68,40 +67,53 @@ public override string ToDisplayLine()
         return $"Perform Find/Replace [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        // NoInteract inverted: state="True" = With dialog: Off
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var opEl = step.Element("FindReplaceOperation");
-        var op = opEl is not null ? FindReplaceOperation.FromXml(opEl) : FindReplaceOperation.Default();
-        var findEl = step.Element("FindCalc")?.Element("Calculation");
-        var find = findEl is not null ? Calculation.FromXml(findEl) : new Calculation("");
-        var replaceEl = step.Element("ReplaceCalc")?.Element("Calculation");
-        var replace = replaceEl is not null ? Calculation.FromXml(replaceEl) : null;
-        return new PerformFindReplaceStep(withDialog, op, find, replace, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<PerformFindReplaceStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when operation state the display
+    /// line cannot carry is present: match flags, a non-forward direction,
+    /// or non-default within/across scopes (the display shows only the
+    /// operation type).
+    /// </summary>
+    public override bool IsFullyEditable =>
+        Operation is { MatchWholeWords: false, MatchCase: false, Direction: "Forward", WithinOptions: "All", AcrossOptions: "All" };
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        // Display is lossy — operation flags like MatchCase can't be
-        // expressed in this short form.
+        // Display grammar: [ With dialog: On/Off ; find ; replace? ; operation ].
+        // The last positional token is the operation type; earlier positional
+        // tokens are the find and optional replace calcs.
         bool withDialog = true;
-        Calculation find = new("");
-        Calculation? replace = null;
-        int positional = 0;
+        var positional = new List<string>();
         foreach (var tok in hrParams)
         {
             var t = tok.Trim();
             if (t.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase))
                 withDialog = t.Substring(12).Trim().Equals("On", StringComparison.OrdinalIgnoreCase);
-            else if (!string.IsNullOrWhiteSpace(t))
+            else
+                positional.Add(t);
+        }
+
+        var opType = "FindNext";
+        if (positional.Count > 0)
+        {
+            opType = positional[^1] switch
             {
-                if (positional == 0) { find = new Calculation(t); positional++; }
-                else if (positional == 1) { replace = new Calculation(t); positional++; }
-            }
+                "Find Next" => "FindNext",
+                "Replace and Find" => "ReplaceAndFind",
+                "Replace" => "Replace",
+                "Replace All" => "ReplaceAll",
+                var other => other,
+            };
+            positional.RemoveAt(positional.Count - 1);
         }
-        return new PerformFindReplaceStep(withDialog, FindReplaceOperation.Default(), find, replace, enabled);
+
+        Calculation find = positional.Count > 0 ? new(positional[0]) : new("");
+        Calculation? replace = positional.Count > 1 ? new(positional[1]) : null;
+        // Canonical unconfigured operation flags; configured flags are sealed state.
+        var operation = new FindReplaceOperation(opType, "Forward", false, false, "All", "All");
+        return new PerformFindReplaceStep(withDialog, operation, find, replace, enabled);
     }
 
     public static StepMetadata Metadata { get; } = new()
@@ -110,12 +122,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "editing",
         HelpUrl = "https://help.claris.com/en/pro-help/content/perform-find-replace.html",
-        Params =
+        // Canonical: NoInteract (inverts WithDialog) then FindReplaceOperation;
+        // the FindCalc/ReplaceCalc wrappers are omitted when empty (Optional).
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "FindReplaceOperation", XmlElement = "FindReplaceOperation", Type = "complex", Required = true },
-            new ParamMetadata { Name = "FindCalc", XmlElement = "Calculation", Type = "namedCalc", Required = true },
-            new ParamMetadata { Name = "ReplaceCalc", XmlElement = "Calculation", Type = "namedCalc" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", Display = DisplayMode.Native },
+            new ValueTypeChild("FindReplaceOperation") { PocoProperty = "Operation", Display = DisplayMode.Native },
+            new NamedCalcChild("FindCalc") { PocoProperty = "FindText", Optional = true, Display = DisplayMode.Native },
+            new NamedCalcChild("ReplaceCalc") { PocoProperty = "ReplaceText", Optional = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformFindStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformFindStep.cs
index a53c72b..3973690 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformFindStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformFindStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,6 +14,15 @@ public sealed class PerformFindStep : ScriptStep, IStepFactory
     public bool RestoreStoredRequests { get; set; }
     public FindRequestList? Query { get; set; }
 
+    /// <summary>
+    /// Display edits are anchor-preserved when stored find requests are
+    /// present — the display line carries only the Restore flag, never the
+    /// <c>&lt;Query&gt;</c> request list.
+    /// </summary>
+    public override bool IsFullyEditable => Query is null;
+
+    private PerformFindStep() : base(false) { }
+
     public PerformFindStep(bool restoreStoredRequests = true, FindRequestList? query = null, bool enabled = true)
         : base(enabled)
     {
@@ -19,40 +30,15 @@ public PerformFindStep(bool restoreStoredRequests = true, FindRequestList? query
         Query = query;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Restore", new XAttribute("state", RestoreStoredRequests ? "True" : "False")));
-        if (Query is not null) step.Add(Query.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Perform Find [ Restore: {(RestoreStoredRequests ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var restore = step.Element("Restore")?.Attribute("state")?.Value == "True";
-        var qEl = step.Element("Query");
-        var q = qEl is not null ? FindRequestList.FromXml(qEl) : null;
-        return new PerformFindStep(restore, q, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<PerformFindStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        bool restore = true;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("Restore:", System.StringComparison.OrdinalIgnoreCase))
-                restore = t.Substring(8).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
-        }
-        return new PerformFindStep(restore, null, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<PerformFindStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,10 +46,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "found sets",
         HelpUrl = "https://help.claris.com/en/pro-help/content/perform-find.html",
-        Params =
+        // Canonical order: always-emitted <Restore state=.../>, then the
+        // <Query> request list only when the step carries stored requests.
+        Shape =
         [
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Query", XmlElement = "Query", Type = "findRequests" },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredRequests", HrLabel = "Restore", Display = DisplayMode.Native },
+            new ValueTypeChild("Query") { PocoProperty = "Query", Optional = true, Display = DisplayMode.Hidden },
+            new HrOnly("Restore") { Boolean = true },
+            new HrOnly("Query"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformJavaScriptInWebViewerStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformJavaScriptInWebViewerStep.cs
index fb3cec0..879acfb 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformJavaScriptInWebViewerStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformJavaScriptInWebViewerStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -18,8 +20,10 @@ public sealed class PerformJavaScriptInWebViewerStep : ScriptStep, IStepFactory
     public const string XmlName = "Perform JavaScript in Web Viewer";
 
     public Calculation? ObjectName { get; set; }
-    public Calculation FunctionName { get; set; }
-    public IReadOnlyList<Calculation> Parameters { get; set; }
+    public Calculation? FunctionName { get; set; }
+    public IReadOnlyList<Calculation> Parameters { get; set; } = new List<Calculation>();
+
+    private PerformJavaScriptInWebViewerStep() : base(false) { }
 
     public PerformJavaScriptInWebViewerStep(
         Calculation? objectName = null,
@@ -29,55 +33,32 @@ public PerformJavaScriptInWebViewerStep(
         : base(enabled)
     {
         ObjectName = objectName;
-        FunctionName = functionName ?? new Calculation("\"\"");
+        FunctionName = functionName;
         Parameters = parameters ?? new List<Calculation>();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        if (ObjectName is not null) step.Add(new XElement("ObjectName", ObjectName.ToXml("Calculation")));
-        step.Add(new XElement("FunctionName", FunctionName.ToXml("Calculation")));
-        if (Parameters.Count > 0)
-        {
-            var parameters = new XElement("Parameters", new XAttribute("Count", Parameters.Count));
-            foreach (var p in Parameters)
-                parameters.Add(new XElement("P", p.ToXml("Calculation")));
-            step.Add(parameters);
-        }
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the unconfigured form renders empty brackets and the
+    // parameter list joins as one comma-separated token — forms the shape
+    // display engine cannot express.
     public override string ToDisplayLine()
     {
         var parts = new List<string>();
         if (ObjectName is not null) parts.Add($"Object Name: {ObjectName.Text}");
-        parts.Add($"Function Name: {FunctionName.Text}");
+        if (FunctionName is not null) parts.Add($"Function Name: {FunctionName.Text}");
         if (Parameters.Count > 0)
             parts.Add($"Parameters: {string.Join(", ", Parameters.Select(p => p.Text))}");
         return $"Perform JavaScript in Web Viewer [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var objEl = step.Element("ObjectName")?.Element("Calculation");
-        var obj = objEl is not null ? Calculation.FromXml(objEl) : null;
-        var fnEl = step.Element("FunctionName")?.Element("Calculation");
-        var fn = fnEl is not null ? Calculation.FromXml(fnEl) : new Calculation("\"\"");
-        var paramsList = step.Element("Parameters")?.Elements("P")
-            .Select(p => p.Element("Calculation") is { } c ? Calculation.FromXml(c) : new Calculation(""))
-            .ToList() ?? new List<Calculation>();
-        return new PerformJavaScriptInWebViewerStep(obj, fn, paramsList, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<PerformJavaScriptInWebViewerStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         Calculation? obj = null;
-        Calculation fn = new("\"\"");
+        Calculation? fn = null;
         List<Calculation> parameters = new();
         foreach (var tok in hrParams)
         {
@@ -102,11 +83,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/perform-javascript-in-web-viewer.html",
-        Params =
+        // Canonical unconfigured form is empty; ObjectName, FunctionName, and
+        // the <Parameters Count><P><Calculation> list (§7.2) are emitted only
+        // when set.
+        Shape =
         [
-            new ParamMetadata { Name = "ObjectName", XmlElement = "ObjectName", Type = "namedCalc", HrLabel = "Object Name" },
-            new ParamMetadata { Name = "FunctionName", XmlElement = "FunctionName", Type = "namedCalc", HrLabel = "Function Name", Required = true },
-            new ParamMetadata { Name = "Parameters", XmlElement = "Parameters", Type = "complex", HrLabel = "Parameters" },
+            new NamedCalcChild("ObjectName") { PocoProperty = "ObjectName", HrLabel = "Object Name", Optional = true, Display = DisplayMode.Augmented },
+            new NamedCalcChild("FunctionName") { PocoProperty = "FunctionName", HrLabel = "Function Name", Optional = true, Display = DisplayMode.Augmented },
+            new ParametersList() { PocoProperty = "Parameters", HrLabel = "Parameters", Optional = true, Display = DisplayMode.Augmented },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformQuickFindStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformQuickFindStep.cs
index 0243020..1d55319 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformQuickFindStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformQuickFindStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +14,9 @@ public sealed class PerformQuickFindStep : ScriptStep, IStepFactory
     public const int XmlId = 150;
     public const string XmlName = "Perform Quick Find";
 
-    public Calculation Calculation { get; set; }
+    public Calculation Calculation { get; set; } = new("");
+
+    private PerformQuickFindStep() : base(false) { }
 
     public PerformQuickFindStep(
         Calculation? calculation = null,
@@ -22,31 +26,15 @@ public PerformQuickFindStep(
         Calculation = calculation ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            Calculation.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Perform Quick Find [ " + Calculation.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var calculation_vEl = step.Element("Calculation");
-        var calculation_v = calculation_vEl is not null ? Calculation.FromXml(calculation_vEl) : new Calculation("");
-        return new PerformQuickFindStep(calculation_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<PerformQuickFindStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? calculation_v = null;
-        foreach (var tok in tokens) { if (!(false)) { calculation_v = new Calculation(tok); break; } }
-        return new PerformQuickFindStep(calculation_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<PerformQuickFindStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -54,14 +42,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "found sets",
         HelpUrl = "https://help.claris.com/en/pro-help/content/perform-quick-find.html",
-        Params =
+        // The bare search Calculation is omitted by the unconfigured form (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-            },
+            new BareCalcChild { PocoProperty = "Calculation", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformRagActionStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformRagActionStep.cs
index 0ba3698..a5989c7 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformRagActionStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformRagActionStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,35 +13,42 @@ public sealed class PerformRagActionStep : ScriptStep, IStepFactory
 
     public StepChildBag Children { get; set; }
 
+    private PerformRagActionStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public PerformRagActionStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new PerformRagActionStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<PerformRagActionStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new PerformRagActionStep(enabled: enabled);
+        StepDisplayParser.Parse<PerformRagActionStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformScriptOnServerStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformScriptOnServerStep.cs
index 29931da..163a292 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformScriptOnServerStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformScriptOnServerStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -19,6 +21,14 @@ public sealed class PerformScriptOnServerStep : ScriptStep, IStepFactory
     public PerformScriptTarget Target { get; set; }
     public Calculation? Parameter { get; set; }
 
+    // Emit-only wire projections: FM Pro emits <Calculated> before
+    // <WaitForCompletion> for ByCalculation but <Script> after the parameter
+    // for ByReference. Get-only, so the shape parser skips them.
+    public Calculation? CalculatedWire =>
+        Target is PerformScriptTarget.ByCalculation byCalc ? byCalc.NameCalc : null;
+    public NamedRef? ScriptWire =>
+        Target is PerformScriptTarget.ByReference byRef ? byRef.Script : null;
+
     public PerformScriptOnServerStep(
         bool waitForCompletion = true,
         PerformScriptTarget? target = null,
@@ -31,31 +41,9 @@ public PerformScriptOnServerStep(
         Parameter = parameter;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-
-        switch (Target)
-        {
-            case PerformScriptTarget.ByReference byRef:
-                step.Add(new XElement("WaitForCompletion", new XAttribute("state", WaitForCompletion ? "True" : "False")));
-                if (Parameter is not null) step.Add(Parameter.ToXml());
-                step.Add(byRef.Script.ToXml("Script"));
-                break;
-
-            case PerformScriptTarget.ByCalculation byCalc:
-                step.Add(new XElement("Calculated", byCalc.NameCalc.ToXml()));
-                step.Add(new XElement("WaitForCompletion", new XAttribute("state", WaitForCompletion ? "True" : "False")));
-                if (Parameter is not null) step.Add(Parameter.ToXml());
-                break;
-        }
-
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the script target is a variant with a bare quoted-name token order the shape renderer cannot express.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>
@@ -77,6 +65,9 @@ public override string ToDisplayLine()
         return $"Perform Script on Server [ {string.Join(" ; ", parts)} ]";
     }
 
+    // Hand-written rather than StepXmlParser: the Target union is spread
+    // across two emit-only projection slots, and the degenerate no-reference
+    // form defaults to an empty by-ref.
     public static new ScriptStep FromXml(XElement step)
     {
         var enabled = step.Attribute("enable")?.Value != "False";
@@ -126,11 +117,16 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/perform-script-on-server.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "WaitForCompletion", XmlElement = "WaitForCompletion", XmlAttr = "state", Type = "boolean", HrLabel = "Wait for completion" },
-            new ParamMetadata { Name = "Script", XmlElement = "Script", Type = "script" },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation", HrLabel = "Parameter" },
+            // Per-variant ordering via the emit-only projections above:
+            // <Calculated> leads for ByCalculation, <Script> trails the
+            // parameter for ByReference; WaitForCompletion and the parameter
+            // sit between in both variants.
+            new NamedCalcChild("Calculated") { PocoProperty = "CalculatedWire", Optional = true },
+            new BoolStateChild("WaitForCompletion") { HrLabel = "Wait for completion" },
+            new BareCalcChild { PocoProperty = "Parameter", Optional = true, HrLabel = "Parameter" },
+            new NamedRefChild("Script") { PocoProperty = "ScriptWire", Optional = true, HrLabel = "Script" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformScriptOnServerWithCallbackStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformScriptOnServerWithCallbackStep.cs
index 0f5b6e3..f35d22c 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformScriptOnServerWithCallbackStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformScriptOnServerWithCallbackStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -21,6 +23,19 @@ public sealed class PerformScriptOnServerWithCallbackStep : ScriptStep, IStepFac
     public NamedRef? CallbackScript { get; set; }
     public Calculation? CallbackParameter { get; set; }
 
+    // Emit-only wire projections: FM Pro emits <Calculated> before
+    // <CallbackScriptState> for ByCalculation but <Script> after the
+    // parameter for ByReference — and only when the target is actually
+    // configured (the canonical unconfigured form carries no <Script>).
+    // Get-only, so the shape parser skips them.
+    public Calculation? CalculatedWire =>
+        Target is PerformScriptTarget.ByCalculation byCalc ? byCalc.NameCalc : null;
+    public NamedRef? ScriptWire =>
+        Target is PerformScriptTarget.ByReference byRef
+            && (byRef.Script.Id != 0 || !string.IsNullOrEmpty(byRef.Script.Name))
+            ? byRef.Script
+            : null;
+
     public PerformScriptOnServerWithCallbackStep(
         string state = "Continue",
         PerformScriptTarget? target = null,
@@ -37,37 +52,9 @@ public PerformScriptOnServerWithCallbackStep(
         CallbackParameter = callbackParameter;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-
-        switch (Target)
-        {
-            case PerformScriptTarget.ByReference byRef:
-                step.Add(new XElement("CallbackScriptState", new XAttribute("value", State)));
-                if (Parameter is not null) step.Add(Parameter.ToXml());
-                step.Add(byRef.Script.ToXml("Script"));
-                break;
-            case PerformScriptTarget.ByCalculation byCalc:
-                step.Add(new XElement("Calculated", byCalc.NameCalc.ToXml()));
-                step.Add(new XElement("CallbackScriptState", new XAttribute("value", State)));
-                if (Parameter is not null) step.Add(Parameter.ToXml());
-                break;
-        }
-
-        if (CallbackScript is not null)
-        {
-            var cb = new XElement("CallbackScript", CallbackScript.ToXml("ScriptName"));
-            if (CallbackParameter is not null)
-                cb.Add(new XElement("ScriptParameter", CallbackParameter.ToXml("Calculation")));
-            step.Add(cb);
-        }
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the script target renders as a bare quoted-name variant token the shape renderer cannot express.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string> { $"State: {State}" };
@@ -85,6 +72,9 @@ public override string ToDisplayLine()
         return $"Perform Script on Server with Callback [ {string.Join(" ; ", parts)} ]";
     }
 
+    // Hand-written rather than StepXmlParser: the Target union is spread
+    // across two emit-only projection slots, and the degenerate no-reference
+    // form defaults to an empty by-ref.
     public static new ScriptStep FromXml(XElement step)
     {
         var enabled = step.Attribute("enable")?.Value != "False";
@@ -124,12 +114,22 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/perform-script-on-server-callback.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "CallbackScriptState", XmlElement = "CallbackScriptState", XmlAttr = "value", Type = "enum", HrLabel = "State", ValidValues = ["Continue", "Halt", "Exit", "Resume", "Pause"], DefaultValue = "Continue" },
-            new ParamMetadata { Name = "Script", XmlElement = "Script", Type = "script" },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation", HrLabel = "Parameter" },
-            new ParamMetadata { Name = "CallbackScript", XmlElement = "CallbackScript", Type = "complex" },
+            // Per-variant ordering via the emit-only projections above:
+            // <Calculated> leads for ByCalculation, <Script> trails the
+            // parameter for ByReference (and only when configured). The
+            // <CallbackScript> wrapper is always emitted, empty when no
+            // callback is set.
+            new NamedCalcChild("Calculated") { PocoProperty = "CalculatedWire", Optional = true },
+            new EnumValueChild("CallbackScriptState") { PocoProperty = "State", HrLabel = "State", ValidValues = ["Continue", "Halt", "Exit", "Resume", "Pause"], DefaultValue = "Continue" },
+            new BareCalcChild { PocoProperty = "Parameter", Optional = true, HrLabel = "Parameter" },
+            new NamedRefChild("Script") { PocoProperty = "ScriptWire", Optional = true, HrLabel = "Script" },
+            new WrapperChild("CallbackScript",
+            [
+                new NamedRefChild("ScriptName") { PocoProperty = "CallbackScript", Optional = true, HrLabel = "Callback" },
+                new NamedCalcChild("ScriptParameter") { PocoProperty = "CallbackParameter", Optional = true },
+            ]),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformScriptStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformScriptStep.cs
index 4ad159b..097ee46 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformScriptStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformScriptStep.cs
@@ -3,6 +3,8 @@
 using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -21,6 +23,14 @@ public sealed class PerformScriptStep : ScriptStep, IStepFactory
     public PerformScriptTarget Target { get; set; }
     public Calculation? Parameter { get; set; }
 
+    // Emit-only wire projections: FM Pro emits the parameter Calculation
+    // before <Script> for ByReference but after <Calculated> for
+    // ByCalculation. Get-only, so the shape parser skips them.
+    public Calculation? ParameterBeforeScript =>
+        Target is PerformScriptTarget.ByReference ? Parameter : null;
+    public Calculation? ParameterAfterCalculated =>
+        Target is PerformScriptTarget.ByCalculation ? Parameter : null;
+
     public PerformScriptStep(bool enabled, PerformScriptTarget target, Calculation? parameter = null)
         : base(enabled)
     {
@@ -28,6 +38,9 @@ public PerformScriptStep(bool enabled, PerformScriptTarget target, Calculation?
         Parameter = parameter;
     }
 
+    // Hand-written rather than StepXmlParser: tolerates the degenerate
+    // no-reference form and binds the step-level Parameter regardless of
+    // which side of the variant it appeared on.
     public static new ScriptStep FromXml(XElement step)
     {
         var enabled = step.Attribute("enable")?.Value != "False";
@@ -58,34 +71,9 @@ public PerformScriptStep(bool enabled, PerformScriptTarget target, Calculation?
         return new PerformScriptStep(enabled, target, parameter);
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-
-        // FM Pro emits parameter before Script for ByReference,
-        // but after Calculated for ByCalculation. Match per-variant
-        // order for clipboard-round-trip fidelity.
-        switch (Target)
-        {
-            case PerformScriptTarget.ByReference byRef:
-                if (Parameter is not null)
-                    step.Add(Parameter.ToXml());
-                step.Add(byRef.Script.ToXml("Script"));
-                break;
-
-            case PerformScriptTarget.ByCalculation byCalc:
-                step.Add(new XElement("Calculated", byCalc.NameCalc.ToXml()));
-                if (Parameter is not null)
-                    step.Add(Parameter.ToXml());
-                break;
-        }
-
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the script target is a variant (by-name renders the quoted name, by-calculation the expression) the shape renderer cannot express.
     public override string ToDisplayLine()
     {
         var parts = new List<string>();
@@ -161,10 +149,18 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/perform-script.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "Script", XmlElement = "Script", Type = "script" },
-            new ParamMetadata { Name = "Parameter", XmlElement = "Calculation", Type = "calculation", HrLabel = "Parameter" },
+            new BareCalcChild { PocoProperty = "ParameterBeforeScript", Optional = true, HrLabel = "Parameter", Display = DisplayMode.Augmented },
+            new VariantBlock(
+            [
+                new VariantCase(typeof(PerformScriptTarget.ByReference),
+                    [new NamedRefChild("Script")]) { MatchElement = "Script" },
+                new VariantCase(typeof(PerformScriptTarget.ByCalculation),
+                    [new NamedCalcChild("Calculated") { PocoProperty = "NameCalc" }])
+                { MatchElement = "Calculated" },
+            ]) { PocoProperty = "Target", Required = true },
+            new BareCalcChild { PocoProperty = "ParameterAfterCalculated", Optional = true, Display = DisplayMode.Hidden },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformSemanticFindStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformSemanticFindStep.cs
index e4ce61b..050eb9e 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformSemanticFindStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformSemanticFindStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,35 +13,42 @@ public sealed class PerformSemanticFindStep : ScriptStep, IStepFactory
 
     public StepChildBag Children { get; set; }
 
+    private PerformSemanticFindStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public PerformSemanticFindStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new PerformSemanticFindStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<PerformSemanticFindStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new PerformSemanticFindStep(enabled: enabled);
+        StepDisplayParser.Parse<PerformSemanticFindStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/PerformSqlQueryByNaturalLanguageStep.cs b/src/SharpFM.Model/Scripting/Steps/PerformSqlQueryByNaturalLanguageStep.cs
index 2c6db61..df9f109 100644
--- a/src/SharpFM.Model/Scripting/Steps/PerformSqlQueryByNaturalLanguageStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PerformSqlQueryByNaturalLanguageStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,35 +13,42 @@ public sealed class PerformSqlQueryByNaturalLanguageStep : ScriptStep, IStepFact
 
     public StepChildBag Children { get; set; }
 
+    private PerformSqlQueryByNaturalLanguageStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public PerformSqlQueryByNaturalLanguageStep(StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
+
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    /// <summary>
+    /// Display edits are anchor-preserved when a configured child subtree is
+    /// present — the display line carries only the step name.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
 
     public static new ScriptStep FromXml(XElement step) =>
-        new PerformSqlQueryByNaturalLanguageStep(StepChildBag.FromParent(step), step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<PerformSqlQueryByNaturalLanguageStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new PerformSqlQueryByNaturalLanguageStep(enabled: enabled);
+        StepDisplayParser.Parse<PerformSqlQueryByNaturalLanguageStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
+        Shape =
+        [
+            new Passthrough { PocoProperty = "Children" },
+        ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/PrintSetupStep.cs b/src/SharpFM.Model/Scripting/Steps/PrintSetupStep.cs
index a29f2db..ea6205c 100644
--- a/src/SharpFM.Model/Scripting/Steps/PrintSetupStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PrintSetupStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +15,11 @@ public sealed class PrintSetupStep : ScriptStep, IStepFactory
     public bool RestoreStoredSettings { get; set; }
     public PageFormat? Format { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    private PrintSetupStep() : base(false) { }
+
     public PrintSetupStep(
         bool withDialog = false,
         bool restoreStoredSettings = true,
@@ -25,44 +32,15 @@ public PrintSetupStep(
         Format = format;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("Restore", new XAttribute("state", RestoreStoredSettings ? "True" : "False")));
-        if (Format is not null) step.Add(Format.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Print Setup [ With dialog: {(WithDialog ? "On" : "Off")} ; Restore: {(RestoreStoredSettings ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var restore = step.Element("Restore")?.Attribute("state")?.Value == "True";
-        var formatEl = step.Element("PageFormat");
-        var format = formatEl is not null ? PageFormat.FromXml(formatEl) : null;
-        return new PrintSetupStep(withDialog, restore, format, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<PrintSetupStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        bool withDialog = false, restore = true;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("With dialog:", System.StringComparison.OrdinalIgnoreCase))
-                withDialog = t.Substring(12).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
-            else if (t.StartsWith("Restore:", System.StringComparison.OrdinalIgnoreCase))
-                restore = t.Substring(8).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
-        }
-        return new PrintSetupStep(withDialog, restore, null, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<PrintSetupStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -70,11 +48,15 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/print-setup.html",
-        Params =
+        // Canonical: NoInteract (inverts WithDialog), Restore, then the optional
+        // PageFormat which owns its own attribute/PlatformData shape.
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "PageFormat", XmlElement = "PageFormat", Type = "complex" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", Display = DisplayMode.Augmented, DisplayInverted = true },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredSettings", HrLabel = "Restore", Display = DisplayMode.Augmented },
+            new ValueTypeChild("PageFormat") { PocoProperty = "Format", Optional = true, Display = DisplayMode.Hidden },
+            new HrOnly("Restore") { Boolean = true },
+            new HrOnly("PageFormat"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/PrintStep.cs b/src/SharpFM.Model/Scripting/Steps/PrintStep.cs
index 28a6286..39ea176 100644
--- a/src/SharpFM.Model/Scripting/Steps/PrintStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/PrintStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +15,11 @@ public sealed class PrintStep : ScriptStep, IStepFactory
     public bool RestoreStoredSettings { get; set; }
     public PrintSettings? Settings { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    private PrintStep() : base(false) { }
+
     public PrintStep(
         bool withDialog = false,
         bool restoreStoredSettings = true,
@@ -25,44 +32,15 @@ public PrintStep(
         Settings = settings;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("Restore", new XAttribute("state", RestoreStoredSettings ? "True" : "False")));
-        if (Settings is not null) step.Add(Settings.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Print [ With dialog: {(WithDialog ? "On" : "Off")} ; Restore: {(RestoreStoredSettings ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var restore = step.Element("Restore")?.Attribute("state")?.Value == "True";
-        var settingsEl = step.Element("PrintSettings");
-        var settings = settingsEl is not null ? PrintSettings.FromXml(settingsEl) : null;
-        return new PrintStep(withDialog, restore, settings, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<PrintStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        bool withDialog = false, restore = true;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("With dialog:", System.StringComparison.OrdinalIgnoreCase))
-                withDialog = t.Substring(12).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
-            else if (t.StartsWith("Restore:", System.StringComparison.OrdinalIgnoreCase))
-                restore = t.Substring(8).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
-        }
-        return new PrintStep(withDialog, restore, null, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<PrintStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -70,11 +48,15 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/print.html",
-        Params =
+        // Canonical: NoInteract (inverts WithDialog), Restore, then the optional
+        // PrintSettings which owns its own attribute/PlatformData shape.
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "PrintSettings", XmlElement = "PrintSettings", Type = "complex" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", Display = DisplayMode.Augmented, DisplayInverted = true },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredSettings", HrLabel = "Restore", Display = DisplayMode.Augmented },
+            new ValueTypeChild("PrintSettings") { PocoProperty = "Settings", Optional = true, Display = DisplayMode.Hidden },
+            new HrOnly("Restore") { Boolean = true },
+            new HrOnly("PrintSettings"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ReLoginStep.cs b/src/SharpFM.Model/Scripting/Steps/ReLoginStep.cs
index 24255f9..d1d0857 100644
--- a/src/SharpFM.Model/Scripting/Steps/ReLoginStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ReLoginStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,8 +15,13 @@ public sealed class ReLoginStep : ScriptStep, IStepFactory
     public const string XmlName = "Re-Login";
 
     public bool WithDialog { get; set; }
-    public Calculation AccountName { get; set; }
-    public Calculation Password { get; set; }
+    public Calculation AccountName { get; set; } = new("");
+    public Calculation Password { get; set; } = new("");
+
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    private ReLoginStep() : base(false) { }
 
     public ReLoginStep(
         bool withDialog = true,
@@ -28,42 +35,15 @@ public ReLoginStep(
         Password = password ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("AccountName", AccountName.ToXml("Calculation")),
-            new XElement("Password", Password.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Re-Login [ " + "With dialog: " + (WithDialog ? "On" : "Off") + " ; " + "Account Name: " + AccountName.Text + " ; " + "Password: " + Password.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog_v = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var accountName_vWrapEl = step.Element("AccountName");
-        var accountName_vCalcEl = accountName_vWrapEl?.Element("Calculation");
-        var accountName_v = accountName_vCalcEl is not null ? Calculation.FromXml(accountName_vCalcEl) : new Calculation("");
-        var password_vWrapEl = step.Element("Password");
-        var password_vCalcEl = password_vWrapEl?.Element("Calculation");
-        var password_v = password_vCalcEl is not null ? Calculation.FromXml(password_vCalcEl) : new Calculation("");
-        return new ReLoginStep(withDialog_v, accountName_v, password_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ReLoginStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool withDialog_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(12).Trim(); withDialog_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        Calculation? accountName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Account Name:", StringComparison.OrdinalIgnoreCase)) { accountName_v = new Calculation(tok.Substring(13).Trim()); break; } }
-        Calculation? password_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Password:", StringComparison.OrdinalIgnoreCase)) { password_v = new Calculation(tok.Substring(9).Trim()); break; } }
-        return new ReLoginStep(withDialog_v, accountName_v, password_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ReLoginStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -71,32 +51,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "accounts",
         HelpUrl = "https://help.claris.com/en/pro-help/content/re-login.html",
-        Params =
+        // NoInteract (inverts WithDialog) then AccountName/Password, which the
+        // unconfigured form omits (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Account Name",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Password",
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", Display = DisplayMode.Native, DisplayInverted = true },
+            new NamedCalcChild("AccountName") { PocoProperty = "AccountName", HrLabel = "Account Name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new NamedCalcChild("Password") { PocoProperty = "Password", HrLabel = "Password", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ReadFromDataFileStep.cs b/src/SharpFM.Model/Scripting/Steps/ReadFromDataFileStep.cs
index 3b4647d..edc4e4f 100644
--- a/src/SharpFM.Model/Scripting/Steps/ReadFromDataFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ReadFromDataFileStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -10,10 +12,12 @@ public sealed class ReadFromDataFileStep : ScriptStep, IStepFactory
     public const int XmlId = 193;
     public const string XmlName = "Read from Data File";
 
-    public Calculation FileId { get; set; }
+    public Calculation? FileId { get; set; }
     public Calculation? Count { get; set; }
     public FieldRef? Target { get; set; }
-    public string DataSourceType { get; set; }
+    public string DataSourceType { get; set; } = "3";
+
+    private ReadFromDataFileStep() : base(false) { }
 
     public ReadFromDataFileStep(
         Calculation? fileId = null,
@@ -23,30 +27,17 @@ public ReadFromDataFileStep(
         bool enabled = true)
         : base(enabled)
     {
-        FileId = fileId ?? new Calculation("");
+        FileId = fileId;
         Count = count;
         Target = target;
         DataSourceType = dataSourceType;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("DataSourceType", new XAttribute("value", DataSourceType)),
-            FileId.ToXml("Calculation"));
-        if (Target is not null)
-        {
-            if (Target.IsVariable) step.Add(new XElement("Text"));
-            step.Add(Target.ToXml("Field"));
-        }
-        if (Count is not null)
-            step.Add(new XElement("Count", Count.ToXml("Calculation")));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the amount label is per-mode conditional ("Amount" for
+    // UTF-16, "Amount (bytes)" otherwise) — a form the shape renderer's static
+    // HrLabel cannot express.
     public override string ToDisplayLine()
     {
         var readAs = DataSourceType switch
@@ -57,25 +48,15 @@ public override string ToDisplayLine()
             _ => DataSourceType,
         };
         var amountLabel = DataSourceType == "1" ? "Amount" : "Amount (bytes)";
-        var parts = new System.Collections.Generic.List<string> { $"File ID: {FileId.Text}" };
+        var parts = new System.Collections.Generic.List<string> { $"File ID: {FileId?.Text ?? ""}" };
         if (Count is not null) parts.Add($"{amountLabel}: {Count.Text}");
         if (Target is not null) parts.Add($"Target: {Target.ToDisplayString()}");
         parts.Add($"Read as: {readAs}");
         return $"Read from Data File [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var type = step.Element("DataSourceType")?.Attribute("value")?.Value ?? "3";
-        var fileIdEl = step.Element("Calculation");
-        var fileId = fileIdEl is not null ? Calculation.FromXml(fileIdEl) : new Calculation("");
-        var countEl = step.Element("Count")?.Element("Calculation");
-        var count = countEl is not null ? Calculation.FromXml(countEl) : null;
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new ReadFromDataFileStep(fileId, count, target, type, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ReadFromDataFileStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -114,12 +95,15 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/read-from-data-file.html",
-        Params =
+        // Canonical: DataSourceType, then the optional bare <Calculation> (file
+        // id), field target (variable target gets the bare <Text/> marker), and
+        // the <Count> amount calculation.
+        Shape =
         [
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation", HrLabel = "File ID", Required = true },
-            new ParamMetadata { Name = "Count", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Amount (bytes)" },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", HrLabel = "Target" },
-            new ParamMetadata { Name = "DataSourceType", XmlElement = "DataSourceType", XmlAttr = "value", Type = "enum", HrLabel = "Read as", ValidValues = ["UTF-16", "UTF-8", "Bytes"], DefaultValue = "3" },
+            new EnumValueChild("DataSourceType") { PocoProperty = "DataSourceType", HrLabel = "Read as", DefaultValue = "3", DisplayValues = ["UTF-16", "UTF-8", "Bytes"], Display = DisplayMode.Augmented },
+            new BareCalcChild { PocoProperty = "FileId", HrLabel = "File ID", Optional = true, Display = DisplayMode.Native },
+            new FieldChild("Field") { PocoProperty = "Target", HrLabel = "Target", Optional = true, VariableTextMarker = true, Display = DisplayMode.Native },
+            new NamedCalcChild("Count") { PocoProperty = "Count", HrLabel = "Amount (bytes)", Optional = true, Display = DisplayMode.Augmented },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/RecoverFileStep.cs b/src/SharpFM.Model/Scripting/Steps/RecoverFileStep.cs
index ccf0b5a..8116160 100644
--- a/src/SharpFM.Model/Scripting/Steps/RecoverFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/RecoverFileStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -14,6 +16,11 @@ public sealed class RecoverFileStep : ScriptStep, IStepFactory
     public bool WithDialog { get; set; }
     public string UniversalPathList { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    private RecoverFileStep() : base(false) { }
+
     public RecoverFileStep(
         bool withDialog = true,
         string universalPathList = "",
@@ -24,34 +31,15 @@ public RecoverFileStep(
         UniversalPathList = universalPathList;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("UniversalPathList", UniversalPathList));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Recover File [ " + "With dialog: " + (WithDialog ? "On" : "Off") + " ; " + UniversalPathList + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog_v = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var universalPathList_v = step.Element("UniversalPathList")?.Value ?? "";
-        return new RecoverFileStep(withDialog_v, universalPathList_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<RecoverFileStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool withDialog_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(12).Trim(); withDialog_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        var universalPathList_v = tokens.FirstOrDefault(t =>
-            !t.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase)) ?? "";
-        return new RecoverFileStep(withDialog_v, universalPathList_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<RecoverFileStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -59,24 +47,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/recover-file.html",
-        Params =
+        // Canonical: NoInteract then UniversalPathList; the path list is omitted
+        // when empty (Optional), and <NoInteract state> is the inverse of WithDialog.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "UniversalPathList",
-                XmlElement = "UniversalPathList",
-                Type = "text",
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", Display = DisplayMode.Augmented, DisplayInverted = true },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "UniversalPathList", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/RefreshObjectStep.cs b/src/SharpFM.Model/Scripting/Steps/RefreshObjectStep.cs
index 3b766bb..ac800df 100644
--- a/src/SharpFM.Model/Scripting/Steps/RefreshObjectStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/RefreshObjectStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,8 +14,10 @@ public sealed class RefreshObjectStep : ScriptStep, IStepFactory
     public const int XmlId = 167;
     public const string XmlName = "Refresh Object";
 
-    public Calculation ObjectName { get; set; }
-    public Calculation Repetition { get; set; }
+    public Calculation ObjectName { get; set; } = new("");
+    public Calculation Repetition { get; set; } = new("");
+
+    private RefreshObjectStep() : base(false) { }
 
     public RefreshObjectStep(
         Calculation? objectName = null,
@@ -25,38 +29,15 @@ public RefreshObjectStep(
         Repetition = repetition ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ObjectName", ObjectName.ToXml("Calculation")),
-            new XElement("Repetition", Repetition.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Refresh Object [ " + "Object Name: " + ObjectName.Text + " ; " + "Repetition: " + Repetition.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var objectName_vWrapEl = step.Element("ObjectName");
-        var objectName_vCalcEl = objectName_vWrapEl?.Element("Calculation");
-        var objectName_v = objectName_vCalcEl is not null ? Calculation.FromXml(objectName_vCalcEl) : new Calculation("");
-        var repetition_vWrapEl = step.Element("Repetition");
-        var repetition_vCalcEl = repetition_vWrapEl?.Element("Calculation");
-        var repetition_v = repetition_vCalcEl is not null ? Calculation.FromXml(repetition_vCalcEl) : new Calculation("");
-        return new RefreshObjectStep(objectName_v, repetition_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<RefreshObjectStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? objectName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Object Name:", StringComparison.OrdinalIgnoreCase)) { objectName_v = new Calculation(tok.Substring(12).Trim()); break; } }
-        Calculation? repetition_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Repetition:", StringComparison.OrdinalIgnoreCase)) { repetition_v = new Calculation(tok.Substring(11).Trim()); break; } }
-        return new RefreshObjectStep(objectName_v, repetition_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<RefreshObjectStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -64,22 +45,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/refresh-object.html",
-        Params =
+        // ObjectName and Repetition wrappers are omitted by the unconfigured
+        // form (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Object Name",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Repetition",
-            },
+            new NamedCalcChild("ObjectName") { PocoProperty = "ObjectName", HrLabel = "Object Name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new NamedCalcChild("Repetition") { PocoProperty = "Repetition", HrLabel = "Repetition", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/RefreshPortalStep.cs b/src/SharpFM.Model/Scripting/Steps/RefreshPortalStep.cs
index 5c37f81..e1b9494 100644
--- a/src/SharpFM.Model/Scripting/Steps/RefreshPortalStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/RefreshPortalStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,42 +14,27 @@ public sealed class RefreshPortalStep : ScriptStep, IStepFactory
     public const int XmlId = 180;
     public const string XmlName = "Refresh Portal";
 
-    public Calculation ObjectName { get; set; }
+    public Calculation? ObjectName { get; set; }
+
+    private RefreshPortalStep() : base(false) { }
 
     public RefreshPortalStep(
         Calculation? objectName = null,
         bool enabled = true)
         : base(enabled)
     {
-        ObjectName = objectName ?? new Calculation("");
+        ObjectName = objectName;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ObjectName", ObjectName.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Refresh Portal [ " + "Object Name: " + ObjectName.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var objectName_vWrapEl = step.Element("ObjectName");
-        var objectName_vCalcEl = objectName_vWrapEl?.Element("Calculation");
-        var objectName_v = objectName_vCalcEl is not null ? Calculation.FromXml(objectName_vCalcEl) : new Calculation("");
-        return new RefreshPortalStep(objectName_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<RefreshPortalStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? objectName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Object Name:", StringComparison.OrdinalIgnoreCase)) { objectName_v = new Calculation(tok.Substring(12).Trim()); break; } }
-        return new RefreshPortalStep(objectName_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<RefreshPortalStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -55,15 +42,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/refresh-portal.html",
-        Params =
+        // Canonical unconfigured form is empty: ObjectName is omitted when blank.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Object Name",
-            },
+            new NamedCalcChild("ObjectName") { PocoProperty = "ObjectName", HrLabel = "Object Name", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/RefreshWindowStep.cs b/src/SharpFM.Model/Scripting/Steps/RefreshWindowStep.cs
index 5fe9ea2..e2eb29f 100644
--- a/src/SharpFM.Model/Scripting/Steps/RefreshWindowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/RefreshWindowStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -20,6 +22,8 @@ public sealed class RefreshWindowStep : ScriptStep, IStepFactory
     public bool FlushCachedJoinResults { get; set; }
     public bool FlushCachedExternalData { get; set; }
 
+    private RefreshWindowStep() : base(false) { }
+
     public RefreshWindowStep(
         bool flushCachedJoinResults = false,
         bool flushCachedExternalData = false,
@@ -30,34 +34,15 @@ public RefreshWindowStep(
         FlushCachedExternalData = flushCachedExternalData;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Option", new XAttribute("state", FlushCachedJoinResults ? "True" : "False")),
-            new XElement("FlushSQLData", new XAttribute("state", FlushCachedExternalData ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Refresh Window [ " + "Flush cached join results: " + (FlushCachedJoinResults ? "On" : "Off") + " ; " + "Flush cached external data: " + (FlushCachedExternalData ? "On" : "Off") + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var flushCachedJoinResults_val = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var flushCachedExternalData_val = step.Element("FlushSQLData")?.Attribute("state")?.Value == "True";
-        return new RefreshWindowStep(flushCachedJoinResults_val, flushCachedExternalData_val, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<RefreshWindowStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool flushCachedJoinResults_val = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Flush cached join results:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(26).Trim(); flushCachedJoinResults_val = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool flushCachedExternalData_val = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Flush cached external data:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(27).Trim(); flushCachedExternalData_val = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        return new RefreshWindowStep(flushCachedJoinResults_val, flushCachedExternalData_val, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<RefreshWindowStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -65,28 +50,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/refresh-window.html",
-        Params =
+        // Canonical: Option (flush cached join results), then FlushSQLData.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Option",
-                XmlElement = "Option",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Flush cached join results",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "FlushSQLData",
-                XmlElement = "FlushSQLData",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Flush cached external data",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
+            new BoolStateChild("Option") { PocoProperty = "FlushCachedJoinResults", HrLabel = "Flush cached join results", Display = DisplayMode.Augmented },
+            new BoolStateChild("FlushSQLData") { PocoProperty = "FlushCachedExternalData", HrLabel = "Flush cached external data", Display = DisplayMode.Augmented },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/RelookupFieldContentsStep.cs b/src/SharpFM.Model/Scripting/Steps/RelookupFieldContentsStep.cs
index 49982e3..fb57a09 100644
--- a/src/SharpFM.Model/Scripting/Steps/RelookupFieldContentsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/RelookupFieldContentsStep.cs
@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,7 +14,17 @@ public sealed class RelookupFieldContentsStep : ScriptStep, IStepFactory
     public const string XmlName = "Relookup Field Contents";
 
     public bool WithDialog { get; set; }
-    public FieldRef Target { get; set; }
+    public FieldRef? Target { get; set; }
+
+    /// <summary>
+    /// XML-facing inverse of <see cref="WithDialog"/>: canonical
+    /// <c>&lt;NoInteract state="…"/&gt;</c> suppresses the dialog, so it is the
+    /// negation of the display-facing flag. The shape binds this so the raw
+    /// state round-trips without re-applying the inversion.
+    /// </summary>
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+
+    private RelookupFieldContentsStep() : base(false) { }
 
     public RelookupFieldContentsStep(
         bool withDialog = true,
@@ -21,38 +33,18 @@ public RelookupFieldContentsStep(
         : base(enabled)
     {
         WithDialog = withDialog;
-        Target = target ?? FieldRef.ForField("", 0, "");
+        Target = target;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            Target.ToXml("Field"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Relookup Field Contents [ " + "With dialog: " + (WithDialog ? "On" : "Off") + " ; " + Target.ToDisplayString() + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog_v = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new RelookupFieldContentsStep(withDialog_v, target, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<RelookupFieldContentsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool withDialog_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(12).Trim(); withDialog_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        FieldRef target = FieldRef.ForField("", 0, "");
-        foreach (var tok in tokens) { if (!tok.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(tok)) { target = FieldRef.FromDisplayToken(tok); break; } }
-        return new RelookupFieldContentsStep(withDialog_v, target, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<RelookupFieldContentsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -60,24 +52,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/relookup-field-contents.html",
-        Params =
+        // Canonical 040-RelookupFieldContents: NoInteract (always present, the
+        // inverse of WithDialog) then a <Field> omitted until a target is bound
+        // (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Field",
-                XmlElement = "Field",
-                Type = "field",
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteract", HrLabel = "With dialog", DisplayInverted = true },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/RenameFileStep.cs b/src/SharpFM.Model/Scripting/Steps/RenameFileStep.cs
index 867804d..282e527 100644
--- a/src/SharpFM.Model/Scripting/Steps/RenameFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/RenameFileStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,7 +15,9 @@ public sealed class RenameFileStep : ScriptStep, IStepFactory
     public const string XmlName = "Rename File";
 
     public string SourceFile { get; set; }
-    public Calculation NewName { get; set; }
+    public Calculation? NewName { get; set; }
+
+    private RenameFileStep() : base(false) { SourceFile = ""; }
 
     public RenameFileStep(
         string sourceFile = "",
@@ -22,38 +26,18 @@ public RenameFileStep(
         : base(enabled)
     {
         SourceFile = sourceFile;
-        NewName = newName ?? new Calculation("");
+        NewName = newName;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UniversalPathList", SourceFile),
-            NewName.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Rename File [ " + "Source file: " + SourceFile + " ; " + "New name: " + NewName.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var sourceFile_v = step.Element("UniversalPathList")?.Value ?? "";
-        var newName_vEl = step.Element("Calculation");
-        var newName_v = newName_vEl is not null ? Calculation.FromXml(newName_vEl) : new Calculation("");
-        return new RenameFileStep(sourceFile_v, newName_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<RenameFileStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        string sourceFile_v = "";
-        foreach (var tok in tokens) { if (tok.StartsWith("Source file:", StringComparison.OrdinalIgnoreCase)) { sourceFile_v = tok.Substring(12).Trim(); break; } }
-        Calculation? newName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("New name:", StringComparison.OrdinalIgnoreCase)) { newName_v = new Calculation(tok.Substring(9).Trim()); break; } }
-        return new RenameFileStep(sourceFile_v, newName_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<RenameFileStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -61,22 +45,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/rename-file.html",
-        Params =
+        // Canonical unconfigured form is empty: source path and new-name calc are omitted when blank.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "UniversalPathList",
-                XmlElement = "UniversalPathList",
-                Type = "text",
-                HrLabel = "Source file",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                HrLabel = "New name",
-            },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "SourceFile", HrLabel = "Source file", Optional = true, DisplayEmptyAs = "" },
+            new BareCalcChild { PocoProperty = "NewName", HrLabel = "New name", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ReplaceFieldContentsStep.cs b/src/SharpFM.Model/Scripting/Steps/ReplaceFieldContentsStep.cs
index a8c899c..04fd656 100644
--- a/src/SharpFM.Model/Scripting/Steps/ReplaceFieldContentsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ReplaceFieldContentsStep.cs
@@ -1,16 +1,18 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
 /// <summary>
-/// Replace Field Contents. The <c>&lt;Restore state="True"/&gt;</c> element
-/// is <b>intentionally dropped</b> per the zero-loss audit in
-/// <c>docs/advanced-filemaker-scripting-syntax.md</c> — FM Pro never changes
-/// the value and never emits the element in clipboard output, matching the
-/// same drop pattern as <see cref="IfStep"/>.
+/// Replace Field Contents. Canonical form (skill): <c>NoInteract</c>,
+/// <c>&lt;Restore state="False"/&gt;</c>, <c>&lt;With value="…"/&gt;</c>, then the
+/// optional replacement payload (a <c>&lt;Calculation&gt;</c> or a
+/// <c>&lt;SerialNumbers/&gt;</c> block) and an optional target <c>&lt;Field&gt;</c>.
+/// (Earlier revisions dropped <c>&lt;Restore&gt;</c>; the skill round-trips it.)
 /// </summary>
 public sealed class ReplaceFieldContentsStep : ScriptStep, IStepFactory
 {
@@ -18,11 +20,25 @@ public sealed class ReplaceFieldContentsStep : ScriptStep, IStepFactory
     public const string XmlName = "Replace Field Contents";
 
     public bool WithDialog { get; set; }
-    public FieldRef Field { get; set; }
+    public bool RestoreState { get; set; }
+    public FieldRef? Field { get; set; }
     public string Mode { get; set; }
     public Calculation? Calculation { get; set; }
     public SerialNumberOptions? SerialOptions { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    /// <summary>
+    /// Display edits are anchor-preserved when a serial-number options block
+    /// or a Restore flag is stored — the display line shows at most the
+    /// skip-auto-enter marker, never the block's increment/initial-value
+    /// settings, and never Restore.
+    /// </summary>
+    public override bool IsFullyEditable => SerialOptions is null && !RestoreState;
+
+    private ReplaceFieldContentsStep() : this(enabled: true) { }
+
     public ReplaceFieldContentsStep(
         bool withDialog = true,
         FieldRef? field = null,
@@ -33,33 +49,24 @@ public ReplaceFieldContentsStep(
         : base(enabled)
     {
         WithDialog = withDialog;
-        Field = field ?? FieldRef.ForField("", 0, "");
+        Field = field;
         Mode = mode;
         Calculation = calculation;
         SerialOptions = serialOptions;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("With", new XAttribute("value", Mode)));
-        if (Calculation is not null) step.Add(Calculation.ToXml("Calculation"));
-        if (SerialOptions is not null) step.Add(SerialOptions.ToXml());
-        step.Add(Field.ToXml("Field"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the mode token is per-mode conditional (Calculation mode
+    // shows the calc text, not the enum value) and the skip-auto-enter marker
+    // reads SerialOptions content — grammar the shape renderer cannot express.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>
         {
             $"With dialog: {(WithDialog ? "On" : "Off")}",
-            Field.ToDisplayString(),
         };
+        if (Field is not null) parts.Add(Field.ToDisplayString());
         var modePart = Mode switch
         {
             "CurrentContents" => "Current contents",
@@ -72,24 +79,13 @@ public override string ToDisplayLine()
         return $"Replace Field Contents [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var mode = step.Element("With")?.Attribute("value")?.Value ?? "Calculation";
-        var calcEl = step.Element("Calculation");
-        var calc = calcEl is not null ? Values.Calculation.FromXml(calcEl) : null;
-        var snEl = step.Element("SerialNumbers");
-        var sn = snEl is not null ? SerialNumberOptions.FromXml(snEl) : null;
-        var fieldEl = step.Element("Field");
-        var field = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        return new ReplaceFieldContentsStep(withDialog, field, mode, calc, sn, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ReplaceFieldContentsStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         bool withDialog = true;
-        FieldRef field = FieldRef.ForField("", 0, "");
+        FieldRef? field = null;
         string mode = "Calculation";
         Calculation? calc = null;
         bool fieldSeen = false;
@@ -98,15 +94,22 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
             var t = tok.Trim();
             if (t.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase))
                 withDialog = t.Substring(12).Trim().Equals("On", StringComparison.OrdinalIgnoreCase);
+            else if (t.Equals("Current contents", StringComparison.OrdinalIgnoreCase))
+                mode = "CurrentContents";
+            else if (t.Equals("Serial numbers", StringComparison.OrdinalIgnoreCase))
+                mode = "SerialNumbers";
+            else if (t.Equals("None", StringComparison.OrdinalIgnoreCase))
+                mode = "None";
+            else if (t.Equals("Skip auto-enter options", StringComparison.OrdinalIgnoreCase))
+            {
+                // Marker for a stored SerialNumbers block; such steps are
+                // sealed (see IsFullyEditable), so nothing to reconstruct.
+            }
             else if (!fieldSeen && !string.IsNullOrWhiteSpace(t))
             {
                 field = FieldRef.FromDisplayToken(t);
                 fieldSeen = true;
             }
-            else if (t.Equals("Current contents", StringComparison.OrdinalIgnoreCase))
-                mode = "CurrentContents";
-            else if (t.Equals("Serial numbers", StringComparison.OrdinalIgnoreCase))
-                mode = "SerialNumbers";
             else if (!string.IsNullOrWhiteSpace(t))
             {
                 mode = "Calculation";
@@ -122,13 +125,18 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/replace-field-contents.html",
-        Params =
+        // Canonical: NoInteract, Restore, With, then the optional replacement
+        // payload (Calculation or SerialNumbers) and the optional target Field.
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog", ValidValues = ["On", "Off"] },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", Required = true },
-            new ParamMetadata { Name = "With", XmlElement = "With", XmlAttr = "value", Type = "enum", ValidValues = ["Current contents", "Serial numbers", "Calculation"], DefaultValue = "Calculation" },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation" },
-            new ParamMetadata { Name = "SerialNumbers", XmlElement = "SerialNumbers", Type = "complex" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog" },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreState", Display = DisplayMode.Hidden },
+            new HrOnly("Field"),
+            new EnumValueChild("With") { PocoProperty = "Mode", ValidValues = ["CurrentContents", "SerialNumbers", "Calculation", "None"], DisplayValues = ["Current contents", "Serial numbers", "Calculation"], DefaultValue = "Calculation" },
+            new BareCalcChild { PocoProperty = "Calculation", Optional = true },
+            new ValueTypeChild("SerialNumbers") { PocoProperty = "SerialOptions", Optional = true, Display = DisplayMode.Hidden },
+            new HrOnly("SerialNumbers"),
+            new FieldChild("Field") { Optional = true, HrLabel = "Field" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ResetAccountPasswordStep.cs b/src/SharpFM.Model/Scripting/Steps/ResetAccountPasswordStep.cs
index c332488..a33fc4e 100644
--- a/src/SharpFM.Model/Scripting/Steps/ResetAccountPasswordStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ResetAccountPasswordStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,10 +14,15 @@ public sealed class ResetAccountPasswordStep : ScriptStep, IStepFactory
     public const int XmlId = 136;
     public const string XmlName = "Reset Account Password";
 
-    public Calculation AccountName { get; set; }
-    public Calculation Password { get; set; }
+    public Calculation AccountName { get; set; } = new("");
+    public Calculation Password { get; set; } = new("");
     public bool ExpirePassword { get; set; }
 
+    /// <summary><c>&lt;ChgPwdOnNextLogin value&gt;</c> as the True/False string the shape emits. Bound by the shape.</summary>
+    public string ExpirePasswordValue { get => ExpirePassword ? "True" : "False"; set => ExpirePassword = value == "True"; }
+
+    private ResetAccountPasswordStep() : base(false) { }
+
     public ResetAccountPasswordStep(
         Calculation? accountName = null,
         Calculation? password = null,
@@ -28,42 +35,15 @@ public ResetAccountPasswordStep(
         ExpirePassword = expirePassword;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("AccountName", AccountName.ToXml("Calculation")),
-            new XElement("Password", Password.ToXml("Calculation")),
-            new XElement("ChgPwdOnNextLogin", new XAttribute("value", ExpirePassword ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Reset Account Password [ " + "Account Name: " + AccountName.Text + " ; " + "Password: " + Password.Text + " ; " + "Expire password: " + (ExpirePassword ? "On" : "Off") + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var accountName_vWrapEl = step.Element("AccountName");
-        var accountName_vCalcEl = accountName_vWrapEl?.Element("Calculation");
-        var accountName_v = accountName_vCalcEl is not null ? Calculation.FromXml(accountName_vCalcEl) : new Calculation("");
-        var password_vWrapEl = step.Element("Password");
-        var password_vCalcEl = password_vWrapEl?.Element("Calculation");
-        var password_v = password_vCalcEl is not null ? Calculation.FromXml(password_vCalcEl) : new Calculation("");
-        var expirePassword_v = step.Element("ChgPwdOnNextLogin")?.Attribute("value")?.Value == "True";
-        return new ResetAccountPasswordStep(accountName_v, password_v, expirePassword_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ResetAccountPasswordStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? accountName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Account Name:", StringComparison.OrdinalIgnoreCase)) { accountName_v = new Calculation(tok.Substring(13).Trim()); break; } }
-        Calculation? password_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Password:", StringComparison.OrdinalIgnoreCase)) { password_v = new Calculation(tok.Substring(9).Trim()); break; } }
-        bool expirePassword_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Expire password:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(16).Trim(); expirePassword_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        return new ResetAccountPasswordStep(accountName_v, password_v, expirePassword_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ResetAccountPasswordStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -71,32 +51,15 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "accounts",
         HelpUrl = "https://help.claris.com/en/pro-help/content/reset-account-password.html",
-        Params =
+        // Canonical: AccountName and Password (omitted when empty, Optional) then
+        // the always-present ChgPwdOnNextLogin value flag.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Account Name",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Password",
-            },
-            new ParamMetadata
-            {
-                Name = "ChgPwdOnNextLogin",
-                XmlElement = "ChgPwdOnNextLogin",
-                Type = "boolean",
-                XmlAttr = "value",
-                HrLabel = "Expire password",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
+            new NamedCalcChild("AccountName") { PocoProperty = "AccountName", HrLabel = "Account Name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new NamedCalcChild("Password") { PocoProperty = "Password", HrLabel = "Password", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            // No DefaultValue: the flag must stay visible in the display line even
+            // when "False" (the POCO default matches the absent-element fallback).
+            new EnumValueChild("ChgPwdOnNextLogin") { PocoProperty = "ExpirePasswordValue", HrLabel = "Expire password", ValidValues = ["True", "False"], DisplayValues = ["On", "Off"], Display = DisplayMode.Augmented },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/RevertRecordRequestStep.cs b/src/SharpFM.Model/Scripting/Steps/RevertRecordRequestStep.cs
index 8226377..1b407a8 100644
--- a/src/SharpFM.Model/Scripting/Steps/RevertRecordRequestStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/RevertRecordRequestStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,39 +19,26 @@ public sealed class RevertRecordRequestStep : ScriptStep, IStepFactory
     /// <summary>The <c>With dialog</c> flag on the step.</summary>
     public bool WithDialog { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    private RevertRecordRequestStep() : base(false) { }
+
     public RevertRecordRequestStep(bool withdialog = true, bool enabled = true)
         : base(enabled)
     {
         WithDialog = withdialog;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract",
-                new XAttribute("state", WithDialog ? "False" : "True")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Revert Record/Request [ With dialog: {(WithDialog ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        return new RevertRecordRequestStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<RevertRecordRequestStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "With dialog:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        var isOn = token.Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new RevertRecordRequestStep(!isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<RevertRecordRequestStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -57,18 +46,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "records",
         HelpUrl = "https://help.claris.com/en/pro-help/content/revert-record-request.html",
-        Params =
+        // Canonical: a single NoInteract child (inverts WithDialog).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "With dialog",
-                // invertedHr: display 'On' means XML state='False'.
-                ValidValues = ["On", "Off"],
-            },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog", Display = DisplayMode.Augmented, DisplayInverted = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/RevertTransactionStep.cs b/src/SharpFM.Model/Scripting/Steps/RevertTransactionStep.cs
index ac7c293..398f8f2 100644
--- a/src/SharpFM.Model/Scripting/Steps/RevertTransactionStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/RevertTransactionStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,9 +15,11 @@ public sealed class RevertTransactionStep : ScriptStep, IStepFactory
     public const string XmlName = "Revert Transaction";
 
     public bool Option { get; set; }
-    public Calculation Condition { get; set; }
-    public Calculation ErrorCode { get; set; }
-    public Calculation ErrorMessage { get; set; }
+    public Calculation? Condition { get; set; }
+    public Calculation? ErrorCode { get; set; }
+    public Calculation? ErrorMessage { get; set; }
+
+    private RevertTransactionStep() : base(false) { }
 
     public RevertTransactionStep(
         bool option = false,
@@ -26,52 +30,20 @@ public RevertTransactionStep(
         : base(enabled)
     {
         Option = option;
-        Condition = condition ?? new Calculation("");
-        ErrorCode = errorCode ?? new Calculation("");
-        ErrorMessage = errorMessage ?? new Calculation("");
+        Condition = condition;
+        ErrorCode = errorCode;
+        ErrorMessage = errorMessage;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Option", new XAttribute("state", Option ? "True" : "False")),
-            new XElement("Condition", Condition.ToXml("Calculation")),
-            new XElement("ErrorCode", ErrorCode.ToXml("Calculation")),
-            new XElement("ErrorMessage", ErrorMessage.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Revert Transaction [ " + (Option ? "On" : "Off") + " ; " + "Condition: " + Condition.Text + " ; " + "Error Code: " + ErrorCode.Text + " ; " + "Error Message: " + ErrorMessage.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var option_v = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var condition_vWrapEl = step.Element("Condition");
-        var condition_vCalcEl = condition_vWrapEl?.Element("Calculation");
-        var condition_v = condition_vCalcEl is not null ? Calculation.FromXml(condition_vCalcEl) : new Calculation("");
-        var errorCode_vWrapEl = step.Element("ErrorCode");
-        var errorCode_vCalcEl = errorCode_vWrapEl?.Element("Calculation");
-        var errorCode_v = errorCode_vCalcEl is not null ? Calculation.FromXml(errorCode_vCalcEl) : new Calculation("");
-        var errorMessage_vWrapEl = step.Element("ErrorMessage");
-        var errorMessage_vCalcEl = errorMessage_vWrapEl?.Element("Calculation");
-        var errorMessage_v = errorMessage_vCalcEl is not null ? Calculation.FromXml(errorMessage_vCalcEl) : new Calculation("");
-        return new RevertTransactionStep(option_v, condition_v, errorCode_v, errorMessage_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<RevertTransactionStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool option_v = false;
-        Calculation? condition_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Condition:", StringComparison.OrdinalIgnoreCase)) { condition_v = new Calculation(tok.Substring(10).Trim()); break; } }
-        Calculation? errorCode_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Error Code:", StringComparison.OrdinalIgnoreCase)) { errorCode_v = new Calculation(tok.Substring(11).Trim()); break; } }
-        Calculation? errorMessage_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Error Message:", StringComparison.OrdinalIgnoreCase)) { errorMessage_v = new Calculation(tok.Substring(14).Trim()); break; } }
-        return new RevertTransactionStep(option_v, condition_v, errorCode_v, errorMessage_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<RevertTransactionStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -79,38 +51,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/revert-transaction.html",
-        Params =
+        // Canonical: Option, then the optional Condition / ErrorCode /
+        // ErrorMessage calculations (omitted when unconfigured).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Option",
-                XmlElement = "Option",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Condition",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Error Code",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Error Message",
-            },
+            new BoolStateChild("Option") { PocoProperty = "Option", Display = DisplayMode.Native },
+            new NamedCalcChild("Condition") { PocoProperty = "Condition", HrLabel = "Condition", Optional = true, Display = DisplayMode.Augmented, DisplayEmptyAs = "" },
+            new NamedCalcChild("ErrorCode") { PocoProperty = "ErrorCode", HrLabel = "Error Code", Optional = true, Display = DisplayMode.Augmented, DisplayEmptyAs = "" },
+            new NamedCalcChild("ErrorMessage") { PocoProperty = "ErrorMessage", HrLabel = "Error Message", Optional = true, Display = DisplayMode.Augmented, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SaveACopyAsAddOnPackageStep.cs b/src/SharpFM.Model/Scripting/Steps/SaveACopyAsAddOnPackageStep.cs
index 920a271..d0030bc 100644
--- a/src/SharpFM.Model/Scripting/Steps/SaveACopyAsAddOnPackageStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SaveACopyAsAddOnPackageStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,7 +15,9 @@ public sealed class SaveACopyAsAddOnPackageStep : ScriptStep, IStepFactory
     public const string XmlName = "Save a Copy as Add-on Package";
 
     public bool ReplaceUUIDs { get; set; }
-    public Calculation WindowName { get; set; }
+    public Calculation WindowName { get; set; } = new("");
+
+    private SaveACopyAsAddOnPackageStep() : base(false) { }
 
     public SaveACopyAsAddOnPackageStep(
         bool replaceUUIDs = false,
@@ -25,35 +29,15 @@ public SaveACopyAsAddOnPackageStep(
         WindowName = windowName ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("LinkAvail", new XAttribute("state", ReplaceUUIDs ? "True" : "False")),
-            WindowName.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Save a Copy as Add-on Package [ " + "Replace UUIDs: " + (ReplaceUUIDs ? "On" : "Off") + " ; " + "Window name: " + WindowName.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var replaceUUIDs_v = step.Element("LinkAvail")?.Attribute("state")?.Value == "True";
-        var windowName_vEl = step.Element("Calculation");
-        var windowName_v = windowName_vEl is not null ? Calculation.FromXml(windowName_vEl) : new Calculation("");
-        return new SaveACopyAsAddOnPackageStep(replaceUUIDs_v, windowName_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SaveACopyAsAddOnPackageStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool replaceUUIDs_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Replace UUIDs:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(14).Trim(); replaceUUIDs_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        Calculation? windowName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Window name:", StringComparison.OrdinalIgnoreCase)) { windowName_v = new Calculation(tok.Substring(12).Trim()); break; } }
-        return new SaveACopyAsAddOnPackageStep(replaceUUIDs_v, windowName_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SaveACopyAsAddOnPackageStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -61,25 +45,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/save-a-copy-as-add-on-package.html",
-        Params =
+        // Canonical: LinkAvail then the window-name Calculation, which the
+        // unconfigured form omits (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "LinkAvail",
-                XmlElement = "LinkAvail",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Replace UUIDs",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                HrLabel = "Window name",
-            },
+            new BoolStateChild("LinkAvail") { PocoProperty = "ReplaceUUIDs", HrLabel = "Replace UUIDs", Display = DisplayMode.Native },
+            new BareCalcChild { PocoProperty = "WindowName", HrLabel = "Window name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SaveACopyAsStep.cs b/src/SharpFM.Model/Scripting/Steps/SaveACopyAsStep.cs
index 04463f0..20c46c3 100644
--- a/src/SharpFM.Model/Scripting/Steps/SaveACopyAsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SaveACopyAsStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -14,8 +16,10 @@ public sealed class SaveACopyAsStep : ScriptStep, IStepFactory
     public bool CreateFolders { get; set; }
     public bool AutomaticallyOpen { get; set; }
     public bool CreateEmail { get; set; }
-    public string CopyType { get; set; }
-    public string OutputPath { get; set; }
+    public string CopyType { get; set; } = "Copy";
+    public string OutputPath { get; set; } = "";
+
+    private SaveACopyAsStep() : base(false) { }
 
     public SaveACopyAsStep(
         bool createFolders = true,
@@ -33,70 +37,15 @@ public SaveACopyAsStep(
         OutputPath = outputPath;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _CopyTypeToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["Copy"] = "copy of current file",
-        ["CompactedCopy"] = "compacted copy (smaller)",
-        ["Clone"] = "clone (no records)",
-        ["SelfContainedCopy"] = "self-contained copy (single file)",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _CopyTypeFromHr =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["copy of current file"] = "Copy",
-        ["compacted copy (smaller)"] = "CompactedCopy",
-        ["clone (no records)"] = "Clone",
-        ["self-contained copy (single file)"] = "SelfContainedCopy",
-    };
-
-    private static string CopyTypeHr(string x) =>
-        _CopyTypeToHr.TryGetValue(x, out var h) ? h : x;
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string CopyTypeXml(string h) =>
-        _CopyTypeFromHr.TryGetValue(h, out var x) ? x : h;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("CreateDirectories", new XAttribute("state", CreateFolders ? "True" : "False")),
-            new XElement("AutoOpen", new XAttribute("state", AutomaticallyOpen ? "True" : "False")),
-            new XElement("CreateEmail", new XAttribute("state", CreateEmail ? "True" : "False")),
-            new XElement("SaveAsType", new XAttribute("value", CopyType)),
-            new XElement("UniversalPathList", OutputPath));
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SaveACopyAsStep>(step, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Save a Copy as [ " + "Create folders: " + (CreateFolders ? "On" : "Off") + " ; " + "Automatically open: " + (AutomaticallyOpen ? "On" : "Off") + " ; " + "Create email: " + (CreateEmail ? "On" : "Off") + " ; " + "Copy type: " + CopyTypeHr(CopyType) + " ; " + "Output path: " + OutputPath + " ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var createFolders_v = step.Element("CreateDirectories")?.Attribute("state")?.Value == "True";
-        var automaticallyOpen_v = step.Element("AutoOpen")?.Attribute("state")?.Value == "True";
-        var createEmail_v = step.Element("CreateEmail")?.Attribute("state")?.Value == "True";
-        var copyType_v = step.Element("SaveAsType")?.Attribute("value")?.Value ?? "Copy";
-        var outputPath_v = step.Element("UniversalPathList")?.Value ?? "";
-        return new SaveACopyAsStep(createFolders_v, automaticallyOpen_v, createEmail_v, copyType_v, outputPath_v, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool createFolders_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Create folders:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(15).Trim(); createFolders_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool automaticallyOpen_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Automatically open:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(19).Trim(); automaticallyOpen_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool createEmail_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Create email:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(13).Trim(); createEmail_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        string copyType_v = "Copy";
-        foreach (var tok in tokens) { if (tok.StartsWith("Copy type:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(10).Trim(); copyType_v = CopyTypeXml(v); break; } }
-        string outputPath_v = "";
-        foreach (var tok in tokens) { if (tok.StartsWith("Output path:", StringComparison.OrdinalIgnoreCase)) { outputPath_v = tok.Substring(12).Trim(); break; } }
-        return new SaveACopyAsStep(createFolders_v, automaticallyOpen_v, createEmail_v, copyType_v, outputPath_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SaveACopyAsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -104,55 +53,17 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/save-a-copy-as.html",
-        Params =
+        // Canonical: CreateDirectories, AutoOpen, CreateEmail, SaveAsType, then
+        // the optional UniversalPathList (omitted when no output path is set).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "CreateDirectories",
-                XmlElement = "CreateDirectories",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Create folders",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "AutoOpen",
-                XmlElement = "AutoOpen",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "Automatically open",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "CreateEmail",
-                XmlElement = "CreateEmail",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "Create email",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "SaveAsType",
-                XmlElement = "SaveAsType",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Copy type",
-                ValidValues = ["copy of current file", "compacted copy (smaller)", "clone (no records)", "self-contained copy (single file)"],
-                DefaultValue = "Copy",
-            },
-            new ParamMetadata
-            {
-                Name = "UniversalPathList",
-                XmlElement = "UniversalPathList",
-                Type = "text",
-                HrLabel = "Output path",
-            },
+            // All Native: every token always shows (Augmented would suppress the
+            // Copy type at its DefaultValue), and shape order is the display order.
+            new BoolStateChild("CreateDirectories") { PocoProperty = "CreateFolders", HrLabel = "Create folders", Display = DisplayMode.Native },
+            new BoolStateChild("AutoOpen") { PocoProperty = "AutomaticallyOpen", HrLabel = "Automatically open", Display = DisplayMode.Native },
+            new BoolStateChild("CreateEmail") { PocoProperty = "CreateEmail", HrLabel = "Create email", Display = DisplayMode.Native },
+            new EnumValueChild("SaveAsType") { PocoProperty = "CopyType", HrLabel = "Copy type", DefaultValue = "Copy", ValidValues = ["Copy", "CompactedCopy", "Clone", "SelfContainedCopy"], DisplayValues = ["copy of current file", "compacted copy (smaller)", "clone (no records)", "self-contained copy (single file)"], Display = DisplayMode.Native },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "OutputPath", HrLabel = "Output path", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SaveACopyAsXMLStep.cs b/src/SharpFM.Model/Scripting/Steps/SaveACopyAsXMLStep.cs
index 6643ea4..4fa1569 100644
--- a/src/SharpFM.Model/Scripting/Steps/SaveACopyAsXMLStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SaveACopyAsXMLStep.cs
@@ -1,66 +1,66 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
+/// <summary>
+/// Save a Copy as XML (3). Canonical form (skill, windows/files reference):
+/// <c>&lt;Option&gt;</c> ("include details for analysis tools") always, then the
+/// FM 26 options — optional <c>&lt;OutputEntireBinaryData&gt;</c> and
+/// <c>&lt;SpecifyJSONOptions&gt;</c> flags and an optional
+/// <c>&lt;SaXML&gt;&lt;JSONOptions&gt;&lt;Calculation&gt;…</c> block carrying the
+/// catalog/JSON export options. The pre-FM 26 form is just <c>&lt;Option&gt;</c>.
+/// The FM 26 flags are nullable so an absent flag stays distinct from "present
+/// and False".
+/// </summary>
 public sealed class SaveACopyAsXMLStep : ScriptStep, IStepFactory
 {
     public const int XmlId = 3;
     public const string XmlName = "Save a Copy as XML";
 
     public bool IncludeDetailsForAnalysisTools { get; set; }
-    public string DestinationFile { get; set; }
-    public Calculation WindowName { get; set; }
+    public bool? OutputEntireBinaryData { get; set; }
+    public bool? SpecifyJSONOptions { get; set; }
+    public Calculation? JsonOptions { get; set; }
+
+    /// <summary>
+    /// Display edits are anchor-preserved when any FM 26 option is present —
+    /// the display line carries only the analysis-tools flag, never the
+    /// binary-data/JSON-options state.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        OutputEntireBinaryData is null && SpecifyJSONOptions is null && JsonOptions is null;
+
+    private SaveACopyAsXMLStep() : base(false) { }
 
     public SaveACopyAsXMLStep(
         bool includeDetailsForAnalysisTools = false,
-        string destinationFile = "",
-        Calculation? windowName = null,
+        bool? outputEntireBinaryData = null,
+        bool? specifyJSONOptions = null,
+        Calculation? jsonOptions = null,
         bool enabled = true)
         : base(enabled)
     {
         IncludeDetailsForAnalysisTools = includeDetailsForAnalysisTools;
-        DestinationFile = destinationFile;
-        WindowName = windowName ?? new Calculation("");
+        OutputEntireBinaryData = outputEntireBinaryData;
+        SpecifyJSONOptions = specifyJSONOptions;
+        JsonOptions = jsonOptions;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Option", new XAttribute("state", IncludeDetailsForAnalysisTools ? "True" : "False")),
-            new XElement("UniversalPathList", DestinationFile),
-            WindowName.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Save a Copy as XML [ " + "Include details for analysis tools: " + (IncludeDetailsForAnalysisTools ? "On" : "Off") + " ; " + "Destination file: " + DestinationFile + " ; " + "Window name: " + WindowName.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var includeDetailsForAnalysisTools_v = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var destinationFile_v = step.Element("UniversalPathList")?.Value ?? "";
-        var windowName_vEl = step.Element("Calculation");
-        var windowName_v = windowName_vEl is not null ? Calculation.FromXml(windowName_vEl) : new Calculation("");
-        return new SaveACopyAsXMLStep(includeDetailsForAnalysisTools_v, destinationFile_v, windowName_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SaveACopyAsXMLStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool includeDetailsForAnalysisTools_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Include details for analysis tools:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(35).Trim(); includeDetailsForAnalysisTools_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        string destinationFile_v = "";
-        foreach (var tok in tokens) { if (tok.StartsWith("Destination file:", StringComparison.OrdinalIgnoreCase)) { destinationFile_v = tok.Substring(17).Trim(); break; } }
-        Calculation? windowName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Window name:", StringComparison.OrdinalIgnoreCase)) { windowName_v = new Calculation(tok.Substring(12).Trim()); break; } }
-        return new SaveACopyAsXMLStep(includeDetailsForAnalysisTools_v, destinationFile_v, windowName_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SaveACopyAsXMLStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -68,32 +68,20 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/save-a-copy-as-xml.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Option",
-                XmlElement = "Option",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "Include details for analysis tools",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "UniversalPathList",
-                XmlElement = "UniversalPathList",
-                Type = "text",
-                HrLabel = "Destination file",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                HrLabel = "Window name",
-            },
+            new BoolStateChild("Option") { PocoProperty = "IncludeDetailsForAnalysisTools", HrLabel = "Include details for analysis tools" },
+            // FM 26 flags are bool? — absent stays distinct from "present and False".
+            new BoolStateChild("OutputEntireBinaryData") { Optional = true, Display = DisplayMode.Hidden },
+            new BoolStateChild("SpecifyJSONOptions") { Optional = true, Display = DisplayMode.Hidden },
+            // <SaXML> is emitted only when the JSON export options are set.
+            new WrapperChild("SaXML",
+            [
+                new WrapperChild("JSONOptions",
+                [
+                    new BareCalcChild { PocoProperty = "JsonOptions", Display = DisplayMode.Hidden },
+                ]),
+            ]) { PocoProperty = "JsonOptions", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsExcelStep.cs b/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsExcelStep.cs
index 272a8d3..3a470fa 100644
--- a/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsExcelStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsExcelStep.cs
@@ -1,5 +1,9 @@
+using System.Collections.Generic;
+using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -32,6 +36,44 @@ public sealed class SaveRecordsAsExcelStep : ScriptStep, IStepFactory
     public string SaveType { get; set; }
     public bool UseFieldNames { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    /// <summary>
+    /// Shape-facing view of the <c>&lt;Profile&gt;</c> element (a multi-attribute
+    /// element no shape primitive models): emitted only when the export format
+    /// differs from the defaults, and parsed back through the shape's
+    /// passthrough slot.
+    /// </summary>
+    public List<XElement> ProfileWire
+    {
+        get
+        {
+            var profileDefault = FieldDelimiter == "\t" && IsPredefined == "-1"
+                && FieldNameRow == "-1" && DataType == "XLXE";
+            return profileDefault
+                ? []
+                :
+                [
+                    new XElement("Profile",
+                        new XAttribute("FieldDelimiter", FieldDelimiter),
+                        new XAttribute("IsPredefined", IsPredefined),
+                        new XAttribute("FieldNameRow", FieldNameRow),
+                        new XAttribute("DataType", DataType)),
+                ];
+        }
+        set
+        {
+            var profile = value.FirstOrDefault(e => e.Name.LocalName == "Profile");
+            FieldDelimiter = profile?.Attribute("FieldDelimiter")?.Value ?? "\t";
+            IsPredefined = profile?.Attribute("IsPredefined")?.Value ?? "-1";
+            FieldNameRow = profile?.Attribute("FieldNameRow")?.Value ?? "-1";
+            DataType = profile?.Attribute("DataType")?.Value ?? "XLXE";
+        }
+    }
+
+    private SaveRecordsAsExcelStep() : this(enabled: true) { }
+
     public SaveRecordsAsExcelStep(
         bool withDialog = false, bool createDirectories = true, bool restoreStoredOptions = true,
         bool autoOpen = false, bool createEmail = false,
@@ -60,84 +102,70 @@ public SaveRecordsAsExcelStep(
         UseFieldNames = useFieldNames;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("CreateDirectories", new XAttribute("state", CreateDirectories ? "True" : "False")),
-            new XElement("Restore", new XAttribute("state", RestoreStoredOptions ? "True" : "False")),
-            new XElement("AutoOpen", new XAttribute("state", AutoOpen ? "True" : "False")),
-            new XElement("CreateEmail", new XAttribute("state", CreateEmail ? "True" : "False")),
-            new XElement("Profile",
-                new XAttribute("FieldDelimiter", FieldDelimiter),
-                new XAttribute("IsPredefined", IsPredefined),
-                new XAttribute("FieldNameRow", FieldNameRow),
-                new XAttribute("DataType", DataType)),
-            new XElement("UniversalPathList", Path));
-        if (WorkSheet is not null) step.Add(new XElement("WorkSheet", WorkSheet.ToXml("Calculation")));
-        if (Title is not null) step.Add(new XElement("Title", Title.ToXml("Calculation")));
-        if (Subject is not null) step.Add(new XElement("Subject", Subject.ToXml("Calculation")));
-        if (Author is not null) step.Add(new XElement("Author", Author.ToXml("Calculation")));
-        step.Add(new XElement("SaveType", new XAttribute("value", SaveType)));
-        step.Add(new XElement("UseFieldNames", new XAttribute("state", UseFieldNames ? "True" : "False")));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the display line hides the option flags and shows only the dialog toggle and conditional file token — sealed state the shape renderer would surface.
     public override string ToDisplayLine() =>
         $"Save Records as Excel [ With dialog: {(WithDialog ? "On" : "Off")} ; {Path} ]";
 
-    public static new ScriptStep FromXml(XElement step)
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SaveRecordsAsExcelStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when state the display line cannot
+    /// carry is present: restore/auto-open/email/directory flags off their
+    /// unconfigured values, a configured export Profile, the doc-metadata
+    /// calcs, a non-default save type, or the use-field-names flag (the
+    /// display shows only the dialog toggle and path).
+    /// </summary>
+    public override bool IsFullyEditable =>
+        CreateDirectories && !RestoreStoredOptions && !AutoOpen && !CreateEmail
+        && FieldDelimiter == "\t" && IsPredefined == "-1" && FieldNameRow == "-1" && DataType == "XLXE"
+        && WorkSheet is null && Title is null && Subject is null && Author is null
+        && SaveType == "BrowsedRecords" && !UseFieldNames;
+
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        static Calculation? ReadCalc(XElement? parent) => parent?.Element("Calculation") is { } c ? Calculation.FromXml(c) : null;
-        var profile = step.Element("Profile");
-        return new SaveRecordsAsExcelStep(
-            step.Element("NoInteract")?.Attribute("state")?.Value != "True",
-            step.Element("CreateDirectories")?.Attribute("state")?.Value == "True",
-            step.Element("Restore")?.Attribute("state")?.Value == "True",
-            step.Element("AutoOpen")?.Attribute("state")?.Value == "True",
-            step.Element("CreateEmail")?.Attribute("state")?.Value == "True",
-            profile?.Attribute("FieldDelimiter")?.Value ?? "\t",
-            profile?.Attribute("IsPredefined")?.Value ?? "-1",
-            profile?.Attribute("FieldNameRow")?.Value ?? "-1",
-            profile?.Attribute("DataType")?.Value ?? "XLXE",
-            step.Element("UniversalPathList")?.Value ?? "",
-            ReadCalc(step.Element("WorkSheet")),
-            ReadCalc(step.Element("Title")),
-            ReadCalc(step.Element("Subject")),
-            ReadCalc(step.Element("Author")),
-            step.Element("SaveType")?.Attribute("value")?.Value ?? "BrowsedRecords",
-            step.Element("UseFieldNames")?.Attribute("state")?.Value == "True",
-            enabled);
+        // Display grammar: [ With dialog: On/Off ; path ]. Everything else
+        // takes its canonical unconfigured value.
+        bool withDialog = false;
+        string path = "";
+        foreach (var tok in hrParams)
+        {
+            var t = tok.Trim();
+            if (t.StartsWith("With dialog:", System.StringComparison.OrdinalIgnoreCase))
+                withDialog = t.Substring(12).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
+            else if (!string.IsNullOrWhiteSpace(t))
+                path = t;
+        }
+        return new SaveRecordsAsExcelStep(withDialog, restoreStoredOptions: false, path: path, enabled: enabled);
     }
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new SaveRecordsAsExcelStep(enabled: enabled);
-
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/save-records-as-excel.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "CreateDirectories", XmlElement = "CreateDirectories", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "AutoOpen", XmlElement = "AutoOpen", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "CreateEmail", XmlElement = "CreateEmail", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Profile", XmlElement = "Profile", Type = "complex" },
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text" },
-            new ParamMetadata { Name = "WorkSheet", XmlElement = "WorkSheet", Type = "namedCalc" },
-            new ParamMetadata { Name = "Title", XmlElement = "Title", Type = "namedCalc" },
-            new ParamMetadata { Name = "Subject", XmlElement = "Subject", Type = "namedCalc" },
-            new ParamMetadata { Name = "Author", XmlElement = "Author", Type = "namedCalc" },
-            new ParamMetadata { Name = "SaveType", XmlElement = "SaveType", XmlAttr = "value", Type = "enum", ValidValues = ["BrowsedRecords", "CurrentRecord"] },
-            new ParamMetadata { Name = "UseFieldNames", XmlElement = "UseFieldNames", XmlAttr = "state", Type = "boolean" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog" },
+            new BoolStateChild("CreateDirectories"),
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredOptions" },
+            new BoolStateChild("AutoOpen"),
+            new BoolStateChild("CreateEmail"),
+            // <Profile> is a multi-attribute element no primitive models; the
+            // ProfileWire view emits it only when configured and parses it
+            // back through this passthrough slot.
+            new Passthrough { PocoProperty = "ProfileWire" },
+            new HrOnly("Profile"),
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Optional = true },
+            new NamedCalcChild("WorkSheet") { Optional = true },
+            new NamedCalcChild("Title") { Optional = true },
+            new NamedCalcChild("Subject") { Optional = true },
+            new NamedCalcChild("Author") { Optional = true },
+            new EnumValueChild("SaveType") { ValidValues = ["BrowsedRecords", "CurrentRecord"], DefaultValue = "BrowsedRecords" },
+            new BoolStateChild("UseFieldNames"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsJsonlStep.cs b/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsJsonlStep.cs
index 72b8a72..bc03067 100644
--- a/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsJsonlStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsJsonlStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -30,6 +32,8 @@ public sealed class SaveRecordsAsJsonlStep : ScriptStep, IStepFactory
     public FieldRef? SourceField { get; set; }
     public NamedRef? Table { get; set; }
 
+    private SaveRecordsAsJsonlStep() : base(false) { Path = ""; }
+
     public SaveRecordsAsJsonlStep(
         bool optionEnableTable = false, bool createDirectories = false, bool fineTuneFormat = true,
         bool autoOpen = false, bool createEmail = false,
@@ -53,78 +57,72 @@ public SaveRecordsAsJsonlStep(
         Table = table;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Option", new XAttribute("state", OptionEnableTable ? "True" : "False")),
-            new XElement("CreateDirectories", new XAttribute("state", CreateDirectories ? "True" : "False")),
-            new XElement("FineTuneFormat", new XAttribute("state", FineTuneFormat ? "True" : "False")),
-            new XElement("AutoOpen", new XAttribute("state", AutoOpen ? "True" : "False")),
-            new XElement("CreateEmail", new XAttribute("state", CreateEmail ? "True" : "False")),
-            new XElement("UniversalPathList", Path));
-        if (CompletionField is not null) step.Add(CompletionField.ToXml("Field"));
-        var bulk = new XElement("SaveAsJSONL");
-        if (FineTuneFormat)
-        {
-            if (SystemPrompt is not null) bulk.Add(new XElement("SystemPrompt", SystemPrompt.ToXml("Calculation")));
-            if (UserPrompt is not null) bulk.Add(new XElement("UserPrompt", UserPrompt.ToXml("Calculation")));
-            if (AssistantPrompt is not null) bulk.Add(new XElement("AssistantPrompt", AssistantPrompt.ToXml("Calculation")));
-        }
-        else
-        {
-            if (SourceField is not null) bulk.Add(SourceField.ToXml("Field"));
-        }
-        step.Add(bulk);
-        if (Table is not null) step.Add(Table.ToXml("Table"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the display line shows only the conditional file and format tokens, hiding the option flags the shape renderer would surface.
     public override string ToDisplayLine() =>
         $"Save Records as JSONL [ {Path} ; Format: {(FineTuneFormat ? "Fine-Tune" : "Completion")} ]";
 
-    public static new ScriptStep FromXml(XElement step)
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SaveRecordsAsJsonlStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when state the display line cannot
+    /// carry is present: prompt calcs, completion/source fields, a table
+    /// reference, or the flags the display grammar does not show (it carries
+    /// only the path and format).
+    /// </summary>
+    public override bool IsFullyEditable =>
+        !OptionEnableTable && !CreateDirectories && !AutoOpen && !CreateEmail
+        && SystemPrompt is null && UserPrompt is null && AssistantPrompt is null
+        && CompletionField is null && SourceField is null && Table is null;
+
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        static Calculation? ReadCalc(XElement? parent) => parent?.Element("Calculation") is { } c ? Calculation.FromXml(c) : null;
-        var bulk = step.Element("SaveAsJSONL");
-        var topField = step.Element("Field");
-        var tableEl = step.Element("Table");
-        return new SaveRecordsAsJsonlStep(
-            step.Element("Option")?.Attribute("state")?.Value == "True",
-            step.Element("CreateDirectories")?.Attribute("state")?.Value == "True",
-            step.Element("FineTuneFormat")?.Attribute("state")?.Value == "True",
-            step.Element("AutoOpen")?.Attribute("state")?.Value == "True",
-            step.Element("CreateEmail")?.Attribute("state")?.Value == "True",
-            step.Element("UniversalPathList")?.Value ?? "",
-            ReadCalc(bulk?.Element("SystemPrompt")),
-            ReadCalc(bulk?.Element("UserPrompt")),
-            ReadCalc(bulk?.Element("AssistantPrompt")),
-            topField is not null ? FieldRef.FromXml(topField) : null,
-            bulk?.Element("Field") is { } sf ? FieldRef.FromXml(sf) : null,
-            tableEl is not null ? NamedRef.FromXml(tableEl) : null,
-            enabled);
+        // Display grammar: [ path ; Format: Fine-Tune/Completion ].
+        string path = "";
+        bool fineTuneFormat = false;
+        foreach (var tok in hrParams)
+        {
+            var t = tok.Trim();
+            if (t.StartsWith("Format:", System.StringComparison.OrdinalIgnoreCase))
+                fineTuneFormat = t.Substring(7).Trim().Equals("Fine-Tune", System.StringComparison.OrdinalIgnoreCase);
+            else if (!string.IsNullOrWhiteSpace(t))
+                path = t;
+        }
+        return new SaveRecordsAsJsonlStep(fineTuneFormat: fineTuneFormat, path: path, enabled: enabled);
     }
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
-        new SaveRecordsAsJsonlStep(enabled: enabled);
-
     public static StepMetadata Metadata { get; } = new()
     {
         Name = XmlName,
         Id = XmlId,
         Category = "files",
-        Params =
+        // Canonical order: five always-emitted flags, the optional path, an
+        // optional top-level completion Field, the always-emitted SaveAsJSONL
+        // wrapper (empty when unconfigured) holding the optional prompt calcs and
+        // the inner source Field, then an optional Table. Each non-flag child is
+        // Optional so the unconfigured form emits only the flags and empty wrapper.
+        Shape =
         [
-            new ParamMetadata { Name = "Option", XmlElement = "Option", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "CreateDirectories", XmlElement = "CreateDirectories", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "FineTuneFormat", XmlElement = "FineTuneFormat", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "AutoOpen", XmlElement = "AutoOpen", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "CreateEmail", XmlElement = "CreateEmail", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text" },
-            new ParamMetadata { Name = "SaveAsJSONL", XmlElement = "SaveAsJSONL", Type = "complex" },
+            new BoolStateChild("Option") { PocoProperty = "OptionEnableTable" },
+            new BoolStateChild("CreateDirectories") { PocoProperty = "CreateDirectories" },
+            new BoolStateChild("FineTuneFormat") { PocoProperty = "FineTuneFormat" },
+            new BoolStateChild("AutoOpen") { PocoProperty = "AutoOpen" },
+            new BoolStateChild("CreateEmail") { PocoProperty = "CreateEmail" },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Optional = true },
+            new FieldChild() { PocoProperty = "CompletionField", Optional = true, Display = DisplayMode.Hidden },
+            new WrapperChild("SaveAsJSONL",
+            [
+                new NamedCalcChild("SystemPrompt") { PocoProperty = "SystemPrompt", Optional = true, Display = DisplayMode.Hidden },
+                new NamedCalcChild("UserPrompt") { PocoProperty = "UserPrompt", Optional = true, Display = DisplayMode.Hidden },
+                new NamedCalcChild("AssistantPrompt") { PocoProperty = "AssistantPrompt", Optional = true, Display = DisplayMode.Hidden },
+                new FieldChild() { PocoProperty = "SourceField", Optional = true, Display = DisplayMode.Hidden },
+            ]),
+            // The wrapper's mode-specific contents surface as one opaque
+            // display slot, mirroring the legacy SaveAsJSONL param.
+            new HrOnly("SaveAsJSONL"),
+            new NamedRefChild("Table") { PocoProperty = "Table", Optional = true, Display = DisplayMode.Hidden },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsPdfStep.cs b/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsPdfStep.cs
index 3d26a09..751de67 100644
--- a/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsPdfStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsPdfStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -19,6 +21,11 @@ public sealed class SaveRecordsAsPdfStep : ScriptStep, IStepFactory
     public Calculation? StoredLabel { get; set; }
     public PdfOptions? Options { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteractState { get => !WithDialog; set => WithDialog = !value; }
+
+    private SaveRecordsAsPdfStep() : this(enabled: true) { }
+
     public SaveRecordsAsPdfStep(
         bool withDialog = false,
         bool append = false,
@@ -43,24 +50,9 @@ public SaveRecordsAsPdfStep(
         Options = options;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("Option", new XAttribute("state", Append ? "True" : "False")),
-            new XElement("CreateDirectories", new XAttribute("state", CreateDirectories ? "True" : "False")),
-            new XElement("Restore", new XAttribute("state", RestoreStoredOptions ? "True" : "False")),
-            new XElement("AutoOpen", new XAttribute("state", AutoOpen ? "True" : "False")),
-            new XElement("CreateEmail", new XAttribute("state", CreateEmail ? "True" : "False")),
-            new XElement("UniversalPathList", Path));
-        if (StoredLabel is not null) step.Add(StoredLabel.ToXml("Calculation"));
-        if (Options is not null) step.Add(Options.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: conditional file and Append tokens plus hidden option flags are grammar the shape renderer cannot express.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string>
@@ -74,26 +66,34 @@ public override string ToDisplayLine()
         return $"Save Records as PDF [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var append = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var createDirs = step.Element("CreateDirectories")?.Attribute("state")?.Value == "True";
-        var restore = step.Element("Restore")?.Attribute("state")?.Value == "True";
-        var autoOpen = step.Element("AutoOpen")?.Attribute("state")?.Value == "True";
-        var createEmail = step.Element("CreateEmail")?.Attribute("state")?.Value == "True";
-        var path = step.Element("UniversalPathList")?.Value ?? "";
-        var labelEl = step.Element("Calculation");
-        var label = labelEl is not null ? Calculation.FromXml(labelEl) : null;
-        var optsEl = step.Element("PDFOptions");
-        var opts = optsEl is not null ? PdfOptions.FromXml(optsEl) : null;
-        return new SaveRecordsAsPdfStep(withDialog, append, createDirs, restore, autoOpen, createEmail, path, label, opts, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SaveRecordsAsPdfStep>(step, Metadata);
+
+    /// <summary>
+    /// The canonical PDFOptions block FileMaker writes for an unconfigured
+    /// step: all-pages document numbered from 1 with a 1–1 page range, and
+    /// default security/view settings.
+    /// </summary>
+    internal static PdfOptions DefaultOptions() => new(
+        "RecordsBeingBrowsed",
+        null,
+        new PdfDocument(null, null, null, null, true,
+            new Calculation("1"), new Calculation("1"), new Calculation("1")),
+        PdfSecurity.Default(),
+        PdfView.Default());
+
+    /// <summary>
+    /// Display edits are anchor-preserved when state the display line cannot
+    /// carry is present: restored stored options (and their label), a
+    /// disabled create-directories flag, or a PDFOptions block configured
+    /// beyond the canonical unconfigured form.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        !RestoreStoredOptions && StoredLabel is null && CreateDirectories
+        && DefaultOptions().Equals(Options);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        // Lossy — full PDFOptions can't round-trip through display.
         bool withDialog = false, append = false, autoOpen = false, createEmail = false;
         string path = "";
         bool pathSeen = false;
@@ -107,7 +107,7 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
             else if (t.Equals("Create email", System.StringComparison.OrdinalIgnoreCase)) createEmail = true;
             else if (!pathSeen && !string.IsNullOrWhiteSpace(t)) { path = t; pathSeen = true; }
         }
-        return new SaveRecordsAsPdfStep(withDialog, append, true, true, autoOpen, createEmail, path, null, null, enabled);
+        return new SaveRecordsAsPdfStep(withDialog, append, true, false, autoOpen, createEmail, path, null, DefaultOptions(), enabled);
     }
 
     public static StepMetadata Metadata { get; } = new()
@@ -116,16 +116,19 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/save-records-as-pdf.html",
-        Params =
+        // Canonical: six state flags, then the optional path, the optional
+        // stored-label calc, and the PDFOptions block which owns its own shape.
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "Option", XmlElement = "Option", XmlAttr = "state", Type = "boolean", HrLabel = "Append" },
-            new ParamMetadata { Name = "CreateDirectories", XmlElement = "CreateDirectories", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "AutoOpen", XmlElement = "AutoOpen", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "CreateEmail", XmlElement = "CreateEmail", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "UniversalPathList", XmlElement = "UniversalPathList", Type = "text", Required = true },
-            new ParamMetadata { Name = "PDFOptions", XmlElement = "PDFOptions", Type = "complex" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteractState", HrLabel = "With dialog" },
+            new BoolStateChild("Option") { PocoProperty = "Append", HrLabel = "Append" },
+            new BoolStateChild("CreateDirectories"),
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredOptions" },
+            new BoolStateChild("AutoOpen"),
+            new BoolStateChild("CreateEmail"),
+            new NamedTextChild("UniversalPathList") { PocoProperty = "Path", Optional = true },
+            new BareCalcChild { PocoProperty = "StoredLabel", Optional = true },
+            new ValueTypeChild("PDFOptions") { PocoProperty = "Options", Optional = true, Display = DisplayMode.Hidden },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsSnapshotLinkStep.cs b/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsSnapshotLinkStep.cs
index d92d2c6..08325f0 100644
--- a/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsSnapshotLinkStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SaveRecordsAsSnapshotLinkStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -16,6 +18,8 @@ public sealed class SaveRecordsAsSnapshotLinkStep : ScriptStep, IStepFactory
     public string Records { get; set; }
     public string OutputPath { get; set; }
 
+    private SaveRecordsAsSnapshotLinkStep() : base(false) { }
+
     public SaveRecordsAsSnapshotLinkStep(
         bool createFolders = false,
         bool createEmail = false,
@@ -30,62 +34,15 @@ public SaveRecordsAsSnapshotLinkStep(
         OutputPath = outputPath;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _RecordsToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["BrowsedRecords"] = "Records being browsed",
-        ["CurrentRecord"] = "Current record",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _RecordsFromHr =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["Records being browsed"] = "BrowsedRecords",
-        ["Current record"] = "CurrentRecord",
-    };
-
-    private static string RecordsHr(string x) =>
-        _RecordsToHr.TryGetValue(x, out var h) ? h : x;
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string RecordsXml(string h) =>
-        _RecordsFromHr.TryGetValue(h, out var x) ? x : h;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("CreateDirectories", new XAttribute("state", CreateFolders ? "True" : "False")),
-            new XElement("CreateEmail", new XAttribute("state", CreateEmail ? "True" : "False")),
-            new XElement("SaveType", new XAttribute("value", Records)),
-            new XElement("UniversalPathList", OutputPath));
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SaveRecordsAsSnapshotLinkStep>(step, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Save Records as Snapshot Link [ " + "Create folders: " + (CreateFolders ? "On" : "Off") + " ; " + "Create email: " + (CreateEmail ? "On" : "Off") + " ; " + "Records: " + RecordsHr(Records) + " ; " + "Output path: " + OutputPath + " ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var createFolders_v = step.Element("CreateDirectories")?.Attribute("state")?.Value == "True";
-        var createEmail_v = step.Element("CreateEmail")?.Attribute("state")?.Value == "True";
-        var records_v = step.Element("SaveType")?.Attribute("value")?.Value ?? "BrowsedRecords";
-        var outputPath_v = step.Element("UniversalPathList")?.Value ?? "";
-        return new SaveRecordsAsSnapshotLinkStep(createFolders_v, createEmail_v, records_v, outputPath_v, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool createFolders_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Create folders:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(15).Trim(); createFolders_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool createEmail_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Create email:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(13).Trim(); createEmail_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        string records_v = "BrowsedRecords";
-        foreach (var tok in tokens) { if (tok.StartsWith("Records:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(8).Trim(); records_v = RecordsXml(v); break; } }
-        string outputPath_v = "";
-        foreach (var tok in tokens) { if (tok.StartsWith("Output path:", StringComparison.OrdinalIgnoreCase)) { outputPath_v = tok.Substring(12).Trim(); break; } }
-        return new SaveRecordsAsSnapshotLinkStep(createFolders_v, createEmail_v, records_v, outputPath_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SaveRecordsAsSnapshotLinkStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -93,45 +50,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "records",
         HelpUrl = "https://help.claris.com/en/pro-help/content/save-records-as-snapshot-link.html",
-        Params =
+        // Canonical: CreateDirectories, CreateEmail, SaveType, then the path list
+        // which the unconfigured form omits (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "CreateDirectories",
-                XmlElement = "CreateDirectories",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Create folders",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "CreateEmail",
-                XmlElement = "CreateEmail",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "Create email",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "SaveType",
-                XmlElement = "SaveType",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Records",
-                ValidValues = ["Records being browsed", "Current record"],
-                DefaultValue = "BrowsedRecords",
-            },
-            new ParamMetadata
-            {
-                Name = "UniversalPathList",
-                XmlElement = "UniversalPathList",
-                Type = "text",
-                HrLabel = "Output path",
-            },
+            new BoolStateChild("CreateDirectories") { PocoProperty = "CreateFolders", HrLabel = "Create folders", Display = DisplayMode.Native },
+            new BoolStateChild("CreateEmail") { PocoProperty = "CreateEmail", HrLabel = "Create email", Display = DisplayMode.Native },
+            new EnumValueChild("SaveType") { PocoProperty = "Records", HrLabel = "Records", DefaultValue = "BrowsedRecords", ValidValues = ["BrowsedRecords", "CurrentRecord"], DisplayValues = ["Records being browsed", "Current record"], Display = DisplayMode.Native },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "OutputPath", HrLabel = "Output path", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ScrollWindowStep.cs b/src/SharpFM.Model/Scripting/Steps/ScrollWindowStep.cs
index 3de4a59..0ce67c8 100644
--- a/src/SharpFM.Model/Scripting/Steps/ScrollWindowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ScrollWindowStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,7 +19,9 @@ public sealed class ScrollWindowStep : ScriptStep, IStepFactory
     public const string XmlName = "Scroll Window";
 
     /// <summary>The enum XML value emitted on the <c>&lt;ScrollOperation&gt;</c> element.</summary>
-    public string Direction { get; set; }
+    public string Direction { get; set; } = "Home";
+
+    private ScrollWindowStep() : base(false) { }
 
     public ScrollWindowStep(string direction = "Home", bool enabled = true)
         : base(enabled)
@@ -25,58 +29,15 @@ public ScrollWindowStep(string direction = "Home", bool enabled = true)
         Direction = direction;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _xmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["Home"] = "Home",
-        ["End"] = "End",
-        ["PageUp"] = "Page Up",
-        ["PageDown"] = "Page Down",
-        ["ToSelection"] = "To Selection",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _hrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["Home"] = "Home",
-        ["End"] = "End",
-        ["Page Up"] = "PageUp",
-        ["Page Down"] = "PageDown",
-        ["To Selection"] = "ToSelection",
-    };
-
-    private static string ToHr(string xmlValue) =>
-        _xmlToHr.TryGetValue(xmlValue, out var hr) ? hr : xmlValue;
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string FromHr(string hrValue) =>
-        _hrToXml.TryGetValue(hrValue, out var xml) ? xml : hrValue;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ScrollOperation",
-                new XAttribute("value", Direction)));
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ScrollWindowStep>(step, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Scroll Window [ Direction: {ToHr(Direction)} ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var value = step.Element("ScrollOperation")?.Attribute("value")?.Value ?? "Home";
-        return new ScrollWindowStep(value, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "Direction:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        return new ScrollWindowStep(FromHr(token), enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ScrollWindowStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -84,17 +45,17 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/scroll-window.html",
-        Params =
+        // Canonical: a single ScrollOperation enum child.
+        Shape =
         [
-            new ParamMetadata
+            new EnumValueChild("ScrollOperation")
             {
-                Name = "ScrollOperation",
-                XmlElement = "ScrollOperation",
-                Type = "enum",
-                XmlAttr = "value",
+                PocoProperty = "Direction",
                 HrLabel = "Direction",
                 DefaultValue = "Home",
-                ValidValues = ["Home", "End", "Page Up", "Page Down", "To Selection"],
+                ValidValues = ["Home", "End", "PageUp", "PageDown", "ToSelection"],
+                DisplayValues = ["Home", "End", "Page Up", "Page Down", "To Selection"],
+                Display = DisplayMode.Native,
             },
         ],
         FromXml = FromXml,
diff --git a/src/SharpFM.Model/Scripting/Steps/SelectAllStep.cs b/src/SharpFM.Model/Scripting/Steps/SelectAllStep.cs
index f7769bc..bf11452 100644
--- a/src/SharpFM.Model/Scripting/Steps/SelectAllStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SelectAllStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class SelectAllStep : ScriptStep, IStepFactory
     public const int XmlId = 50;
     public const string XmlName = "Select All";
 
+    private SelectAllStep() : base(false) { }
+
     public SelectAllStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new SelectAllStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<SelectAllStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new SelectAllStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SelectAllStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/SelectDictionariesStep.cs b/src/SharpFM.Model/Scripting/Steps/SelectDictionariesStep.cs
index 8ab154d..e8051b4 100644
--- a/src/SharpFM.Model/Scripting/Steps/SelectDictionariesStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SelectDictionariesStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class SelectDictionariesStep : ScriptStep, IStepFactory
     public const int XmlId = 108;
     public const string XmlName = "Select Dictionaries";
 
+    private SelectDictionariesStep() : base(false) { }
+
     public SelectDictionariesStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new SelectDictionariesStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<SelectDictionariesStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new SelectDictionariesStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SelectDictionariesStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/SelectWindowStep.cs b/src/SharpFM.Model/Scripting/Steps/SelectWindowStep.cs
index f38fb37..8e53c8d 100644
--- a/src/SharpFM.Model/Scripting/Steps/SelectWindowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SelectWindowStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,8 +15,10 @@ public sealed class SelectWindowStep : ScriptStep, IStepFactory
     public const string XmlName = "Select Window";
 
     public bool CurrentFile { get; set; }
-    public string Window { get; set; }
-    public Calculation Name { get; set; }
+    public string Window { get; set; } = "ByName";
+    public Calculation Name { get; set; } = new("");
+
+    private SelectWindowStep() : base(false) { }
 
     public SelectWindowStep(
         bool currentFile = true,
@@ -28,53 +32,15 @@ public SelectWindowStep(
         Name = name ?? new Calculation("");
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _WindowToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal) {
-        ["ByName"] = "Name: <calc>",
-        ["Current"] = "Current Window",
-    };
-    private static readonly IReadOnlyDictionary<string, string> _WindowFromHr =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {
-        ["Name: <calc>"] = "ByName",
-        ["Current Window"] = "Current",
-    };
-    private static string WindowHr(string x) => _WindowToHr.TryGetValue(x, out var h) ? h : x;
-    private static string WindowXml(string h) => _WindowFromHr.TryGetValue(h, out var x) ? x : h;
-
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("LimitToWindowsOfCurrentFile", new XAttribute("state", CurrentFile ? "True" : "False")),
-            new XElement("Window", new XAttribute("value", Window)),
-            new XElement("Name", Name.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Select Window [ " + "Current file: " + (CurrentFile ? "On" : "Off") + " ; " + "Window: " + WindowHr(Window) + " ; " + "Name: " + Name.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var currentFile_v = step.Element("LimitToWindowsOfCurrentFile")?.Attribute("state")?.Value == "True";
-        var window_v = step.Element("Window")?.Attribute("value")?.Value ?? "ByName";
-        var name_vWrapEl = step.Element("Name");
-        var name_vCalcEl = name_vWrapEl?.Element("Calculation");
-        var name_v = name_vCalcEl is not null ? Calculation.FromXml(name_vCalcEl) : new Calculation("");
-        return new SelectWindowStep(currentFile_v, window_v, name_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SelectWindowStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool currentFile_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Current file:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(13).Trim(); currentFile_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        string window_v = "ByName";
-        foreach (var tok in tokens) { if (tok.StartsWith("Window:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); window_v = WindowXml(v); break; } }
-        Calculation? name_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Name:", StringComparison.OrdinalIgnoreCase)) { name_v = new Calculation(tok.Substring(5).Trim()); break; } }
-        return new SelectWindowStep(currentFile_v, window_v, name_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SelectWindowStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -82,35 +48,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/select-window.html",
-        Params =
+        // Canonical: LimitToWindowsOfCurrentFile, Window, then the optional
+        // <Name> calculation (present only in the ByName form).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "LimitToWindowsOfCurrentFile",
-                XmlElement = "LimitToWindowsOfCurrentFile",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "Current file",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Window",
-                XmlElement = "Window",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Window",
-                ValidValues = ["Name: <calc>", "Current Window"],
-                DefaultValue = "ByName",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Name",
-            },
+            new BoolStateChild("LimitToWindowsOfCurrentFile") { PocoProperty = "CurrentFile", HrLabel = "Current file", Display = DisplayMode.Native },
+            new EnumValueChild("Window") { PocoProperty = "Window", HrLabel = "Window", DefaultValue = "ByName", ValidValues = ["ByName", "Current"], DisplayValues = ["Name: <calc>", "Current Window"], Display = DisplayMode.Native },
+            new NamedCalcChild("Name") { PocoProperty = "Name", HrLabel = "Name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SendDDEExecuteStep.cs b/src/SharpFM.Model/Scripting/Steps/SendDDEExecuteStep.cs
index dd03a87..9359cc9 100644
--- a/src/SharpFM.Model/Scripting/Steps/SendDDEExecuteStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SendDDEExecuteStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -19,53 +21,26 @@ public sealed class SendDDEExecuteStep : ScriptStep, IStepFactory
     /// <summary>The enum XML value emitted on the <c>&lt;ContentType&gt;</c> element.</summary>
     public string ContentType { get; set; }
 
+    private SendDDEExecuteStep() : base(false)
+    {
+        ContentType = "File";
+    }
+
     public SendDDEExecuteStep(string contentType = "File", bool enabled = true)
         : base(enabled)
     {
         ContentType = contentType;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _xmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["File"] = "File",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _hrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["File"] = "File",
-    };
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string ToHr(string xmlValue) =>
-        _xmlToHr.TryGetValue(xmlValue, out var hr) ? hr : xmlValue;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    private static string FromHr(string hrValue) =>
-        _hrToXml.TryGetValue(hrValue, out var xml) ? xml : hrValue;
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SendDDEExecuteStep>(step, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ContentType",
-                new XAttribute("value", ContentType)));
-
-    public override string ToDisplayLine() =>
-        $"Send DDE Execute [ {ToHr(ContentType)} ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var value = step.Element("ContentType")?.Attribute("value")?.Value ?? "File";
-        return new SendDDEExecuteStep(value, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        return new SendDDEExecuteStep(FromHr(token), enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SendDDEExecuteStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -73,17 +48,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/send-dde-execute-windows.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "ContentType",
-                XmlElement = "ContentType",
-                Type = "enum",
-                XmlAttr = "value",
-                DefaultValue = "File",
-                ValidValues = ["File"],
-            },
+            new EnumValueChild("ContentType") { PocoProperty = "ContentType", DefaultValue = "File", ValidValues = ["File"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SendEventStep.cs b/src/SharpFM.Model/Scripting/Steps/SendEventStep.cs
index 09a3b1d..20a3bd0 100644
--- a/src/SharpFM.Model/Scripting/Steps/SendEventStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SendEventStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -19,10 +21,21 @@ public sealed class SendEventStep : ScriptStep, IStepFactory
     public const int XmlId = 57;
     public const string XmlName = "Send Event";
 
-    public string ContentType { get; set; }
+    public string ContentType { get; set; } = "Text";
     public Calculation? Calculation { get; set; }
-    public string Text { get; set; }
-    public SendEventTarget Event { get; set; }
+    public string Text { get; set; } = "";
+    public SendEventTarget Event { get; set; } = SendEventTarget.Default();
+
+    /// <summary>
+    /// Display edits are anchor-preserved when the event carries behaviour
+    /// state the display line cannot express: the copy/wait/foreground flags
+    /// and the target type never appear in display text, so any non-baseline
+    /// value seals the step.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        Event is { CopyResultToClipboard: false, WaitForCompletion: false, BringTargetToForeground: false, TargetType: "" };
+
+    private SendEventStep() : base(false) { }
 
     public SendEventStep(
         string contentType = "Text",
@@ -38,19 +51,9 @@ public SendEventStep(
         Event = evt ?? SendEventTarget.Default();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ContentType", new XAttribute("value", ContentType)));
-        if (Calculation is not null) step.Add(Calculation.ToXml("Calculation"));
-        step.Add(string.IsNullOrEmpty(Text) ? new XElement("Text") : new XElement("Text", Text));
-        step.Add(Event.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: fixed empty-slot tokens plus the synthetic <file> placeholder — grammar the shape renderer cannot express.
     public override string ToDisplayLine()
     {
         var content = ContentType switch
@@ -63,24 +66,40 @@ public override string ToDisplayLine()
         return $"Send Event [ {Event.TargetName} ; {Event.Class} ; {Event.Id} ; {content} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var contentType = step.Element("ContentType")?.Attribute("value")?.Value ?? "Text";
-        var calcEl = step.Element("Calculation");
-        var calc = calcEl is not null ? Values.Calculation.FromXml(calcEl) : null;
-        var text = step.Element("Text")?.Value ?? "";
-        var eventEl = step.Element("Event");
-        var evt = eventEl is not null ? SendEventTarget.FromXml(eventEl) : SendEventTarget.Default();
-        return new SendEventStep(contentType, calc, text, evt, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SendEventStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        // Display form is lossy for Send Event (event attrs can't all be
-        // round-tripped through display). Best-effort parse; full fidelity
-        // is only via XML round-trip.
-        return new SendEventStep(enabled: enabled);
+        // Display shape is positional: [ targetName ; class ; id ; content ].
+        // The event's behaviour flags and target type are not displayable —
+        // instances carrying them are sealed (see IsFullyEditable).
+        var tokens = Array.ConvertAll(hrParams, h => h.Trim());
+        var targetName = tokens.Length >= 1 ? tokens[0] : "";
+        var cls = tokens.Length >= 2 ? tokens[1] : "";
+        var id = tokens.Length >= 3 ? tokens[2] : "";
+        var content = tokens.Length >= 4 ? tokens[3] : "";
+
+        string contentType;
+        Calculation? calculation = null;
+        string text = "";
+        if (content == "<file>")
+            contentType = "File";
+        else if (content.Length >= 2 && content.StartsWith("\"", StringComparison.Ordinal) && content.EndsWith("\"", StringComparison.Ordinal))
+        {
+            contentType = "Text";
+            text = content.Substring(1, content.Length - 2);
+        }
+        else if (content.Length > 0)
+        {
+            contentType = "Calculation";
+            calculation = new Calculation(content);
+        }
+        else
+            contentType = "Text";
+
+        var evt = new SendEventTarget(false, false, false, "", targetName, id, cls);
+        return new SendEventStep(contentType, calculation, text, evt, enabled);
     }
 
     public static StepMetadata Metadata { get; } = new()
@@ -89,12 +108,15 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/send-event.html",
-        Params =
+        // Canonical: ContentType, optional Calculation, optional Text, then Event.
+        Shape =
         [
-            new ParamMetadata { Name = "ContentType", XmlElement = "ContentType", XmlAttr = "value", Type = "enum", ValidValues = ["Text", "File", "Calculation"], DefaultValue = "Text", Required = true },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation" },
-            new ParamMetadata { Name = "Text", XmlElement = "Text", Type = "text" },
-            new ParamMetadata { Name = "Event", XmlElement = "Event", Type = "complex", Required = true },
+            new EnumValueChild("ContentType") { PocoProperty = "ContentType", DefaultValue = "Text", Display = DisplayMode.Hidden },
+            new HrOnly("ContentType") { DisplayValues = ["Text", "File", "Calculation"] },
+            new BareCalcChild { PocoProperty = "Calculation", Optional = true, Display = DisplayMode.Native },
+            new NamedTextChild("Text") { PocoProperty = "Text", Optional = true, Display = DisplayMode.Native },
+            new ValueTypeChild("Event") { PocoProperty = "Event", Display = DisplayMode.Hidden },
+            new HrOnly("Event"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SendMailStep.cs b/src/SharpFM.Model/Scripting/Steps/SendMailStep.cs
index c11bd82..1b49271 100644
--- a/src/SharpFM.Model/Scripting/Steps/SendMailStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SendMailStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -31,6 +33,28 @@ public sealed class SendMailStep : ScriptStep, IStepFactory
     public bool WithDialog { get; set; }
     public StepChildBag Children { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+
+    /// <summary>
+    /// Display edits are anchor-preserved when the child bag is populated:
+    /// the display line carries only the dialog flag (plus To/Subject
+    /// annotations), never the bag's SMTP/OAuth/recipient elements.
+    /// </summary>
+    public override bool IsFullyEditable => Children.Children.Count == 0;
+
+    /// <summary>Shape-facing view of <see cref="Children"/> for the trailing passthrough slot.</summary>
+    public List<XElement> ExtraChildren
+    {
+        get => Children.Children.ToList();
+        set => Children = new StepChildBag(value);
+    }
+
+    private SendMailStep() : base(false)
+    {
+        Children = new StepChildBag();
+    }
+
     public SendMailStep(bool withDialog = true, StepChildBag? children = null, bool enabled = true)
         : base(enabled)
     {
@@ -38,17 +62,10 @@ public SendMailStep(bool withDialog = true, StepChildBag? children = null, bool
         Children = children ?? new StepChildBag();
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")));
-        Children.AppendTo(step);
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the To/Subject annotations are conditional tokens read
+    // from the passthrough child bag, which the shape renderer cannot surface.
     public override string ToDisplayLine()
     {
         var parts = new List<string>();
@@ -58,30 +75,11 @@ public override string ToDisplayLine()
         return $"Send Mail [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        // Skip NoInteract — it's already captured as WithDialog; preserve
-        // everything else verbatim.
-        var children = step.Elements()
-            .Where(e => e.Name.LocalName != "NoInteract")
-            .ToList();
-        return new SendMailStep(withDialog, new StepChildBag(children), enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SendMailStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        // Display is inherently lossy — 30 params can't survive a short form.
-        bool withDialog = true;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("With dialog:", StringComparison.OrdinalIgnoreCase))
-                withDialog = t.Substring(12).Trim().Equals("On", StringComparison.OrdinalIgnoreCase);
-        }
-        return new SendMailStep(withDialog, null, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SendMailStep>(enabled, hrParams, Metadata);
 
     // --- Hot-field accessors (read through the bag) ---
 
@@ -104,14 +102,17 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/send-mail.html",
-        Params =
+        // NoInteract (inverse of WithDialog) followed by every other child
+        // preserved verbatim — the hybrid StepChildBag round-trip.
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "To", XmlElement = "To", Type = "namedCalc", HrLabel = "To" },
-            new ParamMetadata { Name = "Cc", XmlElement = "Cc", Type = "namedCalc", HrLabel = "Cc" },
-            new ParamMetadata { Name = "Bcc", XmlElement = "Bcc", Type = "namedCalc", HrLabel = "Bcc" },
-            new ParamMetadata { Name = "Subject", XmlElement = "Subject", Type = "namedCalc", HrLabel = "Subject" },
-            new ParamMetadata { Name = "Message", XmlElement = "Message", Type = "namedCalc", HrLabel = "Message" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteract", HrLabel = "With dialog", DisplayInverted = true },
+            new Passthrough { PocoProperty = "ExtraChildren" },
+            new HrOnly("To") { HrLabel = "To" },
+            new HrOnly("Cc") { HrLabel = "Cc" },
+            new HrOnly("Bcc") { HrLabel = "Bcc" },
+            new HrOnly("Subject") { HrLabel = "Subject" },
+            new HrOnly("Message") { HrLabel = "Message" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetAICallLoggingStep.cs b/src/SharpFM.Model/Scripting/Steps/SetAICallLoggingStep.cs
index 9c9119c..29584f2 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetAICallLoggingStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetAICallLoggingStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -21,6 +23,8 @@ public sealed class SetAICallLoggingStep : ScriptStep, IStepFactory
     public bool Verbose { get; set; }
     public bool TruncateMessages { get; set; }
 
+    private SetAICallLoggingStep() : base(false) { }
+
     public SetAICallLoggingStep(
         bool logging = false,
         Calculation? fileName = null,
@@ -35,24 +39,11 @@ public SetAICallLoggingStep(
         TruncateMessages = truncateMessages;
     }
 
-    public override XElement ToXml()
-    {
-        var debugLog = new XElement("LLMDebugLog");
-        if (FileName is not null)
-            debugLog.Add(new XElement("FileName", FileName.ToXml("Calculation")));
-        if (Verbose)
-            debugLog.Add(new XElement("VerboseMode"));
-        if (TruncateMessages)
-            debugLog.Add(new XElement("TruncateEmbeddingVectorsMode"));
-
-        return new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Set", new XAttribute("state", Logging ? "True" : "False")),
-            debugLog);
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: Verbose/Truncate are wire flag elements (presence = On)
+    // but display as always-present "Label: On/Off" tokens — a form the shape
+    // renderer's bare-label FlagChild convention cannot express.
     public override string ToDisplayLine()
     {
         var parts = new System.Collections.Generic.List<string> { Logging ? "On" : "Off" };
@@ -62,23 +53,8 @@ public override string ToDisplayLine()
         return $"Set AI Call Logging [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var logging = step.Element("Set")?.Attribute("state")?.Value == "True";
-        var debugLog = step.Element("LLMDebugLog");
-        Calculation? fileName = null;
-        bool verbose = false;
-        bool truncate = false;
-        if (debugLog is not null)
-        {
-            var fileEl = debugLog.Element("FileName")?.Element("Calculation");
-            if (fileEl is not null) fileName = Calculation.FromXml(fileEl);
-            verbose = debugLog.Element("VerboseMode") is not null;
-            truncate = debugLog.Element("TruncateEmbeddingVectorsMode") is not null;
-        }
-        return new SetAICallLoggingStep(logging, fileName, verbose, truncate, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetAICallLoggingStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -110,22 +86,17 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Name = XmlName,
         Id = XmlId,
         Category = "artificial intelligence",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Set",
-                XmlElement = "Set",
-                XmlAttr = "state",
-                Type = "boolean",
-                HrLabel = "Logging",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-                Required = true,
-            },
-            new ParamMetadata { Name = "FileName", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Filename" },
-            new ParamMetadata { Name = "VerboseMode", XmlElement = "VerboseMode", Type = "flagElement", HrLabel = "Verbose" },
-            new ParamMetadata { Name = "TruncateEmbeddingVectorsMode", XmlElement = "TruncateEmbeddingVectorsMode", Type = "flagElement", HrLabel = "Truncate Messages" },
+            new BoolStateChild("Set") { PocoProperty = "Logging", HrLabel = "Logging", Required = true },
+            // The <LLMDebugLog> wrapper is always emitted, empty when no
+            // option inside it is configured.
+            new WrapperChild("LLMDebugLog",
+            [
+                new NamedCalcChild("FileName") { Optional = true, HrLabel = "Filename" },
+                new FlagChild("VerboseMode") { PocoProperty = "Verbose", HrLabel = "Verbose" },
+                new FlagChild("TruncateEmbeddingVectorsMode") { PocoProperty = "TruncateMessages", HrLabel = "Truncate Messages" },
+            ]),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetDataFilePositionStep.cs b/src/SharpFM.Model/Scripting/Steps/SetDataFilePositionStep.cs
index f08d052..cb42ed0 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetDataFilePositionStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetDataFilePositionStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,8 +14,10 @@ public sealed class SetDataFilePositionStep : ScriptStep, IStepFactory
     public const int XmlId = 195;
     public const string XmlName = "Set Data File Position";
 
-    public Calculation FileID { get; set; }
-    public Calculation NewPosition { get; set; }
+    public Calculation? FileID { get; set; }
+    public Calculation? NewPosition { get; set; }
+
+    private SetDataFilePositionStep() : base(false) { }
 
     public SetDataFilePositionStep(
         Calculation? fileID = null,
@@ -21,41 +25,19 @@ public SetDataFilePositionStep(
         bool enabled = true)
         : base(enabled)
     {
-        FileID = fileID ?? new Calculation("");
-        NewPosition = newPosition ?? new Calculation("");
+        FileID = fileID;
+        NewPosition = newPosition;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            FileID.ToXml("Calculation"),
-            new XElement("position", NewPosition.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Set Data File Position [ " + "File ID: " + FileID.Text + " ; " + "New position: " + NewPosition.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var fileID_vEl = step.Element("Calculation");
-        var fileID_v = fileID_vEl is not null ? Calculation.FromXml(fileID_vEl) : new Calculation("");
-        var newPosition_vWrapEl = step.Element("position");
-        var newPosition_vCalcEl = newPosition_vWrapEl?.Element("Calculation");
-        var newPosition_v = newPosition_vCalcEl is not null ? Calculation.FromXml(newPosition_vCalcEl) : new Calculation("");
-        return new SetDataFilePositionStep(fileID_v, newPosition_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetDataFilePositionStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? fileID_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("File ID:", StringComparison.OrdinalIgnoreCase)) { fileID_v = new Calculation(tok.Substring(8).Trim()); break; } }
-        Calculation? newPosition_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("New position:", StringComparison.OrdinalIgnoreCase)) { newPosition_v = new Calculation(tok.Substring(13).Trim()); break; } }
-        return new SetDataFilePositionStep(fileID_v, newPosition_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetDataFilePositionStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -63,22 +45,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-data-file-position.html",
-        Params =
+        // Canonical: the optional bare <Calculation> (file id) and <position>
+        // calculation; the unconfigured form is an empty step.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                HrLabel = "File ID",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "New position",
-            },
+            new BareCalcChild { PocoProperty = "FileID", HrLabel = "File ID", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new NamedCalcChild("position") { PocoProperty = "NewPosition", HrLabel = "New position", Optional = true, Display = DisplayMode.Augmented, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetDictionaryStep.cs b/src/SharpFM.Model/Scripting/Steps/SetDictionaryStep.cs
index 1ee1990..2bb28a1 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetDictionaryStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetDictionaryStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -14,6 +16,8 @@ public sealed class SetDictionaryStep : ScriptStep, IStepFactory
     public string SpellingLanguage { get; set; }
     public string UserDictionary { get; set; }
 
+    private SetDictionaryStep() : base(false) { SpellingLanguage = "US English"; UserDictionary = ""; }
+
     public SetDictionaryStep(
         string spellingLanguage = "US English",
         string userDictionary = "",
@@ -24,34 +28,15 @@ public SetDictionaryStep(
         UserDictionary = userDictionary;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("MainDictionary", new XAttribute("value", SpellingLanguage)),
-            new XElement("UniversalPathList", UserDictionary));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Set Dictionary [ " + "Spelling Language: " + SpellingLanguage + " ; " + "User Dictionary: " + UserDictionary + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var spellingLanguage_v = step.Element("MainDictionary")?.Attribute("value")?.Value ?? "US English";
-        var userDictionary_v = step.Element("UniversalPathList")?.Value ?? "";
-        return new SetDictionaryStep(spellingLanguage_v, userDictionary_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetDictionaryStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        string spellingLanguage_v = "US English";
-        foreach (var tok in tokens) { if (tok.StartsWith("Spelling Language:", StringComparison.OrdinalIgnoreCase)) { spellingLanguage_v = tok.Substring(18).Trim(); break; } }
-        string userDictionary_v = "";
-        foreach (var tok in tokens) { if (tok.StartsWith("User Dictionary:", StringComparison.OrdinalIgnoreCase)) { userDictionary_v = tok.Substring(16).Trim(); break; } }
-        return new SetDictionaryStep(spellingLanguage_v, userDictionary_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetDictionaryStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -59,24 +44,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "spelling",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-dictionary.html",
-        Params =
+        // Canonical form carries MainDictionary; the optional user-dictionary path is omitted when blank.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "MainDictionary",
-                XmlElement = "MainDictionary",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Spelling Language",
-                DefaultValue = "US English",
-            },
-            new ParamMetadata
-            {
-                Name = "UniversalPathList",
-                XmlElement = "UniversalPathList",
-                Type = "text",
-                HrLabel = "User Dictionary",
-            },
+            new EnumValueChild("MainDictionary") { PocoProperty = "SpellingLanguage", HrLabel = "Spelling Language", DefaultValue = "US English" },
+            new NamedTextChild("UniversalPathList") { PocoProperty = "UserDictionary", HrLabel = "User Dictionary", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetErrorCaptureStep.cs b/src/SharpFM.Model/Scripting/Steps/SetErrorCaptureStep.cs
index 1b7ce25..c545114 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetErrorCaptureStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetErrorCaptureStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -25,36 +27,23 @@ public sealed class SetErrorCaptureStep : ScriptStep, IStepFactory
     /// </summary>
     public bool CaptureErrors { get; set; }
 
+    private SetErrorCaptureStep() : base(false) { }
+
     public SetErrorCaptureStep(bool captureErrors = false, bool enabled = true)
         : base(enabled)
     {
         CaptureErrors = captureErrors;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Set",
-                new XAttribute("state", CaptureErrors ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Set Error Capture [ {(CaptureErrors ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("Set")?.Attribute("state")?.Value == "True";
-        return new SetErrorCaptureStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetErrorCaptureStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var captureErrors = hrParams.Length > 0
-            && hrParams[0].Trim().Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new SetErrorCaptureStep(captureErrors, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetErrorCaptureStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -63,18 +52,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-error-capture.html",
         HrSignature = "[ On|Off ]",
-        Params =
+        Shape =
         [
-            new ParamMetadata
+            new BoolStateChild("Set")
             {
-                Name = "Set",
-                XmlElement = "Set",
-                Type = "boolean",
-                XmlAttr = "state",
-                ValidValues = ["On", "Off"],
+                PocoProperty = "CaptureErrors",
+                DefaultValue = "True",
                 Description = "\"True\" (On) suppresses FileMaker Pro alert messages and some "
                     + "dialog boxes. \"False\" (Off) reenables the alert messages.",
-                DefaultValue = "True",
             },
         ],
         FromXml = FromXml,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetErrorLoggingStep.cs b/src/SharpFM.Model/Scripting/Steps/SetErrorLoggingStep.cs
index 72c9c05..90b850d 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetErrorLoggingStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetErrorLoggingStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,7 +15,9 @@ public sealed class SetErrorLoggingStep : ScriptStep, IStepFactory
     public const string XmlName = "Set Error Logging";
 
     public bool Logging { get; set; }
-    public Calculation CustomDebugInfo { get; set; }
+    public Calculation CustomDebugInfo { get; set; } = new("");
+
+    private SetErrorLoggingStep() : base(false) { }
 
     public SetErrorLoggingStep(
         bool logging = false,
@@ -25,35 +29,15 @@ public SetErrorLoggingStep(
         CustomDebugInfo = customDebugInfo ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Option", new XAttribute("state", Logging ? "True" : "False")),
-            CustomDebugInfo.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Set Error Logging [ " + "Logging: " + (Logging ? "On" : "Off") + " ; " + "Custom debug info: " + CustomDebugInfo.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var logging_v = step.Element("Option")?.Attribute("state")?.Value == "True";
-        var customDebugInfo_vEl = step.Element("Calculation");
-        var customDebugInfo_v = customDebugInfo_vEl is not null ? Calculation.FromXml(customDebugInfo_vEl) : new Calculation("");
-        return new SetErrorLoggingStep(logging_v, customDebugInfo_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetErrorLoggingStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool logging_v = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Logging:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(8).Trim(); logging_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        Calculation? customDebugInfo_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Custom debug info:", StringComparison.OrdinalIgnoreCase)) { customDebugInfo_v = new Calculation(tok.Substring(18).Trim()); break; } }
-        return new SetErrorLoggingStep(logging_v, customDebugInfo_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetErrorLoggingStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -61,25 +45,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-error-logging.html",
-        Params =
+        // Option flag then the bare custom-debug Calculation, which the
+        // unconfigured form omits (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Option",
-                XmlElement = "Option",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Logging",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                HrLabel = "Custom debug info",
-            },
+            new BoolStateChild("Option") { PocoProperty = "Logging", HrLabel = "Logging", Display = DisplayMode.Native },
+            new BareCalcChild { PocoProperty = "CustomDebugInfo", HrLabel = "Custom debug info", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetFieldByNameStep.cs b/src/SharpFM.Model/Scripting/Steps/SetFieldByNameStep.cs
index e795ae8..b1304b5 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetFieldByNameStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetFieldByNameStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,8 +14,10 @@ public sealed class SetFieldByNameStep : ScriptStep, IStepFactory
     public const int XmlId = 147;
     public const string XmlName = "Set Field By Name";
 
-    public Calculation TargetFieldName { get; set; }
-    public Calculation CalculatedResult { get; set; }
+    public Calculation TargetFieldName { get; set; } = new("");
+    public Calculation CalculatedResult { get; set; } = new("");
+
+    private SetFieldByNameStep() : base(false) { }
 
     public SetFieldByNameStep(
         Calculation? targetFieldName = null,
@@ -25,38 +29,15 @@ public SetFieldByNameStep(
         CalculatedResult = calculatedResult ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("TargetName", TargetFieldName.ToXml("Calculation")),
-            new XElement("Result", CalculatedResult.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Set Field By Name [ " + "Target field name: " + TargetFieldName.Text + " ; " + "Calculated result: " + CalculatedResult.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var targetFieldName_vWrapEl = step.Element("TargetName");
-        var targetFieldName_vCalcEl = targetFieldName_vWrapEl?.Element("Calculation");
-        var targetFieldName_v = targetFieldName_vCalcEl is not null ? Calculation.FromXml(targetFieldName_vCalcEl) : new Calculation("");
-        var calculatedResult_vWrapEl = step.Element("Result");
-        var calculatedResult_vCalcEl = calculatedResult_vWrapEl?.Element("Calculation");
-        var calculatedResult_v = calculatedResult_vCalcEl is not null ? Calculation.FromXml(calculatedResult_vCalcEl) : new Calculation("");
-        return new SetFieldByNameStep(targetFieldName_v, calculatedResult_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetFieldByNameStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? targetFieldName_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Target field name:", StringComparison.OrdinalIgnoreCase)) { targetFieldName_v = new Calculation(tok.Substring(18).Trim()); break; } }
-        Calculation? calculatedResult_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Calculated result:", StringComparison.OrdinalIgnoreCase)) { calculatedResult_v = new Calculation(tok.Substring(18).Trim()); break; } }
-        return new SetFieldByNameStep(targetFieldName_v, calculatedResult_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetFieldByNameStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -64,22 +45,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-field-by-name.html",
-        Params =
+        // TargetName and Result wrappers are omitted by the unconfigured form (Optional).
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Target field name",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Calculated result",
-            },
+            new NamedCalcChild("TargetName") { PocoProperty = "TargetFieldName", HrLabel = "Target field name", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new NamedCalcChild("Result") { PocoProperty = "CalculatedResult", HrLabel = "Calculated result", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetFieldStep.cs b/src/SharpFM.Model/Scripting/Steps/SetFieldStep.cs
index 00f2b17..db9a486 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetFieldStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetFieldStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -7,61 +9,44 @@ namespace SharpFM.Model.Scripting.Steps;
 /// <summary>
 /// Typed domain representation of FileMaker's "Set Field" script step.
 /// FM Pro emits the source XML as <c>[Calculation, Field]</c> but renders
-/// display as <c>[ Field ; Calculation ]</c>; this step honors both.
+/// display as <c>[ Field ; Calculation ]</c>; this step honors both. An
+/// unconfigured Set Field carries neither child, so both are Optional.
 /// </summary>
 public sealed class SetFieldStep : ScriptStep, IStepFactory
 {
     public const int XmlId = 76;
     public const string XmlName = "Set Field";
 
-    public FieldRef Target { get; set; }
-    public Calculation Expression { get; set; }
+    public FieldRef? Target { get; set; }
+    public Calculation? Expression { get; set; }
 
-    public SetFieldStep(bool enabled, FieldRef target, Calculation expression)
+    private SetFieldStep() : base(false) { }
+
+    public SetFieldStep(bool enabled, FieldRef? target, Calculation? expression)
         : base(enabled)
     {
         Target = target;
         Expression = expression;
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-
-        var fieldEl = step.Element("Field");
-        var target = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField(null, 0, "");
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetFieldStep>(step, Metadata);
 
-        var calcEl = step.Element("Calculation");
-        var expression = calcEl is not null ? Calculation.FromXml(calcEl) : new Calculation("");
-
-        return new SetFieldStep(enabled, target, expression);
-    }
-
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-
-        step.Add(Expression.ToXml());
-        step.Add(Target.ToXml("Field"));
-
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the display shows bare field-then-calculation tokens, the reverse of the canonical XML order; bare tokens cannot be reordered via Native/Augmented.
     public override string ToDisplayLine() =>
-        $"Set Field [ {Target.ToDisplayString()} ; {Expression.Text} ]";
+        $"Set Field [ {Target?.ToDisplayString() ?? ""} ; {Expression?.Text ?? ""} ]";
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        var target = FieldRef.ForField(null, 0, "");
-        var expression = new Calculation("");
+        FieldRef? target = null;
+        Calculation? expression = null;
 
-        if (hrParams.Length >= 1)
+        if (hrParams.Length >= 1 && hrParams[0].Trim().Length > 0)
             target = FieldRef.FromDisplayToken(hrParams[0]);
 
-        if (hrParams.Length >= 2)
+        if (hrParams.Length >= 2 && hrParams[1].Trim().Length > 0)
             expression = new Calculation(hrParams[1].Trim());
 
         return new SetFieldStep(enabled, target, expression);
@@ -73,10 +58,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-field.html",
-        Params =
+        // Canonical 076-SetField: source order is bare <Calculation> then
+        // <Field>. The unconfigured variant (-1) has neither, so both Optional.
+        Shape =
         [
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", Required = true },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation", Required = true },
+            new BareCalcChild { PocoProperty = "Expression", Optional = true },
+            new FieldChild("Field") { PocoProperty = "Target", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetLayoutObjectAnimationStep.cs b/src/SharpFM.Model/Scripting/Steps/SetLayoutObjectAnimationStep.cs
index e5fc8ab..eac1ff0 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetLayoutObjectAnimationStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetLayoutObjectAnimationStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,39 +19,23 @@ public sealed class SetLayoutObjectAnimationStep : ScriptStep, IStepFactory
     /// <summary>The <c>Animation</c> flag on the step.</summary>
     public bool Animation { get; set; }
 
+    private SetLayoutObjectAnimationStep() : base(false) { }
+
     public SetLayoutObjectAnimationStep(bool animation = true, bool enabled = true)
         : base(enabled)
     {
         Animation = animation;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Set",
-                new XAttribute("state", Animation ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Set Layout Object Animation [ Animation: {(Animation ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("Set")?.Attribute("state")?.Value == "True";
-        return new SetLayoutObjectAnimationStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetLayoutObjectAnimationStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "Animation:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        var isOn = token.Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new SetLayoutObjectAnimationStep(isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetLayoutObjectAnimationStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -57,17 +43,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-layout-object-animation.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Set",
-                XmlElement = "Set",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Animation",
-                ValidValues = ["On", "Off"],
-            },
+            new BoolStateChild("Set") { PocoProperty = "Animation", HrLabel = "Animation" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetMultiUserStep.cs b/src/SharpFM.Model/Scripting/Steps/SetMultiUserStep.cs
index 353832e..da9e1bb 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetMultiUserStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetMultiUserStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -19,60 +21,26 @@ public sealed class SetMultiUserStep : ScriptStep, IStepFactory
     /// <summary>The enum XML value emitted on the <c>&lt;MultiUser&gt;</c> element.</summary>
     public string NetworkAccess { get; set; }
 
+    private SetMultiUserStep() : base(false)
+    {
+        NetworkAccess = "True";
+    }
+
     public SetMultiUserStep(string networkAccess = "True", bool enabled = true)
         : base(enabled)
     {
         NetworkAccess = networkAccess;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _xmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["True"] = "On",
-        ["OnHidden"] = "On (Hidden)",
-        ["False"] = "Off",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _hrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["On"] = "True",
-        ["On (Hidden)"] = "OnHidden",
-        ["Off"] = "False",
-    };
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string ToHr(string xmlValue) =>
-        _xmlToHr.TryGetValue(xmlValue, out var hr) ? hr : xmlValue;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    private static string FromHr(string hrValue) =>
-        _hrToXml.TryGetValue(hrValue, out var xml) ? xml : hrValue;
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetMultiUserStep>(step, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("MultiUser",
-                new XAttribute("value", NetworkAccess)));
-
-    public override string ToDisplayLine() =>
-        $"Set Multi-User [ Network access: {ToHr(NetworkAccess)} ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var value = step.Element("MultiUser")?.Attribute("value")?.Value ?? "True";
-        return new SetMultiUserStep(value, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "Network access:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        return new SetMultiUserStep(FromHr(token), enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetMultiUserStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -80,18 +48,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-multi-user.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "MultiUser",
-                XmlElement = "MultiUser",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Network access",
-                DefaultValue = "True",
-                ValidValues = ["On", "On (Hidden)", "Off"],
-            },
+            new EnumValueChild("MultiUser") { PocoProperty = "NetworkAccess", HrLabel = "Network access", DefaultValue = "True", ValidValues = ["True", "OnHidden", "False"], DisplayValues = ["On", "On (Hidden)", "Off"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetNextSerialValueStep.cs b/src/SharpFM.Model/Scripting/Steps/SetNextSerialValueStep.cs
index 116e90b..57aa7ef 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetNextSerialValueStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetNextSerialValueStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -10,45 +12,28 @@ public sealed class SetNextSerialValueStep : ScriptStep, IStepFactory
     public const int XmlId = 116;
     public const string XmlName = "Set Next Serial Value";
 
-    public FieldRef Field { get; set; }
-    public Calculation NextValue { get; set; }
+    // Nullable so the unconfigured form (no Field) omits the optional <Field> node.
+    public FieldRef? Field { get; set; }
+    public Calculation NextValue { get; set; } = new("");
+
+    private SetNextSerialValueStep() : base(false) { }
 
     public SetNextSerialValueStep(FieldRef? field = null, Calculation? nextValue = null, bool enabled = true)
         : base(enabled)
     {
-        Field = field ?? FieldRef.ForField("", 0, "");
+        Field = field;
         NextValue = nextValue ?? new Calculation("");
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            Field.ToXml("Field"),
-            NextValue.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Set Next Serial Value [ {Field.ToDisplayString()} ; {NextValue.Text} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var fieldEl = step.Element("Field");
-        var field = fieldEl is not null ? FieldRef.FromXml(fieldEl) : FieldRef.ForField("", 0, "");
-        var calcEl = step.Element("Calculation");
-        var calc = calcEl is not null ? Calculation.FromXml(calcEl) : new Calculation("");
-        return new SetNextSerialValueStep(field, calc, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetNextSerialValueStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        FieldRef field = FieldRef.ForField("", 0, "");
-        Calculation calc = new("");
-        if (hrParams.Length >= 1) field = FieldRef.FromDisplayToken(hrParams[0].Trim());
-        if (hrParams.Length >= 2) calc = new Calculation(hrParams[1].Trim());
-        return new SetNextSerialValueStep(field, calc, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetNextSerialValueStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -56,10 +41,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "fields",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-next-serial-value.html",
-        Params =
+        // Both Field and the bare next-value Calculation are omitted by the
+        // unconfigured form (Optional).
+        Shape =
         [
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", HrLabel = "Field", Required = true },
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation", HrLabel = "Next value", Required = true },
+            new FieldChild("Field") { PocoProperty = "Field", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new BareCalcChild { PocoProperty = "NextValue", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetRevertTransactionOnErrorStep.cs b/src/SharpFM.Model/Scripting/Steps/SetRevertTransactionOnErrorStep.cs
index c8c6f91..d9668cb 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetRevertTransactionOnErrorStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetRevertTransactionOnErrorStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,39 +19,23 @@ public sealed class SetRevertTransactionOnErrorStep : ScriptStep, IStepFactory
     /// <summary>The <c>Revert on error</c> flag on the step.</summary>
     public bool RevertOnError { get; set; }
 
+    private SetRevertTransactionOnErrorStep() : base(false) { }
+
     public SetRevertTransactionOnErrorStep(bool revertonerror = false, bool enabled = true)
         : base(enabled)
     {
         RevertOnError = revertonerror;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Set",
-                new XAttribute("state", RevertOnError ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Set Revert Transaction on Error [ Revert on error: {(RevertOnError ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("Set")?.Attribute("state")?.Value == "True";
-        return new SetRevertTransactionOnErrorStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetRevertTransactionOnErrorStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "Revert on error:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        var isOn = token.Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new SetRevertTransactionOnErrorStep(isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetRevertTransactionOnErrorStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -57,17 +43,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-revert-transaction-on-error.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Set",
-                XmlElement = "Set",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Revert on error",
-                ValidValues = ["On", "Off"],
-            },
+            new BoolStateChild("Set") { PocoProperty = "RevertOnError", HrLabel = "Revert on error" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetSelectionStep.cs b/src/SharpFM.Model/Scripting/Steps/SetSelectionStep.cs
index d9799e4..1d75ecb 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetSelectionStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetSelectionStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -16,8 +18,10 @@ public sealed class SetSelectionStep : ScriptStep, IStepFactory
     public const string XmlName = "Set Selection";
 
     public FieldRef? Field { get; set; }
-    public Calculation StartPosition { get; set; }
-    public Calculation EndPosition { get; set; }
+    public Calculation StartPosition { get; set; } = new("");
+    public Calculation EndPosition { get; set; } = new("");
+
+    private SetSelectionStep() : base(false) { }
 
     public SetSelectionStep(FieldRef? field = null, Calculation? startPosition = null, Calculation? endPosition = null, bool enabled = true)
         : base(enabled)
@@ -27,53 +31,15 @@ public SetSelectionStep(FieldRef? field = null, Calculation? startPosition = nul
         EndPosition = endPosition ?? new Calculation("");
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-        if (Field is not null) step.Add(Field.ToXml("Field"));
-        step.Add(new XElement("StartPosition", StartPosition.ToXml("Calculation")));
-        step.Add(new XElement("EndPosition", EndPosition.ToXml("Calculation")));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine()
-    {
-        var field = Field is null ? "" : $"{Field.ToDisplayString()} ; ";
-        return $"Set Selection [ {field}Start Position: {StartPosition.Text} ; End Position: {EndPosition.Text} ]";
-    }
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var fieldEl = step.Element("Field");
-        var field = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        var startEl = step.Element("StartPosition")?.Element("Calculation");
-        var start = startEl is not null ? Calculation.FromXml(startEl) : new Calculation("");
-        var endEl = step.Element("EndPosition")?.Element("Calculation");
-        var end = endEl is not null ? Calculation.FromXml(endEl) : new Calculation("");
-        return new SetSelectionStep(field, start, end, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetSelectionStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        FieldRef? field = null;
-        Calculation start = new("");
-        Calculation end = new("");
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("Start Position:", StringComparison.OrdinalIgnoreCase))
-                start = new Calculation(t.Substring(15).Trim());
-            else if (t.StartsWith("End Position:", StringComparison.OrdinalIgnoreCase))
-                end = new Calculation(t.Substring(13).Trim());
-            else if (!string.IsNullOrWhiteSpace(t) && field is null)
-                field = FieldRef.FromDisplayToken(t);
-        }
-        return new SetSelectionStep(field, start, end, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetSelectionStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -81,11 +47,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "editing",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-selection.html",
-        Params =
+        // Field, StartPosition and EndPosition are all omitted by the
+        // unconfigured form (Optional).
+        Shape =
         [
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", HrLabel = "Field" },
-            new ParamMetadata { Name = "StartPosition", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Start Position", Required = true },
-            new ParamMetadata { Name = "EndPosition", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "End Position", Required = true },
+            new FieldChild("Field") { PocoProperty = "Field", Optional = true, Display = DisplayMode.Native },
+            new NamedCalcChild("StartPosition") { PocoProperty = "StartPosition", HrLabel = "Start Position", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new NamedCalcChild("EndPosition") { PocoProperty = "EndPosition", HrLabel = "End Position", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetSessionIdentifierStep.cs b/src/SharpFM.Model/Scripting/Steps/SetSessionIdentifierStep.cs
index c48f9fd..6ea9314 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetSessionIdentifierStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetSessionIdentifierStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,41 +14,27 @@ public sealed class SetSessionIdentifierStep : ScriptStep, IStepFactory
     public const int XmlId = 208;
     public const string XmlName = "Set Session Identifier";
 
-    public Calculation SessionIdentifier { get; set; }
+    public Calculation? SessionIdentifier { get; set; }
+
+    private SetSessionIdentifierStep() : base(false) { }
 
     public SetSessionIdentifierStep(
         Calculation? sessionIdentifier = null,
         bool enabled = true)
         : base(enabled)
     {
-        SessionIdentifier = sessionIdentifier ?? new Calculation("");
+        SessionIdentifier = sessionIdentifier;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            SessionIdentifier.ToXml("Calculation"));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Set Session Identifier [ " + "Session identifier: " + SessionIdentifier.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var sessionIdentifier_vEl = step.Element("Calculation");
-        var sessionIdentifier_v = sessionIdentifier_vEl is not null ? Calculation.FromXml(sessionIdentifier_vEl) : new Calculation("");
-        return new SetSessionIdentifierStep(sessionIdentifier_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetSessionIdentifierStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        Calculation? sessionIdentifier_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Session identifier:", StringComparison.OrdinalIgnoreCase)) { sessionIdentifier_v = new Calculation(tok.Substring(19).Trim()); break; } }
-        return new SetSessionIdentifierStep(sessionIdentifier_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetSessionIdentifierStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -54,15 +42,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-session-identifier.html",
-        Params =
+        // Canonical unconfigured form is empty: the bare identifier calc is omitted when blank.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "calculation",
-                HrLabel = "Session identifier",
-            },
+            new BareCalcChild { PocoProperty = "SessionIdentifier", HrLabel = "Session identifier", Optional = true, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetUseSystemFormatsStep.cs b/src/SharpFM.Model/Scripting/Steps/SetUseSystemFormatsStep.cs
index fd9c5f0..ea6400b 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetUseSystemFormatsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetUseSystemFormatsStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -17,39 +19,23 @@ public sealed class SetUseSystemFormatsStep : ScriptStep, IStepFactory
     /// <summary>The <c>Use system formats</c> flag on the step.</summary>
     public bool UseSystemFormats { get; set; }
 
+    private SetUseSystemFormatsStep() : base(false) { }
+
     public SetUseSystemFormatsStep(bool usesystemformats = true, bool enabled = true)
         : base(enabled)
     {
         UseSystemFormats = usesystemformats;
     }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Set",
-                new XAttribute("state", UseSystemFormats ? "True" : "False")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Set Use System Formats [ Use system formats: {(UseSystemFormats ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var state = step.Element("Set")?.Attribute("state")?.Value == "True";
-        return new SetUseSystemFormatsStep(state, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetUseSystemFormatsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "Use system formats:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        var isOn = token.Equals("On", StringComparison.OrdinalIgnoreCase);
-        return new SetUseSystemFormatsStep(isOn, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetUseSystemFormatsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -57,17 +43,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-use-system-formats.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Set",
-                XmlElement = "Set",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Use system formats",
-                ValidValues = ["On", "Off"],
-            },
+            new BoolStateChild("Set") { PocoProperty = "UseSystemFormats", HrLabel = "Use system formats" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetVariableStep.cs b/src/SharpFM.Model/Scripting/Steps/SetVariableStep.cs
index 74d1008..3e44440 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetVariableStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetVariableStep.cs
@@ -2,6 +2,8 @@
 using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -18,9 +20,11 @@ public sealed class SetVariableStep : ScriptStep, IStepFactory
     public const int XmlId = 141;
     public const string XmlName = "Set Variable";
 
-    public string Name { get; set; }
-    public Calculation Value { get; set; }
-    public Calculation Repetition { get; set; }
+    public string Name { get; set; } = "";
+    public Calculation Value { get; set; } = new("");
+    public Calculation Repetition { get; set; } = new("1");
+
+    private SetVariableStep() : base(false) { }
 
     public SetVariableStep(bool enabled, string name, Calculation value, Calculation? repetition = null)
         : base(enabled)
@@ -30,35 +34,12 @@ public SetVariableStep(bool enabled, string name, Calculation value, Calculation
         Repetition = repetition ?? new Calculation("1");
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-
-        var name = step.Element("Name")?.Value ?? "";
-
-        var valueCalc = step.Element("Value")?.Element("Calculation");
-        var value = valueCalc is not null ? Calculation.FromXml(valueCalc) : new Calculation("");
-
-        var repCalc = step.Element("Repetition")?.Element("Calculation");
-        var repetition = repCalc is not null ? Calculation.FromXml(repCalc) : new Calculation("1");
-
-        return new SetVariableStep(enabled, name, value, repetition);
-    }
-
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-
-        step.Add(new XElement("Value", Value.ToXml()));
-        step.Add(new XElement("Repetition", Repetition.ToXml()));
-        step.Add(new XElement("Name", Name));
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetVariableStep>(step, Metadata);
 
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the name and repetition merge into one [rep] token the shape renderer cannot express.
     public override string ToDisplayLine()
     {
         var nameToken = Repetition.Text == "1"
@@ -110,12 +91,19 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "control",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-variable.html",
-        Params =
+        // Canonical shape per skill §3 / §7.1 / §7.4: Value, Repetition, then
+        // Name LAST as a plain-text child (the variable-name silent-drop trap).
+        // Repetition is always emitted in XML (never Optional) but hidden from
+        // the display line when it holds the default "1".
+        Shape =
         [
-            new ParamMetadata { Name = "Name", XmlElement = "Name", Type = "text", Required = true },
-            new ParamMetadata { Name = "Value", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Value", Required = true },
-            new ParamMetadata { Name = "Repetition", XmlElement = "Calculation", Type = "namedCalc" },
+            new NamedCalcChild("Value") { PocoProperty = "Value", HrLabel = "Value", Required = true, Display = DisplayMode.Augmented },
+            new NamedCalcChild("Repetition") { PocoProperty = "Repetition", Display = DisplayMode.Augmented, DefaultValue = "1" },
+            new NamedTextChild("Name") { PocoProperty = "Name", Required = true, Display = DisplayMode.Native },
         ],
+        // Params is retained alongside Shape only to feed the not-yet-migrated
+        // legacy consumers (FmScript.SynthesizeHrParams, ScriptValidator). It is
+        // deleted at the end of phase 6 once those read Shape directly.
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
     };
diff --git a/src/SharpFM.Model/Scripting/Steps/SetWebViewerStep.cs b/src/SharpFM.Model/Scripting/Steps/SetWebViewerStep.cs
index 587de87..9c516dd 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetWebViewerStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetWebViewerStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -16,6 +18,27 @@ public sealed class SetWebViewerStep : ScriptStep, IStepFactory
     public string Action { get; set; }
     public Calculation URL { get; set; }
 
+    /// <summary>
+    /// Shape-facing view of the <c>&lt;URL&gt;</c> element (a calc wrapper that
+    /// also carries a <c>custom</c> attribute, which no shape primitive
+    /// models): emitted only when a URL is configured and parsed back through
+    /// the shape's passthrough slot. The attribute is always written as
+    /// <c>"False"</c>, matching FM Pro's canonical form.
+    /// </summary>
+    public List<XElement> UrlWire
+    {
+        get => string.IsNullOrEmpty(URL.Text)
+            ? []
+            : [new XElement("URL", new XAttribute("custom", "False"), URL.ToXml("Calculation"))];
+        set
+        {
+            var calcEl = value.FirstOrDefault(e => e.Name.LocalName == "URL")?.Element("Calculation");
+            URL = calcEl is not null ? Calculation.FromXml(calcEl) : new Calculation("");
+        }
+    }
+
+    private SetWebViewerStep() : this(enabled: true) { }
+
     public SetWebViewerStep(
         Calculation? objectName = null,
         string action = "GoToURL",
@@ -47,30 +70,16 @@ public SetWebViewerStep(
     private static string ActionHr(string x) => _ActionToHr.TryGetValue(x, out var h) ? h : x;
     private static string ActionXml(string h) => _ActionFromHr.TryGetValue(h, out var x) ? x : h;
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ObjectName", ObjectName.ToXml("Calculation")),
-            new XElement("Action", new XAttribute("value", Action)),
-            new XElement("URL", URL.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written (render and parse): the URL token's wire form lives inside
+    // the UrlWire passthrough slot, which the shape display engine cannot read
+    // or bind.
     public override string ToDisplayLine() =>
         "Set Web Viewer [ " + "Object Name: " + ObjectName.Text + " ; " + "Action: " + ActionHr(Action) + " ; " + "URL: " + URL.Text + " ]";
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var objectName_vWrapEl = step.Element("ObjectName");
-        var objectName_vCalcEl = objectName_vWrapEl?.Element("Calculation");
-        var objectName_v = objectName_vCalcEl is not null ? Calculation.FromXml(objectName_vCalcEl) : new Calculation("");
-        var action_v = step.Element("Action")?.Attribute("value")?.Value ?? "GoToURL";
-        var uRL_vWrapEl = step.Element("URL");
-        var uRL_vCalcEl = uRL_vWrapEl?.Element("Calculation");
-        var uRL_v = uRL_vCalcEl is not null ? Calculation.FromXml(uRL_vCalcEl) : new Calculation("");
-        return new SetWebViewerStep(objectName_v, action_v, uRL_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetWebViewerStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -90,32 +99,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-web-viewer.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Object Name",
-            },
-            new ParamMetadata
-            {
-                Name = "Action",
-                XmlElement = "Action",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Action",
-                ValidValues = ["Go to URL", "Reset", "Reload", "Go Forward", "Go Back"],
-                DefaultValue = "GoToURL",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "URL",
-            },
+            // Canonical order: Action first, then the optional ObjectName and URL.
+            new EnumValueChild("Action") { HrLabel = "Action", ValidValues = ["GoToURL", "Reset", "Reload", "GoForward", "GoBack"], DisplayValues = ["Go to URL", "Reset", "Reload", "Go Forward", "Go Back"], DefaultValue = "GoToURL" },
+            new NamedCalcChild("ObjectName") { Optional = true, HrLabel = "Object Name" },
+            new Passthrough { PocoProperty = "UrlWire" },
+            new HrOnly("URL") { HrLabel = "URL" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetWindowTitleStep.cs b/src/SharpFM.Model/Scripting/Steps/SetWindowTitleStep.cs
index e0e9a4d..11b0e89 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetWindowTitleStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetWindowTitleStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -12,10 +14,12 @@ public sealed class SetWindowTitleStep : ScriptStep, IStepFactory
     public const int XmlId = 124;
     public const string XmlName = "Set Window Title";
 
-    public string Window { get; set; }
-    public Calculation OfWindow { get; set; }
+    public string Window { get; set; } = "ByName";
+    public Calculation OfWindow { get; set; } = new("");
     public bool CurrentFile { get; set; }
-    public Calculation NewTitle { get; set; }
+    public Calculation NewTitle { get; set; } = new("");
+
+    private SetWindowTitleStep() : base(false) { }
 
     public SetWindowTitleStep(
         string window = "ByName",
@@ -31,59 +35,15 @@ public SetWindowTitleStep(
         NewTitle = newTitle ?? new Calculation("");
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _WindowToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal) {
-        ["Current"] = "Current Window",
-        ["ByName"] = "Of Window",
-    };
-    private static readonly IReadOnlyDictionary<string, string> _WindowFromHr =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {
-        ["Current Window"] = "Current",
-        ["Of Window"] = "ByName",
-    };
-    private static string WindowHr(string x) => _WindowToHr.TryGetValue(x, out var h) ? h : x;
-    private static string WindowXml(string h) => _WindowFromHr.TryGetValue(h, out var x) ? x : h;
-
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Window", new XAttribute("value", Window)),
-            new XElement("Name", OfWindow.ToXml("Calculation")),
-            new XElement("LimitToWindowsOfCurrentFile", new XAttribute("state", CurrentFile ? "True" : "False")),
-            new XElement("NewName", NewTitle.ToXml("Calculation")));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Set Window Title [ " + "Window: " + WindowHr(Window) + " ; " + "Of Window: " + OfWindow.Text + " ; " + "Current file: " + (CurrentFile ? "On" : "Off") + " ; " + "New Title: " + NewTitle.Text + " ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var window_v = step.Element("Window")?.Attribute("value")?.Value ?? "ByName";
-        var ofWindow_vWrapEl = step.Element("Name");
-        var ofWindow_vCalcEl = ofWindow_vWrapEl?.Element("Calculation");
-        var ofWindow_v = ofWindow_vCalcEl is not null ? Calculation.FromXml(ofWindow_vCalcEl) : new Calculation("");
-        var currentFile_v = step.Element("LimitToWindowsOfCurrentFile")?.Attribute("state")?.Value == "True";
-        var newTitle_vWrapEl = step.Element("NewName");
-        var newTitle_vCalcEl = newTitle_vWrapEl?.Element("Calculation");
-        var newTitle_v = newTitle_vCalcEl is not null ? Calculation.FromXml(newTitle_vCalcEl) : new Calculation("");
-        return new SetWindowTitleStep(window_v, ofWindow_v, currentFile_v, newTitle_v, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetWindowTitleStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        string window_v = "ByName";
-        foreach (var tok in tokens) { if (tok.StartsWith("Window:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); window_v = WindowXml(v); break; } }
-        Calculation? ofWindow_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("Of Window:", StringComparison.OrdinalIgnoreCase)) { ofWindow_v = new Calculation(tok.Substring(10).Trim()); break; } }
-        bool currentFile_v = true;
-        foreach (var tok in tokens) { if (tok.StartsWith("Current file:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(13).Trim(); currentFile_v = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        Calculation? newTitle_v = null;
-        foreach (var tok in tokens) { if (tok.StartsWith("New Title:", StringComparison.OrdinalIgnoreCase)) { newTitle_v = new Calculation(tok.Substring(10).Trim()); break; } }
-        return new SetWindowTitleStep(window_v, ofWindow_v, currentFile_v, newTitle_v, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetWindowTitleStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -91,42 +51,16 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-window-title.html",
-        Params =
+        // Canonical: LimitToWindowsOfCurrentFile leads, then Window, then the
+        // optional <Name> (of-window) and <NewName> (new-title) calculations.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Window",
-                XmlElement = "Window",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Window",
-                ValidValues = ["Current Window", "Of Window"],
-                DefaultValue = "ByName",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "Of Window",
-            },
-            new ParamMetadata
-            {
-                Name = "LimitToWindowsOfCurrentFile",
-                XmlElement = "LimitToWindowsOfCurrentFile",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "Current file",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "Calculation",
-                XmlElement = "Calculation",
-                Type = "namedCalc",
-                HrLabel = "New Title",
-            },
+            // Native slots (Window, Of Window) lead the display line in shape
+            // order; Augmented (Current file, New Title) follow — XML order unchanged.
+            new BoolStateChild("LimitToWindowsOfCurrentFile") { PocoProperty = "CurrentFile", HrLabel = "Current file", Display = DisplayMode.Augmented },
+            new EnumValueChild("Window") { PocoProperty = "Window", HrLabel = "Window", DefaultValue = "ByName", ValidValues = ["Current", "ByName"], DisplayValues = ["Current Window", "Of Window"], Display = DisplayMode.Native },
+            new NamedCalcChild("Name") { PocoProperty = "OfWindow", HrLabel = "Of Window", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new NamedCalcChild("NewName") { PocoProperty = "NewTitle", HrLabel = "New Title", Optional = true, Display = DisplayMode.Augmented, DisplayEmptyAs = "" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SetZoomLevelStep.cs b/src/SharpFM.Model/Scripting/Steps/SetZoomLevelStep.cs
index 4711159..0cebfc0 100644
--- a/src/SharpFM.Model/Scripting/Steps/SetZoomLevelStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SetZoomLevelStep.cs
@@ -3,6 +3,9 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -19,81 +22,38 @@ public sealed class SetZoomLevelStep : ScriptStep, IStepFactory
 
     public bool Lock { get; set; }
     public string ZoomLevel { get; set; }
+    public Calculation? ZoomCalculation { get; set; }
+
+    /// <summary>
+    /// Display edits are anchor-preserved when a zoom-by-calculation
+    /// expression is stored — the display line shows only the ByCalculation
+    /// marker, never the calculation itself.
+    /// </summary>
+    public override bool IsFullyEditable => ZoomCalculation is null;
+
+    private SetZoomLevelStep() : base(false) { ZoomLevel = "100"; }
 
     public SetZoomLevelStep(
         bool @lock = false,
         string zoomLevel = "100",
+        Calculation? zoomCalculation = null,
         bool enabled = true)
         : base(enabled)
     {
         Lock = @lock;
         ZoomLevel = zoomLevel;
+        ZoomCalculation = zoomCalculation;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _ZoomLevelXmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["25"] = "25%",
-        ["50"] = "50%",
-        ["75"] = "75%",
-        ["100"] = "100%",
-        ["150"] = "150%",
-        ["200"] = "200%",
-        ["300"] = "300%",
-        ["400"] = "400%",
-        ["ZoomIn"] = "Zoom In",
-        ["ZoomOut"] = "Zoom Out",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _ZoomLevelHrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["25%"] = "25",
-        ["50%"] = "50",
-        ["75%"] = "75",
-        ["100%"] = "100",
-        ["150%"] = "150",
-        ["200%"] = "200",
-        ["300%"] = "300",
-        ["400%"] = "400",
-        ["Zoom In"] = "ZoomIn",
-        ["Zoom Out"] = "ZoomOut",
-    };
-
-    private static string ZoomLevelToHr(string x) =>
-        _ZoomLevelXmlToHr.TryGetValue(x, out var h) ? h : x;
-
-    private static string ZoomLevelFromHr(string h) =>
-        _ZoomLevelHrToXml.TryGetValue(h, out var x) ? x : h;
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Lock", new XAttribute("state", Lock ? "True" : "False")),
-            new XElement("Zoom", new XAttribute("value", ZoomLevel)));
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        "Set Zoom Level [ " + "Lock: " + (Lock ? "On" : "Off") + " ; " + "Zoom level: " + ZoomLevelToHr(ZoomLevel) + " ]";
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SetZoomLevelStep>(step, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var @lock_val = step.Element("Lock")?.Attribute("state")?.Value == "True";
-        var zoomLevel_val = step.Element("Zoom")?.Attribute("value")?.Value ?? "";
-        return new SetZoomLevelStep(@lock_val, zoomLevel_val, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool @lock_val = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Lock:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(5).Trim(); @lock_val = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        string zoomLevel_val = "100";
-        foreach (var tok in tokens) { if (tok.StartsWith("Zoom level:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(11).Trim(); zoomLevel_val = ZoomLevelFromHr(v); break; } }
-        return new SetZoomLevelStep(@lock_val, zoomLevel_val, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SetZoomLevelStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -101,28 +61,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/set-zoom-level.html",
-        Params =
+        // Canonical: Lock, Zoom, and (only for the ByCalculation zoom) a bare
+        // <Calculation> carrying the zoom-percentage expression.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Lock",
-                XmlElement = "Lock",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Lock",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Zoom",
-                XmlElement = "Zoom",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Zoom level",
-                ValidValues = ["25%", "50%", "75%", "100%", "150%", "200%", "300%", "400%", "Zoom In", "Zoom Out"],
-                DefaultValue = "100",
-            },
+            new BoolStateChild("Lock") { PocoProperty = "Lock", HrLabel = "Lock", Display = DisplayMode.Native },
+            new EnumValueChild("Zoom") { PocoProperty = "ZoomLevel", HrLabel = "Zoom level", DefaultValue = "100", ValidValues = ["25", "50", "75", "100", "150", "200", "300", "400", "ZoomIn", "ZoomOut", "ByCalculation"], DisplayValues = ["25%", "50%", "75%", "100%", "150%", "200%", "300%", "400%", "Zoom In", "Zoom Out", "ByCalculation"], Display = DisplayMode.Native },
+            new BareCalcChild { PocoProperty = "ZoomCalculation", Optional = true, Display = DisplayMode.Hidden },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ShowAllRecordsStep.cs b/src/SharpFM.Model/Scripting/Steps/ShowAllRecordsStep.cs
index f2f50e3..40fd38d 100644
--- a/src/SharpFM.Model/Scripting/Steps/ShowAllRecordsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ShowAllRecordsStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class ShowAllRecordsStep : ScriptStep, IStepFactory
     public const int XmlId = 23;
     public const string XmlName = "Show All Records";
 
+    private ShowAllRecordsStep() : base(false) { }
+
     public ShowAllRecordsStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ShowAllRecordsStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ShowAllRecordsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new ShowAllRecordsStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ShowAllRecordsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/ShowCustomDialogStep.cs b/src/SharpFM.Model/Scripting/Steps/ShowCustomDialogStep.cs
index 59b4c02..810c703 100644
--- a/src/SharpFM.Model/Scripting/Steps/ShowCustomDialogStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ShowCustomDialogStep.cs
@@ -5,6 +5,8 @@
 using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -32,9 +34,54 @@ public sealed class ShowCustomDialogStep : ScriptStep, IStepFactory
 
     public Calculation Title { get; set; }
     public Calculation Message { get; set; }
+    public Calculation? Height { get; set; }
+    public Calculation? Width { get; set; }
+    public Calculation? DistanceFromTop { get; set; }
+    public Calculation? DistanceFromLeft { get; set; }
     public IReadOnlyList<ShowCustomDialogButton> Buttons { get; set; }
     public IReadOnlyList<ShowCustomDialogInputField>? InputFields { get; set; }
 
+    /// <summary>
+    /// Display edits are anchor-preserved when dialog geometry is stored —
+    /// the height/width/position calcs never appear in display text.
+    /// </summary>
+    public override bool IsFullyEditable =>
+        Height is null && Width is null && DistanceFromTop is null && DistanceFromLeft is null;
+
+    /// <summary>
+    /// Shape-facing view of the trailing <c>&lt;Buttons&gt;</c> /
+    /// <c>&lt;InputFields&gt;</c> wrappers (typed child lists no shape
+    /// primitive models), emitted and parsed back through the shape's
+    /// passthrough slot. Buttons are emitted only when populated; InputFields
+    /// whenever configured (an empty configured list still writes the wrapper,
+    /// preserving the source's slot count).
+    /// </summary>
+    public List<XElement> ButtonsAndInputsWire
+    {
+        get
+        {
+            var list = new List<XElement>();
+            if (Buttons.Count > 0)
+                list.Add(new XElement("Buttons", Buttons.Select(b => b.ToXml())));
+            if (InputFields is not null)
+                list.Add(new XElement("InputFields", InputFields.Select(i => i.ToXml())));
+            return list;
+        }
+        set
+        {
+            Buttons = value.FirstOrDefault(e => e.Name.LocalName == "Buttons")
+                ?.Elements("Button").Select(ShowCustomDialogButton.FromXml).ToList()
+                ?? new List<ShowCustomDialogButton>();
+            var inputsEl = value.FirstOrDefault(e => e.Name.LocalName == "InputFields");
+            InputFields = inputsEl?.Elements("InputField").Select(ShowCustomDialogInputField.FromXml).ToList();
+        }
+    }
+
+    private ShowCustomDialogStep()
+        : this(true, new Calculation(""), new Calculation(""), new List<ShowCustomDialogButton>())
+    {
+    }
+
     public ShowCustomDialogStep(
         bool enabled,
         Calculation title,
@@ -49,54 +96,12 @@ public ShowCustomDialogStep(
         InputFields = inputFields;
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-
-        var titleCalc = step.Element("Title")?.Element("Calculation");
-        var title = titleCalc is not null ? Calculation.FromXml(titleCalc) : new Calculation("");
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ShowCustomDialogStep>(step, Metadata);
 
-        var messageCalc = step.Element("Message")?.Element("Calculation");
-        var message = messageCalc is not null ? Calculation.FromXml(messageCalc) : new Calculation("");
-
-        var buttons = step.Element("Buttons")?.Elements("Button")
-            .Select(ShowCustomDialogButton.FromXml).ToList()
-            ?? new List<ShowCustomDialogButton>();
-
-        var inputsEl = step.Element("InputFields");
-        List<ShowCustomDialogInputField>? inputs = inputsEl is not null
-            ? inputsEl.Elements("InputField").Select(ShowCustomDialogInputField.FromXml).ToList()
-            : null;
-
-        return new ShowCustomDialogStep(enabled, title, message, buttons, inputs);
-    }
-
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
-
-        step.Add(new XElement("Title", Title.ToXml()));
-        step.Add(new XElement("Message", Message.ToXml()));
-
-        var buttonsEl = new XElement("Buttons");
-        foreach (var button in Buttons)
-            buttonsEl.Add(button.ToXml());
-        step.Add(buttonsEl);
-
-        if (InputFields is not null)
-        {
-            var inputsEl = new XElement("InputFields");
-            foreach (var input in InputFields)
-                inputsEl.Add(input.ToXml());
-            step.Add(inputsEl);
-        }
-
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: the buttons render as a nested quoted list with commit markers — grammar the shape renderer cannot express.
     public override string ToDisplayLine()
     {
         var parts = new List<string>
@@ -167,6 +172,7 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         var message = new Calculation("");
         List<ShowCustomDialogButton> buttons = new();
         List<ShowCustomDialogInputField>? inputs = null;
+        bool buttonsSeen = false;
 
         foreach (var raw in hrParams)
         {
@@ -177,7 +183,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
             else if (token.StartsWith("Message:", StringComparison.OrdinalIgnoreCase))
                 message = new Calculation(token.Substring("Message:".Length).Trim());
             else if (token.StartsWith("Buttons:", StringComparison.OrdinalIgnoreCase))
+            {
                 buttons = ParseButtonBlock(token.Substring("Buttons:".Length).Trim());
+                buttonsSeen = true;
+            }
             else if (token.StartsWith("Inputs:", StringComparison.OrdinalIgnoreCase))
                 inputs = ParseInputBlock(token.Substring("Inputs:".Length).Trim());
         }
@@ -185,8 +194,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         // No Buttons block in the display ⇒ FM Pro default 3-slot shape.
         // This is the round-trip pair to IsDefaultButtonShape in
         // ToDisplayLine; together they make the default shape invisible
-        // in display text while fully round-tripping through XML.
-        if (buttons.Count == 0)
+        // in display text while fully round-tripping through XML. An
+        // explicitly empty block ("Buttons: [ ]") instead means the source
+        // had no button slots, and stays empty.
+        if (!buttonsSeen)
             buttons = DefaultButtons();
 
         return new ShowCustomDialogStep(enabled, title, message, buttons, inputs);
@@ -367,12 +378,20 @@ private static (string CalcText, string Keyword) SplitTrailingKeyword(string slo
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/show-custom-dialog.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "Title", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Title" },
-            new ParamMetadata { Name = "Message", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "Message" },
-            new ParamMetadata { Name = "Buttons", XmlElement = "Buttons", Type = "complex" },
-            new ParamMetadata { Name = "InputFields", XmlElement = "InputFields", Type = "complex" },
+            // Canonical: optional Title and Message, the optional
+            // dialog-geometry calcs, then the (optional) Buttons list and
+            // InputFields. An unconfigured dialog omits every child.
+            new NamedCalcChild("Title") { Optional = true, HrLabel = "Title" },
+            new NamedCalcChild("Message") { Optional = true, HrLabel = "Message" },
+            new NamedCalcChild("Height") { Optional = true, Display = DisplayMode.Hidden },
+            new NamedCalcChild("Width") { Optional = true, Display = DisplayMode.Hidden },
+            new NamedCalcChild("DistanceFromTop") { Optional = true, Display = DisplayMode.Hidden },
+            new NamedCalcChild("DistanceFromLeft") { Optional = true, Display = DisplayMode.Hidden },
+            new Passthrough { PocoProperty = "ButtonsAndInputsWire" },
+            new HrOnly("Buttons"),
+            new HrOnly("InputFields"),
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ShowHideMenubarStep.cs b/src/SharpFM.Model/Scripting/Steps/ShowHideMenubarStep.cs
index 72179e1..dc02d3e 100644
--- a/src/SharpFM.Model/Scripting/Steps/ShowHideMenubarStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ShowHideMenubarStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -20,6 +22,11 @@ public sealed class ShowHideMenubarStep : ScriptStep, IStepFactory
     public bool Lock { get; set; }
     public string Action { get; set; }
 
+    private ShowHideMenubarStep() : base(false)
+    {
+        Action = "Hide";
+    }
+
     public ShowHideMenubarStep(
         bool @lock = false,
         string action = "Hide",
@@ -30,56 +37,15 @@ public ShowHideMenubarStep(
         Action = action;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _ActionXmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["Show"] = "Show",
-        ["Hide"] = "Hide",
-        ["Toggle"] = "Toggle",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _ActionHrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["Show"] = "Show",
-        ["Hide"] = "Hide",
-        ["Toggle"] = "Toggle",
-    };
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string ActionToHr(string x) =>
-        _ActionXmlToHr.TryGetValue(x, out var h) ? h : x;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    private static string ActionFromHr(string h) =>
-        _ActionHrToXml.TryGetValue(h, out var x) ? x : h;
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ShowHideMenubarStep>(step, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("Lock", new XAttribute("state", Lock ? "True" : "False")),
-            new XElement("ShowHide", new XAttribute("value", Action)));
-
-    public override string ToDisplayLine() =>
-        "Show/Hide Menubar [ " + "Lock: " + (Lock ? "On" : "Off") + " ; " + "Action: " + ActionToHr(Action) + " ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var @lock_val = step.Element("Lock")?.Attribute("state")?.Value == "True";
-        var action_val = step.Element("ShowHide")?.Attribute("value")?.Value ?? "";
-        return new ShowHideMenubarStep(@lock_val, action_val, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool @lock_val = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Lock:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(5).Trim(); @lock_val = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        string action_val = "Hide";
-        foreach (var tok in tokens) { if (tok.StartsWith("Action:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); action_val = ActionFromHr(v); break; } }
-        return new ShowHideMenubarStep(@lock_val, action_val, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ShowHideMenubarStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -87,28 +53,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/show-hide-menubar.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "Lock",
-                XmlElement = "Lock",
-                Type = "boolean",
-                XmlAttr = "state",
-                HrLabel = "Lock",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "ShowHide",
-                XmlElement = "ShowHide",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Action",
-                ValidValues = ["Show", "Hide", "Toggle"],
-                DefaultValue = "Hide",
-            },
+            new BoolStateChild("Lock") { PocoProperty = "Lock", HrLabel = "Lock" },
+            new EnumValueChild("ShowHide") { PocoProperty = "Action", HrLabel = "Action", ValidValues = ["Show", "Hide", "Toggle"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ShowHideTextRulerStep.cs b/src/SharpFM.Model/Scripting/Steps/ShowHideTextRulerStep.cs
index 3529439..b76fbc0 100644
--- a/src/SharpFM.Model/Scripting/Steps/ShowHideTextRulerStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ShowHideTextRulerStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -19,60 +21,26 @@ public sealed class ShowHideTextRulerStep : ScriptStep, IStepFactory
     /// <summary>The enum XML value emitted on the <c>&lt;ShowHide&gt;</c> element.</summary>
     public string Action { get; set; }
 
+    private ShowHideTextRulerStep() : base(false)
+    {
+        Action = "Show";
+    }
+
     public ShowHideTextRulerStep(string action = "Show", bool enabled = true)
         : base(enabled)
     {
         Action = action;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _xmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["Show"] = "Show",
-        ["Hide"] = "Hide",
-        ["Toggle"] = "Toggle",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _hrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["Show"] = "Show",
-        ["Hide"] = "Hide",
-        ["Toggle"] = "Toggle",
-    };
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string ToHr(string xmlValue) =>
-        _xmlToHr.TryGetValue(xmlValue, out var hr) ? hr : xmlValue;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    private static string FromHr(string hrValue) =>
-        _hrToXml.TryGetValue(hrValue, out var xml) ? xml : hrValue;
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ShowHideTextRulerStep>(step, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("ShowHide",
-                new XAttribute("value", Action)));
-
-    public override string ToDisplayLine() =>
-        $"Show/Hide Text Ruler [ Action: {ToHr(Action)} ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var value = step.Element("ShowHide")?.Attribute("value")?.Value ?? "Show";
-        return new ShowHideTextRulerStep(value, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "Action:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        return new ShowHideTextRulerStep(FromHr(token), enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ShowHideTextRulerStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -80,18 +48,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/show-hide-text-ruler.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "ShowHide",
-                XmlElement = "ShowHide",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Action",
-                DefaultValue = "Show",
-                ValidValues = ["Show", "Hide", "Toggle"],
-            },
+            new EnumValueChild("ShowHide") { PocoProperty = "Action", HrLabel = "Action", DefaultValue = "Show", ValidValues = ["Show", "Hide", "Toggle"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ShowHideToolbarsStep.cs b/src/SharpFM.Model/Scripting/Steps/ShowHideToolbarsStep.cs
index 56d2c3b..1c48d1b 100644
--- a/src/SharpFM.Model/Scripting/Steps/ShowHideToolbarsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ShowHideToolbarsStep.cs
@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -21,6 +23,11 @@ public sealed class ShowHideToolbarsStep : ScriptStep, IStepFactory
     public bool Lock { get; set; }
     public string Action { get; set; }
 
+    private ShowHideToolbarsStep() : base(false)
+    {
+        Action = "Hide";
+    }
+
     public ShowHideToolbarsStep(
         bool includeEditRecordToolbar = false,
         bool @lock = false,
@@ -33,60 +40,15 @@ public ShowHideToolbarsStep(
         Action = action;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _ActionXmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["Show"] = "Show",
-        ["Hide"] = "Hide",
-        ["Toggle"] = "Toggle",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _ActionHrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["Show"] = "Show",
-        ["Hide"] = "Hide",
-        ["Toggle"] = "Toggle",
-    };
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string ActionToHr(string x) =>
-        _ActionXmlToHr.TryGetValue(x, out var h) ? h : x;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    private static string ActionFromHr(string h) =>
-        _ActionHrToXml.TryGetValue(h, out var x) ? x : h;
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ShowHideToolbarsStep>(step, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("IncludeEditRecordToolbar", new XAttribute("state", IncludeEditRecordToolbar ? "True" : "False")),
-            new XElement("Lock", new XAttribute("state", Lock ? "True" : "False")),
-            new XElement("ShowHide", new XAttribute("value", Action)));
-
-    public override string ToDisplayLine() =>
-        "Show/Hide Toolbars [ " + "Include Edit Record Toolbar: " + (IncludeEditRecordToolbar ? "On" : "Off") + " ; " + "Lock: " + (Lock ? "On" : "Off") + " ; " + "Action: " + ActionToHr(Action) + " ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var includeEditRecordToolbar_val = step.Element("IncludeEditRecordToolbar")?.Attribute("state")?.Value == "True";
-        var @lock_val = step.Element("Lock")?.Attribute("state")?.Value == "True";
-        var action_val = step.Element("ShowHide")?.Attribute("value")?.Value ?? "";
-        return new ShowHideToolbarsStep(includeEditRecordToolbar_val, @lock_val, action_val, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var tokens = hrParams.Select(h => h.Trim()).ToArray();
-        bool includeEditRecordToolbar_val = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Include Edit Record Toolbar:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(28).Trim(); includeEditRecordToolbar_val = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        bool @lock_val = false;
-        foreach (var tok in tokens) { if (tok.StartsWith("Lock:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(5).Trim(); @lock_val = v.Equals("On", StringComparison.OrdinalIgnoreCase); break; } }
-        string action_val = "Hide";
-        foreach (var tok in tokens) { if (tok.StartsWith("Action:", StringComparison.OrdinalIgnoreCase)) { var v = tok.Substring(7).Trim(); action_val = ActionFromHr(v); break; } }
-        return new ShowHideToolbarsStep(includeEditRecordToolbar_val, @lock_val, action_val, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ShowHideToolbarsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -94,38 +56,11 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/show-hide-toolbars.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "IncludeEditRecordToolbar",
-                XmlElement = "IncludeEditRecordToolbar",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "Include Edit Record Toolbar",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "Lock",
-                XmlElement = "Lock",
-                Type = "flagBoolean",
-                XmlAttr = "state",
-                HrLabel = "Lock",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "False",
-            },
-            new ParamMetadata
-            {
-                Name = "ShowHide",
-                XmlElement = "ShowHide",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Action",
-                ValidValues = ["Show", "Hide", "Toggle"],
-                DefaultValue = "Hide",
-            },
+            new BoolStateChild("IncludeEditRecordToolbar") { HrLabel = "Include Edit Record Toolbar" },
+            new BoolStateChild("Lock") { HrLabel = "Lock" },
+            new EnumValueChild("ShowHide") { PocoProperty = "Action", HrLabel = "Action", ValidValues = ["Show", "Hide", "Toggle"], DefaultValue = "Hide" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/ShowOmittedOnlyStep.cs b/src/SharpFM.Model/Scripting/Steps/ShowOmittedOnlyStep.cs
index 087a51e..1338a35 100644
--- a/src/SharpFM.Model/Scripting/Steps/ShowOmittedOnlyStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ShowOmittedOnlyStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class ShowOmittedOnlyStep : ScriptStep, IStepFactory
     public const int XmlId = 27;
     public const string XmlName = "Show Omitted Only";
 
+    private ShowOmittedOnlyStep() : base(false) { }
+
     public ShowOmittedOnlyStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new ShowOmittedOnlyStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<ShowOmittedOnlyStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new ShowOmittedOnlyStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ShowOmittedOnlyStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/SortRecordsByFieldStep.cs b/src/SharpFM.Model/Scripting/Steps/SortRecordsByFieldStep.cs
index 8a53ec2..481a0dc 100644
--- a/src/SharpFM.Model/Scripting/Steps/SortRecordsByFieldStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SortRecordsByFieldStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +15,11 @@ public sealed class SortRecordsByFieldStep : ScriptStep, IStepFactory
     public string SortOrder { get; set; }
     public FieldRef? Field { get; set; }
 
+    private SortRecordsByFieldStep() : base(false)
+    {
+        SortOrder = "SortAscending";
+    }
+
     public SortRecordsByFieldStep(string sortOrder = "SortAscending", FieldRef? field = null, bool enabled = true)
         : base(enabled)
     {
@@ -20,66 +27,15 @@ public SortRecordsByFieldStep(string sortOrder = "SortAscending", FieldRef? fiel
         Field = field;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("SortRecordsByField", new XAttribute("value", SortOrder)));
-        if (Field is not null) step.Add(Field.ToXml("Field"));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine()
-    {
-        var order = SortOrder switch
-        {
-            "SortAscending" => "Ascending",
-            "SortDescending" => "Descending",
-            "SortValueList" => "Associated value list",
-            _ => SortOrder,
-        };
-        return Field is null
-            ? $"Sort Records by Field [ {order} ]"
-            : $"Sort Records by Field [ {order} ; {Field.ToDisplayString()} ]";
-    }
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var order = step.Element("SortRecordsByField")?.Attribute("value")?.Value ?? "SortAscending";
-        var fieldEl = step.Element("Field");
-        var field = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new SortRecordsByFieldStep(order, field, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SortRecordsByFieldStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        string order = "SortAscending";
-        FieldRef? field = null;
-        bool orderSeen = false;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (!orderSeen)
-            {
-                order = t switch
-                {
-                    "Ascending" => "SortAscending",
-                    "Descending" => "SortDescending",
-                    "Associated value list" => "SortValueList",
-                    _ => t,
-                };
-                orderSeen = true;
-            }
-            else if (!string.IsNullOrWhiteSpace(t))
-            {
-                field = FieldRef.FromDisplayToken(t);
-            }
-        }
-        return new SortRecordsByFieldStep(order, field, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SortRecordsByFieldStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -87,19 +43,10 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "found sets",
         HelpUrl = "https://help.claris.com/en/pro-help/content/sort-records-by-field.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "SortRecordsByField",
-                XmlElement = "SortRecordsByField",
-                XmlAttr = "value",
-                Type = "enum",
-                HrLabel = "Sort order",
-                ValidValues = ["Ascending", "Descending", "Associated value list"],
-                DefaultValue = "SortAscending",
-            },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", HrLabel = "Field" },
+            new EnumValueChild("SortRecordsByField") { PocoProperty = "SortOrder", DefaultValue = "SortAscending", ValidValues = ["SortAscending", "SortDescending", "SortValueList"], DisplayValues = ["Ascending", "Descending", "Associated value list"] },
+            new FieldChild("Field") { PocoProperty = "Field", Optional = true },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SortRecordsStep.cs b/src/SharpFM.Model/Scripting/Steps/SortRecordsStep.cs
index de67df8..d203962 100644
--- a/src/SharpFM.Model/Scripting/Steps/SortRecordsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SortRecordsStep.cs
@@ -1,5 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -13,6 +15,18 @@ public sealed class SortRecordsStep : ScriptStep, IStepFactory
     public bool RestoreStoredOrder { get; set; }
     public SortList? Sort { get; set; }
 
+    /// <summary>
+    /// Display edits are anchor-preserved when a stored sort order is
+    /// present — the display line carries only the dialog and Restore flags,
+    /// never the <c>&lt;SortList&gt;</c>.
+    /// </summary>
+    public override bool IsFullyEditable => Sort is null;
+
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+
+    private SortRecordsStep() : base(false) { }
+
     public SortRecordsStep(
         bool withDialog = false,
         bool restoreStoredOrder = true,
@@ -25,44 +39,15 @@ public SortRecordsStep(
         Sort = sort;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("Restore", new XAttribute("state", RestoreStoredOrder ? "True" : "False")));
-        if (Sort is not null) step.Add(Sort.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() =>
-        $"Sort Records [ With dialog: {(WithDialog ? "On" : "Off")} ; Restore: {(RestoreStoredOrder ? "On" : "Off")} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var restore = step.Element("Restore")?.Attribute("state")?.Value == "True";
-        var sortEl = step.Element("SortList");
-        var sort = sortEl is not null ? SortList.FromXml(sortEl) : null;
-        return new SortRecordsStep(withDialog, restore, sort, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SortRecordsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        bool withDialog = false, restore = true;
-        foreach (var tok in hrParams)
-        {
-            var t = tok.Trim();
-            if (t.StartsWith("With dialog:", System.StringComparison.OrdinalIgnoreCase))
-                withDialog = t.Substring(12).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
-            else if (t.StartsWith("Restore:", System.StringComparison.OrdinalIgnoreCase))
-                restore = t.Substring(8).Trim().Equals("On", System.StringComparison.OrdinalIgnoreCase);
-        }
-        return new SortRecordsStep(withDialog, restore, null, enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SortRecordsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -70,11 +55,14 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "found sets",
         HelpUrl = "https://help.claris.com/en/pro-help/content/sort-records.html",
-        Params =
+        // NoInteract (inverse of WithDialog), Restore, then the SortList only
+        // when a sort order is stored.
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog" },
-            new ParamMetadata { Name = "Restore", XmlElement = "Restore", XmlAttr = "state", Type = "boolean" },
-            new ParamMetadata { Name = "SortList", XmlElement = "SortList", Type = "complex" },
+            new BoolStateChild("NoInteract") { PocoProperty = "NoInteract", HrLabel = "With dialog", DisplayInverted = true },
+            new BoolStateChild("Restore") { PocoProperty = "RestoreStoredOrder", HrLabel = "Restore" },
+            new HrOnly("Restore") { Boolean = true },
+            new ValueTypeChild("SortList") { PocoProperty = "Sort" },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/SpeakStep.cs b/src/SharpFM.Model/Scripting/Steps/SpeakStep.cs
index dd504f5..6515194 100644
--- a/src/SharpFM.Model/Scripting/Steps/SpeakStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SpeakStep.cs
@@ -1,53 +1,63 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
 
+/// <summary>
+/// Speak (66, macOS). Canonical form (skill): an optional text
+/// <c>&lt;Calculation&gt;</c> followed by the <c>&lt;SpeechOptions&gt;</c>
+/// element; the text calc is omitted when the step is unconfigured.
+/// </summary>
 public sealed class SpeakStep : ScriptStep, IStepFactory
 {
     public const int XmlId = 66;
     public const string XmlName = "Speak";
 
-    public Calculation Text { get; set; }
+    public Calculation? Text { get; set; }
     public SpeechOptions? Options { get; set; }
 
+    /// <summary>
+    /// The options FM writes for a Speak step with no voice configured:
+    /// wait-for-completion on, the default (id 0) voice. This is what the
+    /// display parser reconstructs, since the display line carries only the
+    /// spoken text.
+    /// </summary>
+    internal static readonly SpeechOptions DefaultOptions = new(true, "", "0", "");
+
+    /// <summary>
+    /// Display edits are anchor-preserved when a non-default voice or
+    /// wait-for-completion setting is stored — the display line cannot carry
+    /// the speech options.
+    /// </summary>
+    public override bool IsFullyEditable => Options is null || Options == DefaultOptions;
+
+    private SpeakStep() : base(false) { }
+
     public SpeakStep(Calculation? text = null, SpeechOptions? options = null, bool enabled = true)
         : base(enabled)
     {
-        Text = text ?? new Calculation("");
+        Text = text;
         Options = options;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            Text.ToXml("Calculation"));
-        if (Options is not null) step.Add(Options.ToXml());
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => $"Speak [ {Text.Text} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var calcEl = step.Element("Calculation");
-        var text = calcEl is not null ? Calculation.FromXml(calcEl) : new Calculation("");
-        var optEl = step.Element("SpeechOptions");
-        var options = optEl is not null ? SpeechOptions.FromXml(optEl) : null;
-        return new SpeakStep(text, options, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<SpeakStep>(step, Metadata);
 
+    // Hand-written: reconstructs the DefaultOptions SpeechOptions block the
+    // wire form always carries, which the shape parser cannot synthesize.
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
-        Calculation text = new("");
-        if (hrParams.Length >= 1) text = new Calculation(hrParams[0].Trim());
-        return new SpeakStep(text, null, enabled);
+        Calculation? text = null;
+        if (hrParams.Length >= 1 && hrParams[0].Trim().Length > 0) text = new Calculation(hrParams[0].Trim());
+        return new SpeakStep(text, DefaultOptions, enabled);
     }
 
     public static StepMetadata Metadata { get; } = new()
@@ -56,10 +66,12 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "miscellaneous",
         HelpUrl = "https://help.claris.com/en/pro-help/content/speak-os-x.html",
-        Params =
+        // Canonical: optional text <Calculation>, then <SpeechOptions>.
+        Shape =
         [
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation", HrLabel = "Text to speak", Required = true },
-            new ParamMetadata { Name = "SpeechOptions", XmlElement = "SpeechOptions", Type = "complex", HrLabel = "Speech options" },
+            new BareCalcChild { PocoProperty = "Text", Optional = true, Display = DisplayMode.Native, DisplayEmptyAs = "" },
+            new ValueTypeChild("SpeechOptions") { PocoProperty = "Options", Display = DisplayMode.Hidden },
+            new HrOnly("SpeechOptions") { HrLabel = "Speech options" },
         ],
         Notes = new StepNotes
         {
diff --git a/src/SharpFM.Model/Scripting/Steps/SpellingOptionsStep.cs b/src/SharpFM.Model/Scripting/Steps/SpellingOptionsStep.cs
index 29d0c85..5915a71 100644
--- a/src/SharpFM.Model/Scripting/Steps/SpellingOptionsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/SpellingOptionsStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class SpellingOptionsStep : ScriptStep, IStepFactory
     public const int XmlId = 107;
     public const string XmlName = "Spelling Options";
 
+    private SpellingOptionsStep() : base(false) { }
+
     public SpellingOptionsStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new SpellingOptionsStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<SpellingOptionsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new SpellingOptionsStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<SpellingOptionsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/TriggerClarisConnectFlowStep.cs b/src/SharpFM.Model/Scripting/Steps/TriggerClarisConnectFlowStep.cs
index f5dedf0..690ee14 100644
--- a/src/SharpFM.Model/Scripting/Steps/TriggerClarisConnectFlowStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/TriggerClarisConnectFlowStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -11,14 +13,12 @@ namespace SharpFM.Model.Scripting.Steps;
 /// target variable.
 ///
 /// <para>
-/// The step id is defaulted to 0; the canonical id has not been confirmed
-/// from real FM Pro clipboard output. Whatever id appears on the source
-/// XML is preserved through round-trip.
+/// The canonical step id is 211 (vendored FileMaker XML skill, control reference).
 /// </para>
 /// </summary>
 public sealed class TriggerClarisConnectFlowStep : ScriptStep, IStepFactory
 {
-    public const int XmlId = 0;
+    public const int XmlId = 211;
     public const string XmlName = "Trigger Claris Connect Flow";
 
     public bool WithDialog { get; set; }
@@ -29,6 +29,21 @@ public sealed class TriggerClarisConnectFlowStep : ScriptStep, IStepFactory
     public Calculation? CurlOptions { get; set; }
     public string TargetVariable { get; set; }
 
+    // Wire adapter: the XML carries <NoInteract state>, the inverse of the
+    // With-dialog option the UI (and display line) exposes. Get/set so the
+    // shape renderer and parser both go through it.
+    public bool NoInteract
+    {
+        get => !WithDialog;
+        set => WithDialog = !value;
+    }
+
+    private TriggerClarisConnectFlowStep() : base(false)
+    {
+        FlowUrl = "";
+        TargetVariable = "";
+    }
+
     public TriggerClarisConnectFlowStep(
         bool withDialog = true,
         bool dontEncodeUrl = false,
@@ -49,48 +64,24 @@ public TriggerClarisConnectFlowStep(
         TargetVariable = targetVariable;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("NoInteract", new XAttribute("state", WithDialog ? "False" : "True")),
-            new XElement("DontEncodeURL", new XAttribute("state", DontEncodeUrl ? "True" : "False")),
-            new XElement("SelectAll", new XAttribute("state", SelectAll ? "True" : "False")),
-            new XElement("VerifySSLCertificates", new XAttribute("state", VerifySslCertificates ? "True" : "False")),
-            new XElement("Flow", FlowUrl));
-        if (CurlOptions is not null)
-            step.Add(new XElement("CURLOptions", CurlOptions.ToXml("Calculation")));
-        step.Add(new XElement("Text", TargetVariable));
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine()
-    {
-        var parts = new System.Collections.Generic.List<string>
-        {
-            $"With dialog: {(WithDialog ? "On" : "Off")}",
-            $"Flow URL: {FlowUrl}",
-        };
-        if (CurlOptions is not null) parts.Add($"cURL options: {CurlOptions.Text}");
-        return $"Trigger Claris Connect Flow [ {string.Join(" ; ", parts)} ]";
-    }
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var withDialog = step.Element("NoInteract")?.Attribute("state")?.Value != "True";
-        var dontEncode = step.Element("DontEncodeURL")?.Attribute("state")?.Value == "True";
-        var selectAll = step.Element("SelectAll")?.Attribute("state")?.Value == "True";
-        var verify = step.Element("VerifySSLCertificates")?.Attribute("state")?.Value == "True";
-        var flowUrl = step.Element("Flow")?.Value ?? "";
-        var curlEl = step.Element("CURLOptions")?.Element("Calculation");
-        var curl = curlEl is not null ? Calculation.FromXml(curlEl) : null;
-        var text = step.Element("Text")?.Value ?? "";
-        return new TriggerClarisConnectFlowStep(withDialog, dontEncode, selectAll, verify, flowUrl, curl, text, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<TriggerClarisConnectFlowStep>(step, Metadata);
+
+    /// <summary>
+    /// Display edits are anchor-preserved when state the display line cannot
+    /// carry is present: a target variable, or the encode/select/SSL flags
+    /// off their unconfigured values (the display shows only the dialog
+    /// toggle, flow URL, and cURL options).
+    /// </summary>
+    public override bool IsFullyEditable =>
+        TargetVariable.Length == 0 && !DontEncodeUrl && SelectAll && !VerifySslCertificates;
 
+    // Hand-written: reconstructs the unconfigured SelectAll=true wire default,
+    // which the shape parser cannot synthesize for a display-hidden slot.
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         bool withDialog = true;
@@ -114,15 +105,17 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Name = XmlName,
         Id = XmlId,
         Category = "control",
-        Params =
+        Shape =
         [
-            new ParamMetadata { Name = "NoInteract", XmlElement = "NoInteract", XmlAttr = "state", Type = "boolean", HrLabel = "With dialog", ValidValues = ["On", "Off"] },
-            new ParamMetadata { Name = "DontEncodeURL", XmlElement = "DontEncodeURL", XmlAttr = "state", Type = "boolean", HrLabel = "Don't encode URL" },
-            new ParamMetadata { Name = "SelectAll", XmlElement = "SelectAll", XmlAttr = "state", Type = "boolean", HrLabel = "Select entire contents" },
-            new ParamMetadata { Name = "VerifySSLCertificates", XmlElement = "VerifySSLCertificates", XmlAttr = "state", Type = "boolean", HrLabel = "Verify SSL certificates" },
-            new ParamMetadata { Name = "Flow", XmlElement = "Flow", Type = "text", HrLabel = "Flow URL" },
-            new ParamMetadata { Name = "CURLOptions", XmlElement = "Calculation", Type = "namedCalc", HrLabel = "cURL options" },
-            new ParamMetadata { Name = "Text", XmlElement = "Text", Type = "text", HrLabel = "Target variable" },
+            new BoolStateChild("NoInteract") { HrLabel = "With dialog", DisplayInverted = true },
+            // The display line carries only the dialog toggle, flow URL, and
+            // cURL options; the remaining state seals the step (IsFullyEditable).
+            new BoolStateChild("DontEncodeURL") { PocoProperty = "DontEncodeUrl", HrLabel = "Don't encode URL", Display = DisplayMode.Hidden },
+            new BoolStateChild("SelectAll") { HrLabel = "Select entire contents", Display = DisplayMode.Hidden },
+            new BoolStateChild("VerifySSLCertificates") { PocoProperty = "VerifySslCertificates", HrLabel = "Verify SSL certificates", Display = DisplayMode.Hidden },
+            new NamedTextChild("Flow") { PocoProperty = "FlowUrl", HrLabel = "Flow URL", DisplayEmptyAs = "" },
+            new NamedCalcChild("CURLOptions") { PocoProperty = "CurlOptions", Optional = true, HrLabel = "cURL options" },
+            new NamedTextChild("Text") { PocoProperty = "TargetVariable", HrLabel = "Target variable", Display = DisplayMode.Hidden },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/TruncateTableStep.cs b/src/SharpFM.Model/Scripting/Steps/TruncateTableStep.cs
index 9a888fc..3ac541d 100644
--- a/src/SharpFM.Model/Scripting/Steps/TruncateTableStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/TruncateTableStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -20,6 +22,9 @@ public sealed class TruncateTableStep : ScriptStep, IStepFactory
     public NamedRef Table { get; set; }
     public string? TableComment { get; set; }
 
+    /// <summary><c>&lt;NoInteract&gt;</c> XML state — the inverse of <see cref="WithDialog"/>. Bound by the shape.</summary>
+    public bool NoInteract { get => !WithDialog; set => WithDialog = !value; }
+
     public TruncateTableStep(bool withDialog = true, NamedRef? table = null, string? tableComment = null, bool enabled = true)
         : base(enabled)
     {
@@ -44,8 +49,7 @@ public override XElement ToXml()
             baseTable);
     }
 
-    public override string ToDisplayLine() =>
-        $"Truncate Table [ With dialog: {(WithDialog ? "On" : "Off")} ; Table: {Table.Name} ]";
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step)
     {
@@ -57,6 +61,8 @@ public override string ToDisplayLine() =>
         return new TruncateTableStep(withDialog, table, comment, enabled);
     }
 
+    // Hand-written: the current-table placeholder must keep its fixed id -1,
+    // which the shape parser's uniform NamedRef(0, name) binding cannot express.
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
         bool withDialog = true;
@@ -71,7 +77,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
             else if (t.StartsWith("Table:", StringComparison.OrdinalIgnoreCase))
             {
                 var name = t.Substring(6).Trim();
-                table = new NamedRef(0, name);
+                // The current-table placeholder carries the fixed id -1;
+                // real tables carry file-specific ids the canonical form wildcards.
+                table = new NamedRef(name == "<Current Table>" ? -1 : 0, name);
             }
         }
         return new TruncateTableStep(withDialog, table, null, enabled);
@@ -83,26 +91,13 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "records",
         HelpUrl = "https://help.claris.com/en/pro-help/content/truncate-table.html",
-        Params =
+        // Shape backs the HR/display metadata and canonical-order lint only;
+        // ToXml/FromXml stay hand-written so the optional BaseTable comment
+        // attribute is preserved, and the shape renderer/parser never runs.
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "NoInteract",
-                XmlElement = "NoInteract",
-                XmlAttr = "state",
-                Type = "boolean",
-                HrLabel = "With dialog",
-                ValidValues = ["On", "Off"],
-                DefaultValue = "True",
-            },
-            new ParamMetadata
-            {
-                Name = "BaseTable",
-                XmlElement = "BaseTable",
-                Type = "tableReference",
-                HrLabel = "Table",
-                Required = true,
-            },
+            new BoolStateChild("NoInteract") { HrLabel = "With dialog", DisplayInverted = true },
+            new NamedRefChild("BaseTable") { PocoProperty = "Table", HrLabel = "Table" },
         ],
         Notes = new StepNotes
         {
diff --git a/src/SharpFM.Model/Scripting/Steps/UndoRedoStep.cs b/src/SharpFM.Model/Scripting/Steps/UndoRedoStep.cs
index 9ae2894..37eed75 100644
--- a/src/SharpFM.Model/Scripting/Steps/UndoRedoStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/UndoRedoStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -19,60 +21,26 @@ public sealed class UndoRedoStep : ScriptStep, IStepFactory
     /// <summary>The enum XML value emitted on the <c>&lt;UndoRedo&gt;</c> element.</summary>
     public string Action { get; set; }
 
+    private UndoRedoStep() : base(false)
+    {
+        Action = "Undo";
+    }
+
     public UndoRedoStep(string action = "Undo", bool enabled = true)
         : base(enabled)
     {
         Action = action;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _xmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["Undo"] = "Undo",
-        ["Redo"] = "Redo",
-        ["Toggle"] = "Toggle",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _hrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["Undo"] = "Undo",
-        ["Redo"] = "Redo",
-        ["Toggle"] = "Toggle",
-    };
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string ToHr(string xmlValue) =>
-        _xmlToHr.TryGetValue(xmlValue, out var hr) ? hr : xmlValue;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    private static string FromHr(string hrValue) =>
-        _hrToXml.TryGetValue(hrValue, out var xml) ? xml : hrValue;
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<UndoRedoStep>(step, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("UndoRedo",
-                new XAttribute("value", Action)));
-
-    public override string ToDisplayLine() =>
-        $"Undo/Redo [ Action: {ToHr(Action)} ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var value = step.Element("UndoRedo")?.Attribute("value")?.Value ?? "Undo";
-        return new UndoRedoStep(value, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "Action:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        return new UndoRedoStep(FromHr(token), enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<UndoRedoStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -80,18 +48,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "editing",
         HelpUrl = "https://help.claris.com/en/pro-help/content/undo-redo.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "UndoRedo",
-                XmlElement = "UndoRedo",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "Action",
-                DefaultValue = "Undo",
-                ValidValues = ["Undo", "Redo", "Toggle"],
-            },
+            new EnumValueChild("UndoRedo") { PocoProperty = "Action", HrLabel = "Action", DefaultValue = "Undo", ValidValues = ["Undo", "Redo", "Toggle"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/UnsortRecordsStep.cs b/src/SharpFM.Model/Scripting/Steps/UnsortRecordsStep.cs
index 3e1a906..a590da0 100644
--- a/src/SharpFM.Model/Scripting/Steps/UnsortRecordsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/UnsortRecordsStep.cs
@@ -1,5 +1,6 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -13,21 +14,19 @@ public sealed class UnsortRecordsStep : ScriptStep, IStepFactory
     public const int XmlId = 21;
     public const string XmlName = "Unsort Records";
 
+    private UnsortRecordsStep() : base(false) { }
+
     public UnsortRecordsStep(bool enabled = true) : base(enabled) { }
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName));
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    public override string ToDisplayLine() => XmlName;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
     public static new ScriptStep FromXml(XElement step) =>
-        new UnsortRecordsStep(step.Attribute("enable")?.Value != "False");
+        StepXmlParser.Parse<UnsortRecordsStep>(step, Metadata);
 
-    public static ScriptStep FromDisplayParams(bool enabled, string[] _) =>
-        new UnsortRecordsStep(enabled);
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<UnsortRecordsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
diff --git a/src/SharpFM.Model/Scripting/Steps/ViewAsStep.cs b/src/SharpFM.Model/Scripting/Steps/ViewAsStep.cs
index 1186fc3..ab3e5c9 100644
--- a/src/SharpFM.Model/Scripting/Steps/ViewAsStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/ViewAsStep.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Model.Scripting.Steps;
 
@@ -19,62 +21,26 @@ public sealed class ViewAsStep : ScriptStep, IStepFactory
     /// <summary>The enum XML value emitted on the <c>&lt;View&gt;</c> element.</summary>
     public string View { get; set; }
 
+    private ViewAsStep() : base(false)
+    {
+        View = "Cycle";
+    }
+
     public ViewAsStep(string view = "Cycle", bool enabled = true)
         : base(enabled)
     {
         View = view;
     }
 
-    private static readonly IReadOnlyDictionary<string, string> _xmlToHr =
-        new Dictionary<string, string>(StringComparer.Ordinal)
-    {
-        ["Cycle"] = "Cycle",
-        ["Form"] = "View as Form",
-        ["List"] = "View as List",
-        ["Table"] = "View as Table",
-    };
-
-    private static readonly IReadOnlyDictionary<string, string> _hrToXml =
-        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
-    {
-        ["Cycle"] = "Cycle",
-        ["View as Form"] = "Form",
-        ["View as List"] = "List",
-        ["View as Table"] = "Table",
-    };
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
-    private static string ToHr(string xmlValue) =>
-        _xmlToHr.TryGetValue(xmlValue, out var hr) ? hr : xmlValue;
+    public override string ToDisplayLine() => StepDisplayRenderer.Render(this, Metadata);
 
-    private static string FromHr(string hrValue) =>
-        _hrToXml.TryGetValue(hrValue, out var xml) ? xml : hrValue;
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<ViewAsStep>(step, Metadata);
 
-    public override XElement ToXml() =>
-        new("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("View",
-                new XAttribute("value", View)));
-
-    public override string ToDisplayLine() =>
-        $"View As [ View: {ToHr(View)} ]";
-
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var value = step.Element("View")?.Attribute("value")?.Value ?? "Cycle";
-        return new ViewAsStep(value, enabled);
-    }
-
-    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
-    {
-        var token = hrParams.Length > 0 ? hrParams[0].Trim() : "";
-        const string Prefix = "View:";
-        if (token.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))
-            token = token.Substring(Prefix.Length).Trim();
-        return new ViewAsStep(FromHr(token), enabled);
-    }
+    public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams) =>
+        StepDisplayParser.Parse<ViewAsStep>(enabled, hrParams, Metadata);
 
     public static StepMetadata Metadata { get; } = new()
     {
@@ -82,18 +48,9 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "windows",
         HelpUrl = "https://help.claris.com/en/pro-help/content/view-as.html",
-        Params =
+        Shape =
         [
-            new ParamMetadata
-            {
-                Name = "View",
-                XmlElement = "View",
-                Type = "enum",
-                XmlAttr = "value",
-                HrLabel = "View",
-                DefaultValue = "Cycle",
-                ValidValues = ["Cycle", "View as Form", "View as List", "View as Table"],
-            },
+            new EnumValueChild("View") { HrLabel = "View", DefaultValue = "Cycle", ValidValues = ["Cycle", "Form", "List", "Table"], DisplayValues = ["Cycle", "View as Form", "View as List", "View as Table"] },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Steps/WriteToDataFileStep.cs b/src/SharpFM.Model/Scripting/Steps/WriteToDataFileStep.cs
index 5e98c2a..7e5e179 100644
--- a/src/SharpFM.Model/Scripting/Steps/WriteToDataFileStep.cs
+++ b/src/SharpFM.Model/Scripting/Steps/WriteToDataFileStep.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Xml.Linq;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Values;
 
 namespace SharpFM.Model.Scripting.Steps;
@@ -10,11 +12,13 @@ public sealed class WriteToDataFileStep : ScriptStep, IStepFactory
     public const int XmlId = 192;
     public const string XmlName = "Write to Data File";
 
-    public Calculation FileId { get; set; }
+    public Calculation? FileId { get; set; }
     public FieldRef? DataSource { get; set; }
-    public string DataSourceType { get; set; }
+    public string DataSourceType { get; set; } = "2";
     public bool AppendLineFeed { get; set; }
 
+    private WriteToDataFileStep() : base(false) { }
+
     public WriteToDataFileStep(
         Calculation? fileId = null,
         FieldRef? dataSource = null,
@@ -23,29 +27,15 @@ public WriteToDataFileStep(
         bool enabled = true)
         : base(enabled)
     {
-        FileId = fileId ?? new Calculation("");
+        FileId = fileId;
         DataSource = dataSource;
         DataSourceType = dataSourceType;
         AppendLineFeed = appendLineFeed;
     }
 
-    public override XElement ToXml()
-    {
-        var step = new XElement("Step",
-            new XAttribute("enable", Enabled ? "True" : "False"),
-            new XAttribute("id", XmlId),
-            new XAttribute("name", XmlName),
-            new XElement("AppendLineFeed", new XAttribute("state", AppendLineFeed ? "True" : "False")),
-            new XElement("DataSourceType", new XAttribute("value", DataSourceType)),
-            FileId.ToXml("Calculation"));
-        if (DataSource is not null)
-        {
-            if (DataSource.IsVariable) step.Add(new XElement("Text"));
-            step.Add(DataSource.ToXml("Field"));
-        }
-        return step;
-    }
+    public override XElement ToXml() => StepXmlRenderer.Render(this, Metadata);
 
+    // Hand-written: Append line feed is a wire boolean displayed as a bare presence token, and the token order differs from shape order.
     public override string ToDisplayLine()
     {
         var writeAs = DataSourceType switch
@@ -54,24 +44,15 @@ public override string ToDisplayLine()
             "2" => "UTF-8",
             _ => DataSourceType,
         };
-        var parts = new System.Collections.Generic.List<string> { $"File ID: {FileId.Text}" };
+        var parts = new System.Collections.Generic.List<string> { $"File ID: {FileId?.Text ?? ""}" };
         if (DataSource is not null) parts.Add($"Data source: {DataSource.ToDisplayString()}");
         parts.Add($"Write as: {writeAs}");
         if (AppendLineFeed) parts.Add("Append line feed");
         return $"Write to Data File [ {string.Join(" ; ", parts)} ]";
     }
 
-    public static new ScriptStep FromXml(XElement step)
-    {
-        var enabled = step.Attribute("enable")?.Value != "False";
-        var append = step.Element("AppendLineFeed")?.Attribute("state")?.Value == "True";
-        var type = step.Element("DataSourceType")?.Attribute("value")?.Value ?? "2";
-        var fileIdEl = step.Element("Calculation");
-        var fileId = fileIdEl is not null ? Calculation.FromXml(fileIdEl) : new Calculation("");
-        var fieldEl = step.Element("Field");
-        var field = fieldEl is not null ? FieldRef.FromXml(fieldEl) : null;
-        return new WriteToDataFileStep(fileId, field, type, append, enabled);
-    }
+    public static new ScriptStep FromXml(XElement step) =>
+        StepXmlParser.Parse<WriteToDataFileStep>(step, Metadata);
 
     public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
     {
@@ -107,12 +88,15 @@ public static ScriptStep FromDisplayParams(bool enabled, string[] hrParams)
         Id = XmlId,
         Category = "files",
         HelpUrl = "https://help.claris.com/en/pro-help/content/write-to-data-file.html",
-        Params =
+        // Canonical: AppendLineFeed, DataSourceType, then the optional bare
+        // <Calculation> (file id) and field data source (variable target gets
+        // the bare <Text/> marker).
+        Shape =
         [
-            new ParamMetadata { Name = "Calculation", XmlElement = "Calculation", Type = "calculation", HrLabel = "File ID", Required = true },
-            new ParamMetadata { Name = "Field", XmlElement = "Field", Type = "field", HrLabel = "Data source" },
-            new ParamMetadata { Name = "DataSourceType", XmlElement = "DataSourceType", XmlAttr = "value", Type = "enum", HrLabel = "Write as", ValidValues = ["UTF-16", "UTF-8"], DefaultValue = "2" },
-            new ParamMetadata { Name = "AppendLineFeed", XmlElement = "AppendLineFeed", XmlAttr = "state", Type = "flagBoolean", HrLabel = "Append line feed" },
+            new BoolStateChild("AppendLineFeed") { PocoProperty = "AppendLineFeed", HrLabel = "Append line feed", Display = DisplayMode.Augmented },
+            new EnumValueChild("DataSourceType") { PocoProperty = "DataSourceType", HrLabel = "Write as", DefaultValue = "2", DisplayValues = ["UTF-16", "UTF-8"], Display = DisplayMode.Augmented },
+            new BareCalcChild { PocoProperty = "FileId", HrLabel = "File ID", Optional = true, Display = DisplayMode.Native },
+            new FieldChild("Field") { PocoProperty = "DataSource", HrLabel = "Data source", Optional = true, VariableTextMarker = true, Display = DisplayMode.Native },
         ],
         FromXml = FromXml,
         FromDisplay = FromDisplayParams,
diff --git a/src/SharpFM.Model/Scripting/Values/PdfOptions.cs b/src/SharpFM.Model/Scripting/Values/PdfOptions.cs
index 019ff2f..39f21b4 100644
--- a/src/SharpFM.Model/Scripting/Values/PdfOptions.cs
+++ b/src/SharpFM.Model/Scripting/Values/PdfOptions.cs
@@ -12,7 +12,9 @@ public sealed record PdfDocument(
     Calculation? Author,
     Calculation? Keywords,
     bool AllPages,
-    Calculation? NumberFrom)
+    Calculation? NumberFrom,
+    Calculation? PageRangeFrom = null,
+    Calculation? PageRangeTo = null)
 {
     public XElement ToXml()
     {
@@ -23,6 +25,13 @@ public XElement ToXml()
         if (Keywords is not null) el.Add(new XElement("Keywords", Keywords.ToXml("Calculation")));
         var pages = new XElement("Pages", new XAttribute("AllPages", AllPages ? "True" : "False"));
         if (NumberFrom is not null) pages.Add(new XElement("NumberFrom", NumberFrom.ToXml("Calculation")));
+        if (PageRangeFrom is not null || PageRangeTo is not null)
+        {
+            var range = new XElement("PageRange");
+            if (PageRangeFrom is not null) range.Add(new XElement("From", PageRangeFrom.ToXml("Calculation")));
+            if (PageRangeTo is not null) range.Add(new XElement("To", PageRangeTo.ToXml("Calculation")));
+            pages.Add(range);
+        }
         el.Add(pages);
         return el;
     }
@@ -33,13 +42,16 @@ public static PdfDocument FromXml(XElement element)
             parent?.Element("Calculation") is { } c ? Calculation.FromXml(c) : null;
 
         var pages = element.Element("Pages");
+        var range = pages?.Element("PageRange");
         return new PdfDocument(
             ReadCalc(element.Element("Title")),
             ReadCalc(element.Element("Subject")),
             ReadCalc(element.Element("Author")),
             ReadCalc(element.Element("Keywords")),
             pages?.Attribute("AllPages")?.Value == "True",
-            ReadCalc(pages?.Element("NumberFrom")));
+            ReadCalc(pages?.Element("NumberFrom")),
+            ReadCalc(range?.Element("From")),
+            ReadCalc(range?.Element("To")));
     }
 }
 
@@ -50,25 +62,38 @@ public sealed record PdfSecurity(
     string ControlEditing,
     string ControlPrinting,
     bool RequireControlEditPassword,
-    bool RequireOpenPassword)
+    bool RequireOpenPassword,
+    Calculation? OpenPassword = null,
+    Calculation? ControlPassword = null)
 {
-    public XElement ToXml() =>
-        new("Security",
+    public XElement ToXml()
+    {
+        var el = new XElement("Security",
             new XAttribute("allowScreenReader", AllowScreenReader ? "True" : "False"),
             new XAttribute("enableCopying", EnableCopying ? "True" : "False"),
             new XAttribute("controlEditing", ControlEditing),
             new XAttribute("controlPrinting", ControlPrinting),
             new XAttribute("requireControlEditPassword", RequireControlEditPassword ? "True" : "False"),
             new XAttribute("requireOpenPassword", RequireOpenPassword ? "True" : "False"));
+        if (OpenPassword is not null) el.Add(new XElement("OpenPassword", OpenPassword.ToXml("Calculation")));
+        if (ControlPassword is not null) el.Add(new XElement("ControlPassword", ControlPassword.ToXml("Calculation")));
+        return el;
+    }
 
-    public static PdfSecurity FromXml(XElement element) =>
-        new(
+    public static PdfSecurity FromXml(XElement element)
+    {
+        static Calculation? ReadCalc(XElement? parent) =>
+            parent?.Element("Calculation") is { } c ? Calculation.FromXml(c) : null;
+        return new(
             element.Attribute("allowScreenReader")?.Value == "True",
             element.Attribute("enableCopying")?.Value == "True",
             element.Attribute("controlEditing")?.Value ?? "AnyExceptExtractingPages",
             element.Attribute("controlPrinting")?.Value ?? "HighResolution",
             element.Attribute("requireControlEditPassword")?.Value == "True",
-            element.Attribute("requireOpenPassword")?.Value == "True");
+            element.Attribute("requireOpenPassword")?.Value == "True",
+            ReadCalc(element.Element("OpenPassword")),
+            ReadCalc(element.Element("ControlPassword")));
+    }
 
     public static PdfSecurity Default() => new(true, true, "AnyExceptExtractingPages", "HighResolution", false, false);
 }
@@ -92,12 +117,14 @@ public static PdfView FromXml(XElement element) =>
 }
 
 /// <summary>Full PDFOptions block with document / security / view.</summary>
-public sealed record PdfOptions(string Source, string? Appearance, PdfDocument Document, PdfSecurity Security, PdfView View)
+public sealed record PdfOptions(string Source, string? Appearance, PdfDocument Document, PdfSecurity Security, PdfView View, string SaveType = "File")
 {
     public XElement ToXml()
     {
         var el = new XElement("PDFOptions", new XAttribute("source", Source));
         if (Appearance is not null) el.Add(new XAttribute("appearance", Appearance));
+        // Canonical PDFOptions leads with the <PDFSaveType> element.
+        el.Add(new XElement("PDFSaveType", SaveType));
         el.Add(Document.ToXml());
         el.Add(Security.ToXml());
         el.Add(View.ToXml());
@@ -114,6 +141,7 @@ public static PdfOptions FromXml(XElement element)
             element.Attribute("appearance")?.Value,
             docEl is not null ? PdfDocument.FromXml(docEl) : new PdfDocument(null, null, null, null, true, null),
             secEl is not null ? PdfSecurity.FromXml(secEl) : PdfSecurity.Default(),
-            viewEl is not null ? PdfView.FromXml(viewEl) : PdfView.Default());
+            viewEl is not null ? PdfView.FromXml(viewEl) : PdfView.Default(),
+            element.Element("PDFSaveType")?.Value ?? "File");
     }
 }
diff --git a/src/SharpFM.Model/Scripting/Values/SendEventTarget.cs b/src/SharpFM.Model/Scripting/Values/SendEventTarget.cs
index dceb2e3..290ee68 100644
--- a/src/SharpFM.Model/Scripting/Values/SendEventTarget.cs
+++ b/src/SharpFM.Model/Scripting/Values/SendEventTarget.cs
@@ -16,15 +16,20 @@ public sealed record SendEventTarget(
     string Id,
     string Class)
 {
-    public XElement ToXml() =>
-        new("Event",
+    public XElement ToXml()
+    {
+        // Canonical form carries the three behaviour booleans always and only the
+        // populated target attributes; empty target descriptors are not emitted.
+        var el = new XElement("Event",
             new XAttribute("CopyResultToClipboard", CopyResultToClipboard ? "True" : "False"),
             new XAttribute("WaitForCompletion", WaitForCompletion ? "True" : "False"),
-            new XAttribute("BringTargetToForeground", BringTargetToForeground ? "True" : "False"),
-            new XAttribute("TargetType", TargetType),
-            new XAttribute("TargetName", TargetName),
-            new XAttribute("id", Id),
-            new XAttribute("class", Class));
+            new XAttribute("BringTargetToForeground", BringTargetToForeground ? "True" : "False"));
+        if (!string.IsNullOrEmpty(TargetType)) el.Add(new XAttribute("TargetType", TargetType));
+        if (!string.IsNullOrEmpty(TargetName)) el.Add(new XAttribute("TargetName", TargetName));
+        if (!string.IsNullOrEmpty(Id)) el.Add(new XAttribute("id", Id));
+        if (!string.IsNullOrEmpty(Class)) el.Add(new XAttribute("class", Class));
+        return el;
+    }
 
     public static SendEventTarget FromXml(XElement element) =>
         new(
diff --git a/src/SharpFM.Model/Scripting/Values/SerialNumberOptions.cs b/src/SharpFM.Model/Scripting/Values/SerialNumberOptions.cs
index 5131bbb..08f71a1 100644
--- a/src/SharpFM.Model/Scripting/Values/SerialNumberOptions.cs
+++ b/src/SharpFM.Model/Scripting/Values/SerialNumberOptions.cs
@@ -7,17 +7,26 @@ namespace SharpFM.Model.Scripting.Values;
 /// SerialNumbers. Attributes round-trip losslessly; they control how FM
 /// Pro interacts with the field's auto-enter serial options.
 /// </summary>
-public sealed record SerialNumberOptions(bool PerformAutoEnter, bool UpdateEntryOptions, bool UseEntryOptions)
+public sealed record SerialNumberOptions(
+    bool PerformAutoEnter,
+    bool UpdateEntryOptions,
+    bool UseEntryOptions,
+    string Increment = "0",
+    string InitialValue = "")
 {
     public XElement ToXml() =>
         new("SerialNumbers",
             new XAttribute("PerformAutoEnter", PerformAutoEnter ? "True" : "False"),
             new XAttribute("UpdateEntryOptions", UpdateEntryOptions ? "True" : "False"),
+            new XAttribute("increment", Increment),
+            new XAttribute("InitialValue", InitialValue),
             new XAttribute("UseEntryOptions", UseEntryOptions ? "True" : "False"));
 
     public static SerialNumberOptions FromXml(XElement element) =>
         new(
             element.Attribute("PerformAutoEnter")?.Value == "True",
             element.Attribute("UpdateEntryOptions")?.Value == "True",
-            element.Attribute("UseEntryOptions")?.Value == "True");
+            element.Attribute("UseEntryOptions")?.Value == "True",
+            element.Attribute("increment")?.Value ?? "0",
+            element.Attribute("InitialValue")?.Value ?? "");
 }
diff --git a/src/SharpFM.Model/Scripting/Values/SpeechOptions.cs b/src/SharpFM.Model/Scripting/Values/SpeechOptions.cs
index 402ffd1..a249ddb 100644
--- a/src/SharpFM.Model/Scripting/Values/SpeechOptions.cs
+++ b/src/SharpFM.Model/Scripting/Values/SpeechOptions.cs
@@ -9,12 +9,17 @@ namespace SharpFM.Model.Scripting.Values;
 /// </summary>
 public sealed record SpeechOptions(bool WaitForCompletion, string VoiceName, string VoiceId, string VoiceCreator)
 {
-    public XElement ToXml() =>
-        new("SpeechOptions",
-            new XAttribute("WaitForCompletion", WaitForCompletion ? "True" : "False"),
-            new XAttribute("VoiceName", VoiceName),
-            new XAttribute("VoiceId", VoiceId),
-            new XAttribute("VoiceCreator", VoiceCreator));
+    public XElement ToXml()
+    {
+        // Canonical form carries WaitForCompletion always and only the populated
+        // voice attributes; empty optional attributes are not emitted.
+        var el = new XElement("SpeechOptions",
+            new XAttribute("WaitForCompletion", WaitForCompletion ? "True" : "False"));
+        if (!string.IsNullOrEmpty(VoiceName)) el.Add(new XAttribute("VoiceName", VoiceName));
+        if (!string.IsNullOrEmpty(VoiceId)) el.Add(new XAttribute("VoiceId", VoiceId));
+        if (!string.IsNullOrEmpty(VoiceCreator)) el.Add(new XAttribute("VoiceCreator", VoiceCreator));
+        return el;
+    }
 
     public static SpeechOptions FromXml(XElement element) =>
         new(
diff --git a/src/SharpFM/Scripting/Editor/FmScriptCompletionProvider.cs b/src/SharpFM/Scripting/Editor/FmScriptCompletionProvider.cs
index b43ffa1..a4e9b8e 100644
--- a/src/SharpFM/Scripting/Editor/FmScriptCompletionProvider.cs
+++ b/src/SharpFM/Scripting/Editor/FmScriptCompletionProvider.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using AvaloniaEdit.CodeCompletion;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 
 namespace SharpFM.Scripting.Editor;
 
@@ -85,7 +86,7 @@ public static (CompletionContext Context, IList<ICompletionData> Items) GetCompl
         if (colonPos >= 0)
         {
             var label = currentSegment.Substring(0, colonPos).Trim();
-            var matchingParam = metadata.Params.FirstOrDefault(p =>
+            var matchingParam = ShapeHrView.HrNodes(metadata.Shape).FirstOrDefault(p =>
                 p.HrLabel?.Equals(label, StringComparison.OrdinalIgnoreCase) == true);
 
             if (matchingParam != null)
@@ -189,7 +190,7 @@ private static IList<ICompletionData> GetStepNameCompletions(string prefix)
 
     /// <summary>
     /// Build a Monaco-style snippet (<c>${N:placeholder}</c> tab-stops)
-    /// from the step's <see cref="ParamMetadata"/> so that accepting a
+    /// from the step's shape display slots so that accepting a
     /// step-name completion inserts the full bracketed form with the
     /// first parameter pre-selected for immediate editing.
     ///
@@ -202,20 +203,21 @@ private static IList<ICompletionData> GetStepNameCompletions(string prefix)
     /// </summary>
     private static string SynthesizeStepSnippet(StepMetadata metadata)
     {
-        if (metadata.Params.Count == 0)
+        var hrSlots = ShapeHrView.HrNodes(metadata.Shape);
+        if (hrSlots.Count == 0)
             return metadata.Name;
 
-        var segments = new List<string>(metadata.Params.Count);
+        var segments = new List<string>(hrSlots.Count);
         int index = 1;
-        foreach (var param in metadata.Params)
+        foreach (var slot in hrSlots)
         {
-            var placeholder = param.ValidValues?.FirstOrDefault()
-                ?? param.DefaultValue
-                ?? param.HrLabel
-                ?? param.Name
-                ?? "value";
+            var placeholder = ShapeHrView.DisplayValuesOf(slot).FirstOrDefault()
+                ?? slot.DefaultValue
+                ?? slot.HrLabel
+                ?? ShapeHrView.NameOf(slot);
+            if (string.IsNullOrEmpty(placeholder)) placeholder = "value";
             var tabStop = $"${{{index++}:{placeholder}}}";
-            segments.Add(param.HrLabel != null ? $"{param.HrLabel}: {tabStop}" : tabStop);
+            segments.Add(slot.HrLabel != null ? $"{slot.HrLabel}: {tabStop}" : tabStop);
         }
 
         return $"{metadata.Name} [ {string.Join(" ; ", segments)} ]";
@@ -226,16 +228,16 @@ private static IList<ICompletionData> GetParamLabelCompletions(
     {
         var items = new List<ICompletionData>();
 
-        foreach (var param in metadata.Params)
+        foreach (var slot in ShapeHrView.HrNodes(metadata.Shape))
         {
-            var label = param.HrLabel;
+            var label = slot.HrLabel;
             if (label == null) continue;
 
             if (existingParams.Contains(label + ":", StringComparison.OrdinalIgnoreCase))
                 continue;
 
-            var desc = param.Type;
-            var validValues = StepRegistry.GetValidValues(param);
+            var desc = ShapeHrView.KindOf(slot);
+            var validValues = ShapeHrView.DisplayValuesOf(slot);
             if (validValues.Count > 0)
                 desc += $" ({string.Join("|", validValues)})";
 
@@ -245,10 +247,9 @@ private static IList<ICompletionData> GetParamLabelCompletions(
         return items;
     }
 
-    private static IList<ICompletionData> GetParamValueCompletions(ParamMetadata param)
+    private static IList<ICompletionData> GetParamValueCompletions(ShapeNode slot)
     {
-        var validValues = StepRegistry.GetValidValues(param);
-        return validValues
+        return ShapeHrView.DisplayValuesOf(slot)
             .Select(v => (ICompletionData)new FmScriptCompletionData(v))
             .ToList();
     }
@@ -267,25 +268,26 @@ private static IList<ICompletionData> GetPositionalValueCompletions(
             .Where(s => s.Length > 0)
             .ToList();
 
+        var hrSlots = ShapeHrView.HrNodes(metadata.Shape);
         int positionalIndex = 0;
         foreach (var seg in segments)
         {
-            bool hasLabel = metadata.Params.Any(p =>
+            bool hasLabel = hrSlots.Any(p =>
                 p.HrLabel != null && seg.StartsWith(p.HrLabel + ":", StringComparison.OrdinalIgnoreCase));
             if (!hasLabel)
                 positionalIndex++;
         }
 
         int unlabeledCount = 0;
-        foreach (var param in metadata.Params)
+        foreach (var slot in hrSlots)
         {
-            if (param.HrLabel != null) continue;
+            if (slot.HrLabel != null) continue;
 
             if (unlabeledCount == positionalIndex)
             {
-                var values = StepRegistry.GetValidValues(param);
+                var values = ShapeHrView.DisplayValuesOf(slot);
                 foreach (var v in values)
-                    items.Add(new FmScriptCompletionData(v, param.XmlElement));
+                    items.Add(new FmScriptCompletionData(v, ShapeHrView.NameOf(slot)));
                 break;
             }
             unlabeledCount++;
diff --git a/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillDisplayRoundTripTests.cs b/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillDisplayRoundTripTests.cs
new file mode 100644
index 0000000..9858591
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillDisplayRoundTripTests.cs
@@ -0,0 +1,84 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting;
+using SharpFM.Model.Scripting.Serialization;
+using Xunit;
+
+namespace SharpFM.Tests.CanonicalSkill;
+
+/// <summary>
+/// The display-mutation contract: every step that claims
+/// <see cref="ScriptStep.IsFullyEditable"/> must survive
+/// XML → POCO → display line → display parse → POCO → XML with the emitted
+/// XML structurally equal to the canonical fixture. Steps whose display
+/// grammar cannot carry their XML (bags, opaque option blocks) are listed in
+/// <see cref="KnownDisplayDivergences"/> — the guard flips for them so the
+/// list shrinks as parsers become faithful, and each entry marks a step whose
+/// display edits are currently lossy despite IsFullyEditable being true.
+/// </summary>
+public class CanonicalSkillDisplayRoundTripTests
+{
+    public static IEnumerable<object[]> AllFixtures() =>
+        CanonicalSkillFixtures.Names().Select(n => new object[] { n });
+
+    [Theory]
+    [MemberData(nameof(AllFixtures))]
+    public void RoundTripsCanonical_ThroughDisplayText(string fixtureName)
+    {
+        var canonical = CanonicalSkillFixtures.Load(fixtureName);
+        var step = ScriptStep.FromXml(canonical);
+        if (!step.IsFullyEditable)
+        {
+            // Sealed: display edits are anchor-preserved, never parsed — the
+            // editor cannot lose this step's state, so it is not a divergence.
+            Assert.False(KnownDisplayDivergences.Names.Contains(fixtureName),
+                $"'{fixtureName}' is sealed — remove it from KnownDisplayDivergences.");
+            return;
+        }
+
+        var display = step.ToDisplayLine();
+        var reparsed = ReparseDisplay(display, step);
+        var roundTrips = reparsed is not null
+            && StructuralXml.Equal(canonical, reparsed.ToXml(), out _);
+        var why = reparsed is null
+            ? "display text does not parse back to a typed step"
+            : (StructuralXml.Equal(canonical, reparsed.ToXml(), out var diff) ? "" : diff);
+
+        if (KnownDisplayDivergences.Names.Contains(fixtureName))
+        {
+            Assert.False(roundTrips,
+                $"'{fixtureName}' now round-trips through display text — remove it from KnownDisplayDivergences.");
+        }
+        else
+        {
+            Assert.True(roundTrips,
+                $"'{fixtureName}' does not survive display-text mutation: {why}\n  display: {display}");
+        }
+    }
+
+    /// <summary>
+    /// Parse a display line the way the editor does: split/merge via
+    /// <see cref="ScriptLineParser"/>, then build the typed POCO through the
+    /// step's registered display factory. A blank line (empty divider
+    /// comment) parses back to an empty comment step. Returns null when the
+    /// display text does not resolve to a typed step (itself a divergence).
+    /// </summary>
+    private static ScriptStep? ReparseDisplay(string display, ScriptStep original)
+    {
+        var parsed = ScriptLineParser.Parse(display);
+        if (parsed.Count == 0)
+            return StepDisplayFactory.TryCreate("# (comment)", original.Enabled, [""]);
+        if (parsed.Count != 1) return null;
+
+        var line = parsed[0];
+        return StepDisplayFactory.TryCreate(line.StepName, !line.Disabled && original.Enabled, line.Params);
+    }
+
+    [Fact]
+    public void EveryKnownDisplayDivergence_HasAFixture()
+    {
+        var fixtures = CanonicalSkillFixtures.Names().ToHashSet(StringComparer.Ordinal);
+        var orphans = KnownDisplayDivergences.Names.Where(n => !fixtures.Contains(n)).ToList();
+        Assert.True(orphans.Count == 0,
+            "KnownDisplayDivergences names with no fixture: " + string.Join(", ", orphans));
+    }
+}
diff --git a/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillFixtures.cs b/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillFixtures.cs
new file mode 100644
index 0000000..0698d74
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillFixtures.cs
@@ -0,0 +1,79 @@
+using System.Xml.Linq;
+
+namespace SharpFM.Tests.CanonicalSkill;
+
+/// <summary>
+/// Loads the canonical-skill round-trip fixtures generated from the vendored
+/// skill markdown (see <c>docs/filemaker-xml-canonical</c>). Each fixture is
+/// one canonical <c>&lt;Step&gt;</c> element; its id and name live in the
+/// element's own attributes.
+/// </summary>
+public static class CanonicalSkillFixtures
+{
+    public static string Dir =>
+        Path.Combine(AppContext.BaseDirectory, "CanonicalSkill", "fixtures");
+
+    /// <summary>Fixture base names (file name without extension), Ordinal-sorted.</summary>
+    public static IEnumerable<string> Names() =>
+        Directory.GetFiles(Dir, "*.xml")
+            .Select(Path.GetFileNameWithoutExtension)
+            .OfType<string>()
+            .OrderBy(n => n, StringComparer.Ordinal);
+
+    public static XElement Load(string name) =>
+        XElement.Parse(File.ReadAllText(Path.Combine(Dir, name + ".xml")));
+}
+
+/// <summary>
+/// Structural XML equivalence used by the canonical round-trip suite:
+/// element local-names and child order must match exactly, leaf text must
+/// match (CDATA and plain text compare equal via <see cref="XElement.Value"/>),
+/// and attributes compare as an order-independent set. A canonical attribute
+/// value of <c>"N"</c> is the skill's documented placeholder for a
+/// file-specific id (script/layout/field/table) and matches any emitted value.
+/// </summary>
+public static class StructuralXml
+{
+    public static bool Equal(XElement canonical, XElement emitted, out string why)
+    {
+        why = "";
+        if (canonical.Name.LocalName != emitted.Name.LocalName)
+        {
+            why = $"name {canonical.Name.LocalName} != {emitted.Name.LocalName}";
+            return false;
+        }
+
+        var ca = canonical.Attributes().ToDictionary(x => x.Name.LocalName, x => x.Value);
+        var ea = emitted.Attributes().ToDictionary(x => x.Name.LocalName, x => x.Value);
+        foreach (var (k, v) in ca)
+        {
+            if (!ea.TryGetValue(k, out var ev)) { why = $"<{canonical.Name.LocalName}> missing emitted attr {k}"; return false; }
+            if (v == "N") continue; // skill placeholder wildcard
+            if (ev != v) { why = $"<{canonical.Name.LocalName}> attr {k}: '{v}' != '{ev}'"; return false; }
+        }
+        foreach (var k in ea.Keys)
+            if (!ca.ContainsKey(k)) { why = $"<{canonical.Name.LocalName}> extra emitted attr {k}"; return false; }
+
+        var cc = canonical.Elements().ToList();
+        var ec = emitted.Elements().ToList();
+        if (cc.Count != ec.Count)
+        {
+            why = $"<{canonical.Name.LocalName}> child count {cc.Count} != {ec.Count} " +
+                  $"[canon: {string.Join(",", cc.Select(e => e.Name.LocalName))}] " +
+                  $"[emit: {string.Join(",", ec.Select(e => e.Name.LocalName))}]";
+            return false;
+        }
+        if (cc.Count == 0)
+        {
+            if (canonical.Value.Trim() != emitted.Value.Trim())
+            {
+                why = $"<{canonical.Name.LocalName}> text '{canonical.Value.Trim()}' != '{emitted.Value.Trim()}'";
+                return false;
+            }
+            return true;
+        }
+        for (int i = 0; i < cc.Count; i++)
+            if (!Equal(cc[i], ec[i], out why)) return false;
+        return true;
+    }
+}
diff --git a/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillRoundTripTests.cs b/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillRoundTripTests.cs
new file mode 100644
index 0000000..e8badb5
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillRoundTripTests.cs
@@ -0,0 +1,49 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting;
+using Xunit;
+
+namespace SharpFM.Tests.CanonicalSkill;
+
+/// <summary>
+/// Drives every canonical-skill fixture through <see cref="ScriptStep.FromXml"/>
+/// and back out through <see cref="ScriptStep.ToXml"/>, asserting the emitted
+/// XML is structurally equivalent to the skill's canonical form. Fixtures known
+/// to diverge today are listed in <see cref="KnownDivergences"/>; the guard
+/// below flips them so the suite stays green while still flagging the moment a
+/// migrated step starts round-tripping.
+/// </summary>
+public class CanonicalSkillRoundTripTests
+{
+    public static IEnumerable<object[]> AllFixtures() =>
+        CanonicalSkillFixtures.Names().Select(n => new object[] { n });
+
+    [Theory]
+    [MemberData(nameof(AllFixtures))]
+    public void RoundTripsCanonical_FromSkill(string fixtureName)
+    {
+        var canonical = CanonicalSkillFixtures.Load(fixtureName);
+        var step = ScriptStep.FromXml(canonical);
+        var emitted = step.ToXml();
+        var roundTrips = StructuralXml.Equal(canonical, emitted, out var why);
+
+        if (KnownDivergences.Names.Contains(fixtureName))
+        {
+            Assert.False(roundTrips,
+                $"'{fixtureName}' now round-trips to canonical — remove it from KnownDivergences.");
+        }
+        else
+        {
+            Assert.True(roundTrips, $"'{fixtureName}' diverges from canonical: {why}");
+        }
+    }
+
+    [Fact]
+    public void EveryKnownDivergence_HasAFixture()
+    {
+        // Guard against stale entries: a name in the list with no fixture file
+        // means a rename slipped through.
+        var fixtures = CanonicalSkillFixtures.Names().ToHashSet(StringComparer.Ordinal);
+        var orphans = KnownDivergences.Names.Where(n => !fixtures.Contains(n)).ToList();
+        Assert.True(orphans.Count == 0, "KnownDivergences names with no fixture: " + string.Join(", ", orphans));
+    }
+}
diff --git a/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillValidatorTests.cs b/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillValidatorTests.cs
new file mode 100644
index 0000000..a16ec34
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/CanonicalSkillValidatorTests.cs
@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using Xunit;
+
+namespace SharpFM.Tests.CanonicalSkill;
+
+/// <summary>
+/// Cross-checks every shape-driven step's canonical XML against its declared
+/// <see cref="StepMetadata.Shape"/> using <see cref="StepXmlValidator"/>: each
+/// child element in the skill's canonical form must be one the shape can emit,
+/// in shape order. This catches a shape whose declared element order or
+/// membership drifts from the canonical form even where round-trip happens to
+/// pass, and exercises the validator that backs the MCP lint surface.
+/// </summary>
+public class CanonicalSkillValidatorTests
+{
+    public static IEnumerable<object[]> ShapeDrivenFixtures()
+    {
+        StepRegistry.Initialize();
+        foreach (var name in CanonicalSkillFixtures.Names())
+        {
+            var step = CanonicalSkillFixtures.Load(name);
+            var stepName = step.Attribute("name")?.Value ?? "";
+            if (StepRegistry.ByName.TryGetValue(stepName, out var meta) && meta.Shape.Count > 0)
+                yield return new object[] { name };
+        }
+    }
+
+    [Theory]
+    [MemberData(nameof(ShapeDrivenFixtures))]
+    public void CanonicalXml_ConformsToDeclaredShape(string fixtureName)
+    {
+        var step = CanonicalSkillFixtures.Load(fixtureName);
+        var meta = StepRegistry.ByName[step.Attribute("name")!.Value];
+
+        var issues = StepXmlValidator.Validate(step, meta);
+
+        Assert.True(issues.Count == 0,
+            $"'{fixtureName}' violates its declared shape: {string.Join("; ", issues)}");
+    }
+
+    [Fact]
+    public void ShapeDrivenSteps_AreCovered()
+    {
+        // Guard that the validator suite actually exercises a meaningful set of
+        // shape-driven steps (rather than silently degenerating to zero).
+        Assert.True(ShapeDrivenFixtures().Count() >= 20,
+            "Expected the validator to cover the shape-driven steps.");
+    }
+}
diff --git a/tests/SharpFM.Tests/CanonicalSkill/KnownDisplayDivergences.cs b/tests/SharpFM.Tests/CanonicalSkill/KnownDisplayDivergences.cs
new file mode 100644
index 0000000..f9829d4
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/KnownDisplayDivergences.cs
@@ -0,0 +1,21 @@
+namespace SharpFM.Tests.CanonicalSkill;
+
+/// <summary>
+/// Fixtures whose steps do NOT survive display-text mutation today (their
+/// display grammar or FromDisplay parser is lossy) even though the step
+/// claims <c>IsFullyEditable</c>. This is the display-accuracy worklist: as
+/// each step's display pair becomes faithful — or the step is sealed instead —
+/// remove its fixtures here; the round-trip test's guard fails until you do,
+/// so the list cannot silently drift out of sync with reality.
+/// </summary>
+public static class KnownDisplayDivergences
+{
+    // Empty: every documented step either survives display-text mutation or
+    // seals itself (IsFullyEditable false) when it carries state the display
+    // grammar cannot express — the editor anchor-preserves those instances.
+    // Add a fixture name here only if a future skill refresh introduces a
+    // configuration the display pair does not yet handle.
+    public static readonly IReadOnlySet<string> Names = new HashSet<string>(StringComparer.Ordinal)
+    {
+    };
+}
diff --git a/tests/SharpFM.Tests/CanonicalSkill/KnownDivergences.cs b/tests/SharpFM.Tests/CanonicalSkill/KnownDivergences.cs
new file mode 100644
index 0000000..f4051da
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/KnownDivergences.cs
@@ -0,0 +1,17 @@
+namespace SharpFM.Tests.CanonicalSkill;
+
+/// <summary>
+/// Fixtures whose current POCO output diverges from the skill's canonical
+/// form. This is the divergence inventory surfaced in phase 2 — the baseline
+/// the audit shrinks. As each step is migrated to the shape-driven renderer
+/// and starts round-tripping, remove its fixture name here; the round-trip
+/// test's guard fails until you do, so the list cannot silently drift out of
+/// sync with reality.
+/// </summary>
+public static class KnownDivergences
+{
+    // Empty: every documented step now round-trips to the skill's canonical form.
+    // Add a fixture name here only if a future skill refresh introduces a step
+    // whose canonical shape the model does not yet reproduce.
+    public static readonly IReadOnlySet<string> Names = new HashSet<string>(StringComparer.Ordinal);
+}
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/001-PerformScript.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/001-PerformScript.xml
new file mode 100644
index 0000000..24d6b93
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/001-PerformScript.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="1" name="Perform Script">
+  <Script id="N" name="script name" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/003-SaveACopyAsXML-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/003-SaveACopyAsXML-1.xml
new file mode 100644
index 0000000..a4193de
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/003-SaveACopyAsXML-1.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="3" name="Save a Copy as XML">
+  <Option state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/003-SaveACopyAsXML-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/003-SaveACopyAsXML-2.xml
new file mode 100644
index 0000000..79a1e2b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/003-SaveACopyAsXML-2.xml
@@ -0,0 +1,36 @@
+<Step enable="True" id="3" name="Save a Copy as XML">
+    <Option state="False" />
+    <OutputEntireBinaryData state="False" />
+    <SpecifyJSONOptions state="False" />
+    <SaXML>
+      <JSONOptions>
+        <Calculation><![CDATA[JSONSetElement ( "{}" ;
+  [ "catalogs_included" ; JSONMakeArray (
+  "PersistentStoreCatalog
+  BaseDirectoryCatalog
+  FileAccessCatalog
+  ExternalDataSourceCatalog
+  BaseTableCatalog
+  TableOccurrenceCatalog
+  CustomFunctionsCatalog
+  ValueListCatalog
+  FieldCatalog
+  RelationshipCatalog
+  CustomMenuCatalog
+  CustomMenuSetCatalog
+  ScriptCatalog
+  ThemeCatalog
+  LayoutCatalog
+  LibraryCatalog
+  PrivilegeSetsCatalog
+  ExtendedPrivilegesCatalog
+  AccountsCatalog
+  Metadata"
+  ; " " ; JSONString ) ; JSONArray ] ;
+  [ "include_details" ; False ; JSONBoolean ] ;
+  [ "split_catalogs" ; False ; JSONBoolean ] ;
+  [ "standalone_binarydata" ; False ; JSONBoolean ]
+)]]></Calculation>
+      </JSONOptions>
+    </SaXML>
+  </Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/004-GoToNextField.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/004-GoToNextField.xml
new file mode 100644
index 0000000..1482254
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/004-GoToNextField.xml
@@ -0,0 +1 @@
+<Step enable="True" id="4" name="Go to Next Field"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/005-GoToPreviousField.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/005-GoToPreviousField.xml
new file mode 100644
index 0000000..e109c58
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/005-GoToPreviousField.xml
@@ -0,0 +1 @@
+<Step enable="True" id="5" name="Go to Previous Field"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/006-GoToLayout-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/006-GoToLayout-1.xml
new file mode 100644
index 0000000..2b289b7
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/006-GoToLayout-1.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="6" name="Go to Layout">
+  <LayoutDestination value="OriginalLayout" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/006-GoToLayout-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/006-GoToLayout-2.xml
new file mode 100644
index 0000000..f1e3cc2
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/006-GoToLayout-2.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="6" name="Go to Layout">
+  <LayoutDestination value="SelectedLayout" />
+  <Layout id="N" name="layout name" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/007-NewRecordRequest.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/007-NewRecordRequest.xml
new file mode 100644
index 0000000..ea7dfc7
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/007-NewRecordRequest.xml
@@ -0,0 +1 @@
+<Step enable="True" id="7" name="New Record/Request"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/008-DuplicateRecordRequest.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/008-DuplicateRecordRequest.xml
new file mode 100644
index 0000000..bd31165
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/008-DuplicateRecordRequest.xml
@@ -0,0 +1 @@
+<Step enable="True" id="8" name="Duplicate Record/Request"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/009-DeleteRecordRequest.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/009-DeleteRecordRequest.xml
new file mode 100644
index 0000000..31d60bb
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/009-DeleteRecordRequest.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="9" name="Delete Record/Request">
+  <NoInteract state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/010-DeleteAllRecords.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/010-DeleteAllRecords.xml
new file mode 100644
index 0000000..59ec208
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/010-DeleteAllRecords.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="10" name="Delete All Records">
+  <NoInteract state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/011-InsertFromIndex.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/011-InsertFromIndex.xml
new file mode 100644
index 0000000..93b1d65
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/011-InsertFromIndex.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="11" name="Insert from Index">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/012-InsertFromLastVisited.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/012-InsertFromLastVisited.xml
new file mode 100644
index 0000000..8c6d86e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/012-InsertFromLastVisited.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="12" name="Insert from Last Visited">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/013-InsertCurrentDate.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/013-InsertCurrentDate.xml
new file mode 100644
index 0000000..d873007
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/013-InsertCurrentDate.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="13" name="Insert Current Date">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/014-InsertCurrentTime.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/014-InsertCurrentTime.xml
new file mode 100644
index 0000000..5a51b9f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/014-InsertCurrentTime.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="14" name="Insert Current Time">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/016-GoToRecordRequestPage.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/016-GoToRecordRequestPage.xml
new file mode 100644
index 0000000..1636aa2
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/016-GoToRecordRequestPage.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="16" name="Go to Record/Request/Page">
+  <NoInteract state="False" />
+  <RowPageLocation value="First" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/017-GoToField-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/017-GoToField-1.xml
new file mode 100644
index 0000000..f2c575a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/017-GoToField-1.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="17" name="Go to Field">
+  <SelectAll state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/017-GoToField-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/017-GoToField-2.xml
new file mode 100644
index 0000000..accdb9a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/017-GoToField-2.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="17" name="Go to Field">
+  <SelectAll state="False" />
+  <Field table="TableOccurrence" id="N" name="field_name" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/018-CheckSelection.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/018-CheckSelection.xml
new file mode 100644
index 0000000..7a2ed6c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/018-CheckSelection.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="18" name="Check Selection">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/019-CheckRecord.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/019-CheckRecord.xml
new file mode 100644
index 0000000..367b370
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/019-CheckRecord.xml
@@ -0,0 +1 @@
+<Step enable="True" id="19" name="Check Record"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/020-CheckFoundSet.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/020-CheckFoundSet.xml
new file mode 100644
index 0000000..75ba632
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/020-CheckFoundSet.xml
@@ -0,0 +1 @@
+<Step enable="True" id="20" name="Check Found Set"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/021-UnsortRecords.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/021-UnsortRecords.xml
new file mode 100644
index 0000000..7d63431
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/021-UnsortRecords.xml
@@ -0,0 +1 @@
+<Step enable="True" id="21" name="Unsort Records" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/022-EnterFindMode.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/022-EnterFindMode.xml
new file mode 100644
index 0000000..ec379fd
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/022-EnterFindMode.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="22" name="Enter Find Mode">
+  <Pause state="True" />
+  <Restore state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/023-ShowAllRecords.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/023-ShowAllRecords.xml
new file mode 100644
index 0000000..04729b0
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/023-ShowAllRecords.xml
@@ -0,0 +1 @@
+<Step enable="True" id="23" name="Show All Records"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/024-ModifyLastFind.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/024-ModifyLastFind.xml
new file mode 100644
index 0000000..9139204
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/024-ModifyLastFind.xml
@@ -0,0 +1 @@
+<Step enable="True" id="24" name="Modify Last Find"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/025-OmitRecord.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/025-OmitRecord.xml
new file mode 100644
index 0000000..b82d240
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/025-OmitRecord.xml
@@ -0,0 +1 @@
+<Step enable="True" id="25" name="Omit Record"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/026-OmitMultipleRecords.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/026-OmitMultipleRecords.xml
new file mode 100644
index 0000000..03ba374
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/026-OmitMultipleRecords.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="26" name="Omit Multiple Records">
+  <NoInteract state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/027-ShowOmittedOnly.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/027-ShowOmittedOnly.xml
new file mode 100644
index 0000000..a94b0b2
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/027-ShowOmittedOnly.xml
@@ -0,0 +1 @@
+<Step enable="True" id="27" name="Show Omitted Only"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/028-PerformFind-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/028-PerformFind-1.xml
new file mode 100644
index 0000000..f153276
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/028-PerformFind-1.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="28" name="Perform Find">
+  <Restore state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/028-PerformFind-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/028-PerformFind-2.xml
new file mode 100644
index 0000000..65745ab
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/028-PerformFind-2.xml
@@ -0,0 +1,15 @@
+<Step enable="True" id="28" name="Perform Find">
+  <Restore state="True" />
+  <Query>
+    <RequestRow operation="Include">
+      <Criteria>
+        <Field table="TableOccurrence" id="N" name="field_a" />
+        <Text>==$variable</Text>
+      </Criteria>
+      <Criteria>
+        <Field table="TableOccurrence" id="N" name="field_b" />
+        <Text>*</Text>
+      </Criteria>
+    </RequestRow>
+  </Query>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/029-ShowHideToolbars.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/029-ShowHideToolbars.xml
new file mode 100644
index 0000000..8916b2e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/029-ShowHideToolbars.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="29" name="Show/Hide Toolbars">
+  <IncludeEditRecordToolbar state="True" />
+  <Lock state="False" />
+  <ShowHide value="Hide" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/030-ViewAs.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/030-ViewAs.xml
new file mode 100644
index 0000000..a363cf3
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/030-ViewAs.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="30" name="View As">
+  <View value="Cycle" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/031-AdjustWindow.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/031-AdjustWindow.xml
new file mode 100644
index 0000000..099279f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/031-AdjustWindow.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="31" name="Adjust Window">
+  <WindowState value="ResizeToFit" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/032-OpenHelp.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/032-OpenHelp.xml
new file mode 100644
index 0000000..f3d3814
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/032-OpenHelp.xml
@@ -0,0 +1 @@
+<Step enable="True" id="32" name="Open Help" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/033-OpenFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/033-OpenFile.xml
new file mode 100644
index 0000000..927c33c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/033-OpenFile.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="33" name="Open File">
+  <Option state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/034-CloseFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/034-CloseFile.xml
new file mode 100644
index 0000000..61fb4f6
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/034-CloseFile.xml
@@ -0,0 +1 @@
+<Step enable="True" id="34" name="Close File"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/035-ImportRecords.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/035-ImportRecords.xml
new file mode 100644
index 0000000..3d2b3b1
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/035-ImportRecords.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="35" name="Import Records">
+  <NoInteract state="True" />
+  <Restore state="False" />
+  <VerifySSLCertificates state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/036-ExportRecords.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/036-ExportRecords.xml
new file mode 100644
index 0000000..7b3b23e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/036-ExportRecords.xml
@@ -0,0 +1,7 @@
+<Step enable="True" id="36" name="Export Records">
+  <NoInteract state="True" />
+  <CreateDirectories state="True" />
+  <Restore state="False" />
+  <AutoOpen state="False" />
+  <CreateEmail state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/037-SaveACopyAs.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/037-SaveACopyAs.xml
new file mode 100644
index 0000000..6578211
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/037-SaveACopyAs.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="37" name="Save a Copy as">
+  <CreateDirectories state="True" />
+  <AutoOpen state="False" />
+  <CreateEmail state="False" />
+  <SaveAsType value="Copy" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/038-OpenManageDatabase.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/038-OpenManageDatabase.xml
new file mode 100644
index 0000000..4bca11c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/038-OpenManageDatabase.xml
@@ -0,0 +1 @@
+<Step enable="True" id="38" name="Open Manage Database" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/039-SortRecords-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/039-SortRecords-1.xml
new file mode 100644
index 0000000..c3a9641
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/039-SortRecords-1.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="39" name="Sort Records">
+  <NoInteract state="True" />
+  <Restore state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/039-SortRecords-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/039-SortRecords-2.xml
new file mode 100644
index 0000000..3e9cae9
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/039-SortRecords-2.xml
@@ -0,0 +1,16 @@
+<Step enable="True" id="39" name="Sort Records">
+  <NoInteract state="True" />
+  <Restore state="True" />
+  <SortList Maintain="True" value="True">
+    <Sort type="Ascending">
+      <PrimaryField>
+        <Field table="TableOccurrence" id="N" name="field_a" />
+      </PrimaryField>
+    </Sort>
+    <Sort type="Ascending">
+      <PrimaryField>
+        <Field table="TableOccurrence" id="N" name="field_b" />
+      </PrimaryField>
+    </Sort>
+  </SortList>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/040-RelookupFieldContents.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/040-RelookupFieldContents.xml
new file mode 100644
index 0000000..3943c57
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/040-RelookupFieldContents.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="40" name="Relookup Field Contents">
+  <NoInteract state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/041-EnterPreviewMode.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/041-EnterPreviewMode.xml
new file mode 100644
index 0000000..7d925cb
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/041-EnterPreviewMode.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="41" name="Enter Preview Mode">
+  <Pause state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/042-PrintSetup.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/042-PrintSetup.xml
new file mode 100644
index 0000000..dafa26b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/042-PrintSetup.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="42" name="Print Setup">
+  <NoInteract state="True" />
+  <Restore state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/043-Print.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/043-Print.xml
new file mode 100644
index 0000000..13cfd8b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/043-Print.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="43" name="Print">
+  <NoInteract state="True" />
+  <Restore state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/044-ExitApplication.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/044-ExitApplication.xml
new file mode 100644
index 0000000..66bd67e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/044-ExitApplication.xml
@@ -0,0 +1 @@
+<Step enable="True" id="44" name="Exit Application"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/045-UndoRedo.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/045-UndoRedo.xml
new file mode 100644
index 0000000..4b6fa45
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/045-UndoRedo.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="45" name="Undo/Redo">
+  <UndoRedo value="Undo" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/046-Cut.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/046-Cut.xml
new file mode 100644
index 0000000..08b475c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/046-Cut.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="46" name="Cut">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/047-Copy.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/047-Copy.xml
new file mode 100644
index 0000000..0e6626d
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/047-Copy.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="47" name="Copy">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/048-Paste.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/048-Paste.xml
new file mode 100644
index 0000000..e48fa60
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/048-Paste.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="48" name="Paste">
+  <NoStyle state="True" />
+  <SelectAll state="True" />
+  <LinkAvail state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/049-Clear.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/049-Clear.xml
new file mode 100644
index 0000000..39a06b8
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/049-Clear.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="49" name="Clear">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/050-SelectAll.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/050-SelectAll.xml
new file mode 100644
index 0000000..4ca21cc
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/050-SelectAll.xml
@@ -0,0 +1 @@
+<Step enable="True" id="50" name="Select All"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/051-RevertRecordRequest.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/051-RevertRecordRequest.xml
new file mode 100644
index 0000000..f2c2216
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/051-RevertRecordRequest.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="51" name="Revert Record/Request">
+  <NoInteract state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/055-EnterBrowseMode.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/055-EnterBrowseMode.xml
new file mode 100644
index 0000000..4092820
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/055-EnterBrowseMode.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="55" name="Enter Browse Mode">
+  <Pause state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/056-InsertPicture.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/056-InsertPicture.xml
new file mode 100644
index 0000000..8711746
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/056-InsertPicture.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="56" name="Insert Picture">
+  <UniversalPathList type="Embedded" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/057-SendEvent.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/057-SendEvent.xml
new file mode 100644
index 0000000..144abf2
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/057-SendEvent.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="57" name="Send Event">
+  <ContentType value="File" />
+  <Event CopyResultToClipboard="False" WaitForCompletion="False" BringTargetToForeground="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/060-InsertCurrentUserName.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/060-InsertCurrentUserName.xml
new file mode 100644
index 0000000..b7362d2
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/060-InsertCurrentUserName.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="60" name="Insert Current User Name">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/061-InsertText.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/061-InsertText.xml
new file mode 100644
index 0000000..316f52c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/061-InsertText.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="61" name="Insert Text">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/062-PauseResumeScript.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/062-PauseResumeScript.xml
new file mode 100644
index 0000000..8c9e3f5
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/062-PauseResumeScript.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="62" name="Pause/Resume Script">
+  <PauseTime value="Indefinitely" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/063-SendMail.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/063-SendMail.xml
new file mode 100644
index 0000000..54748e2
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/063-SendMail.xml
@@ -0,0 +1,9 @@
+<Step enable="True" id="63" name="Send Mail">
+  <NoInteract state="True" />
+  <MultipleEmails state="False" />
+  <SendViaSMTP state="False" />
+  <SendViaOAuthAuthentication state="False" />
+  <SMTPEncryptionType type="SMTPEncryptionNone" />
+  <SMTPAuthenticationType type="SMTPAuthenticationNone" />
+  <OAuthProvider type="OAuthProviderGoogle" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/064-SendDDEExecute.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/064-SendDDEExecute.xml
new file mode 100644
index 0000000..78d3c1d
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/064-SendDDEExecute.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="64" name="Send DDE Execute">
+  <ContentType value="File" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/065-DialPhone.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/065-DialPhone.xml
new file mode 100644
index 0000000..7b3796a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/065-DialPhone.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="65" name="Dial Phone">
+  <NoInteract state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/066-Speak.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/066-Speak.xml
new file mode 100644
index 0000000..6b632d7
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/066-Speak.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="66" name="Speak">
+  <SpeechOptions WaitForCompletion="True" VoiceId="0" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/067-PerformAppleScript.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/067-PerformAppleScript.xml
new file mode 100644
index 0000000..7957a4c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/067-PerformAppleScript.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="67" name="Perform AppleScript">
+  <ContentType value="Text" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/068-If.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/068-If.xml
new file mode 100644
index 0000000..8dd68fc
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/068-If.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="68" name="If">
+  <Restore state="False" />
+  <Calculation><![CDATA[condition]]></Calculation>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/069-Else.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/069-Else.xml
new file mode 100644
index 0000000..5b24214
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/069-Else.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="69" name="Else">
+  <Restore state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/070-EndIf.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/070-EndIf.xml
new file mode 100644
index 0000000..51b202d
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/070-EndIf.xml
@@ -0,0 +1 @@
+<Step enable="True" id="70" name="End If"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/071-Loop.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/071-Loop.xml
new file mode 100644
index 0000000..19c16d1
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/071-Loop.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="71" name="Loop">
+  <Restore state="False" />
+  <FlushType value="Always" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/072-ExitLoopIf.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/072-ExitLoopIf.xml
new file mode 100644
index 0000000..eb63595
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/072-ExitLoopIf.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="72" name="Exit Loop If">
+  <Calculation><![CDATA[condition]]></Calculation>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/073-EndLoop.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/073-EndLoop.xml
new file mode 100644
index 0000000..696b28e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/073-EndLoop.xml
@@ -0,0 +1 @@
+<Step enable="True" id="73" name="End Loop"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/074-GoToRelatedRecord-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/074-GoToRelatedRecord-1.xml
new file mode 100644
index 0000000..1a183ba
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/074-GoToRelatedRecord-1.xml
@@ -0,0 +1,10 @@
+<Step enable="True" id="74" name="Go to Related Record">
+  <Option state="False" />
+  <MatchAllRecords state="False" />
+  <ShowInNewWindow state="False" />
+  <Restore state="True" />
+  <LayoutDestination value="SelectedLayout" />
+  <NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="983554" />
+  <Table id="N" name="table occurrence name" />
+  <Layout id="N" name="layout name" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/074-GoToRelatedRecord-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/074-GoToRelatedRecord-2.xml
new file mode 100644
index 0000000..1cf10d1
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/074-GoToRelatedRecord-2.xml
@@ -0,0 +1,9 @@
+<Step enable="True" id="74" name="Go to Related Record">
+  <Option state="False" />
+  <MatchAllRecords state="False" />
+  <ShowInNewWindow state="False" />
+  <Restore state="False" />
+  <LayoutDestination value="CurrentLayout" />
+  <NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="3606018" />
+  <Table id="0" name="" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/075-CommitRecordsRequests.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/075-CommitRecordsRequests.xml
new file mode 100644
index 0000000..5e9380c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/075-CommitRecordsRequests.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="75" name="Commit Records/Requests">
+  <NoInteract state="True" />
+  <Option state="False" />
+  <ESSForceCommit state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/076-SetField-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/076-SetField-1.xml
new file mode 100644
index 0000000..f2fc786
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/076-SetField-1.xml
@@ -0,0 +1 @@
+<Step enable="True" id="76" name="Set Field" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/076-SetField-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/076-SetField-2.xml
new file mode 100644
index 0000000..4fd0bfa
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/076-SetField-2.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="76" name="Set Field">
+  <Calculation><![CDATA[expression]]></Calculation>
+  <Field table="TableOccurrence" id="N" name="field_name" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/077-InsertCalculatedResult.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/077-InsertCalculatedResult.xml
new file mode 100644
index 0000000..9f5c656
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/077-InsertCalculatedResult.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="77" name="Insert Calculated Result">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/079-FreezeWindow.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/079-FreezeWindow.xml
new file mode 100644
index 0000000..628698f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/079-FreezeWindow.xml
@@ -0,0 +1 @@
+<Step enable="True" id="79" name="Freeze Window"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/080-RefreshWindow.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/080-RefreshWindow.xml
new file mode 100644
index 0000000..e5f2bae
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/080-RefreshWindow.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="80" name="Refresh Window">
+  <Option state="False" />
+  <FlushSQLData state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/081-ScrollWindow.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/081-ScrollWindow.xml
new file mode 100644
index 0000000..163118d
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/081-ScrollWindow.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="81" name="Scroll Window">
+  <ScrollOperation value="Home" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/082-NewFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/082-NewFile.xml
new file mode 100644
index 0000000..eb76ef8
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/082-NewFile.xml
@@ -0,0 +1 @@
+<Step enable="True" id="82" name="New File"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/083-ChangePassword.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/083-ChangePassword.xml
new file mode 100644
index 0000000..827c843
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/083-ChangePassword.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="83" name="Change Password">
+  <NoInteract state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/084-SetMultiUser.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/084-SetMultiUser.xml
new file mode 100644
index 0000000..bf9eac9
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/084-SetMultiUser.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="84" name="Set Multi-User">
+  <MultiUser value="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/085-AllowUserAbort.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/085-AllowUserAbort.xml
new file mode 100644
index 0000000..c3ed090
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/085-AllowUserAbort.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="85" name="Allow User Abort">
+  <Set state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/086-SetErrorCapture.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/086-SetErrorCapture.xml
new file mode 100644
index 0000000..cb683f8
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/086-SetErrorCapture.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="86" name="Set Error Capture">
+  <Set state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-1.xml
new file mode 100644
index 0000000..5278c0d
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-1.xml
@@ -0,0 +1 @@
+<Step enable="True" id="87" name="Show Custom Dialog" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-2.xml
new file mode 100644
index 0000000..285380d
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-2.xml
@@ -0,0 +1,29 @@
+<Step enable="True" id="87" name="Show Custom Dialog">
+  <Title>
+    <Calculation><![CDATA["Dialog Title"]]></Calculation>
+  </Title>
+  <Message>
+    <Calculation><![CDATA["Message text"]]></Calculation>
+  </Message>
+  <Height>
+    <Calculation><![CDATA[200]]></Calculation>
+  </Height>
+  <Width>
+    <Calculation><![CDATA[400]]></Calculation>
+  </Width>
+  <DistanceFromTop>
+    <Calculation><![CDATA[100]]></Calculation>
+  </DistanceFromTop>
+  <DistanceFromLeft>
+    <Calculation><![CDATA[100]]></Calculation>
+  </DistanceFromLeft>
+  <Buttons>
+    <Button CommitState="True">
+      <Calculation><![CDATA["OK"]]></Calculation>
+    </Button>
+    <Button CommitState="False">
+      <Calculation><![CDATA["Cancel"]]></Calculation>
+    </Button>
+    <Button CommitState="False" />
+  </Buttons>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-3.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-3.xml
new file mode 100644
index 0000000..89d6bf0
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-3.xml
@@ -0,0 +1,12 @@
+<Step enable="True" id="87" name="Show Custom Dialog">
+  <Message>
+    <Calculation><![CDATA["message text"]]></Calculation>
+  </Message>
+  <Buttons>
+    <Button CommitState="True">
+      <Calculation><![CDATA["OK"]]></Calculation>
+    </Button>
+    <Button CommitState="False" />
+    <Button CommitState="False" />
+  </Buttons>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-4.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-4.xml
new file mode 100644
index 0000000..89e0749
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/087-ShowCustomDialog-4.xml
@@ -0,0 +1,15 @@
+<Step enable="True" id="87" name="Show Custom Dialog">
+  <Title>
+    <Calculation><![CDATA["Error"]]></Calculation>
+  </Title>
+  <Message>
+    <Calculation><![CDATA["Unable to mount fileserver"]]></Calculation>
+  </Message>
+  <Buttons>
+    <Button CommitState="False">
+      <Calculation><![CDATA["OK"]]></Calculation>
+    </Button>
+    <Button CommitState="False" />
+    <Button CommitState="False" />
+  </Buttons>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/088-OpenScriptWorkspace.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/088-OpenScriptWorkspace.xml
new file mode 100644
index 0000000..cb043c9
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/088-OpenScriptWorkspace.xml
@@ -0,0 +1 @@
+<Step enable="True" id="88" name="Open Script Workspace" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/089-Comment-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/089-Comment-1.xml
new file mode 100644
index 0000000..5846d5b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/089-Comment-1.xml
@@ -0,0 +1 @@
+<Step enable="True" id="89" name="# (comment)" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/089-Comment-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/089-Comment-2.xml
new file mode 100644
index 0000000..b0d076d
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/089-Comment-2.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="89" name="# (comment)">
+  <Text>comment text</Text>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/090-HaltScript.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/090-HaltScript.xml
new file mode 100644
index 0000000..5b1ddaf
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/090-HaltScript.xml
@@ -0,0 +1 @@
+<Step enable="True" id="90" name="Halt Script"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/091-ReplaceFieldContents.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/091-ReplaceFieldContents.xml
new file mode 100644
index 0000000..e653f32
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/091-ReplaceFieldContents.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="91" name="Replace Field Contents">
+  <NoInteract state="True" />
+  <Restore state="False" />
+  <With value="None" />
+  <SerialNumbers PerformAutoEnter="False" UpdateEntryOptions="False" increment="0" InitialValue="" UseEntryOptions="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/092-ShowHideTextRuler.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/092-ShowHideTextRuler.xml
new file mode 100644
index 0000000..f6f311f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/092-ShowHideTextRuler.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="92" name="Show/Hide Text Ruler">
+  <ShowHide value="Show" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/093-Beep.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/093-Beep.xml
new file mode 100644
index 0000000..629d175
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/093-Beep.xml
@@ -0,0 +1 @@
+<Step enable="True" id="93" name="Beep"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/094-SetUseSystemFormats.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/094-SetUseSystemFormats.xml
new file mode 100644
index 0000000..223580d
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/094-SetUseSystemFormats.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="94" name="Set Use System Formats">
+  <Set state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/095-RecoverFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/095-RecoverFile.xml
new file mode 100644
index 0000000..d9ffb9c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/095-RecoverFile.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="95" name="Recover File">
+  <NoInteract state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/096-SaveACopyAsAddOnPackage.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/096-SaveACopyAsAddOnPackage.xml
new file mode 100644
index 0000000..65e763c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/096-SaveACopyAsAddOnPackage.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="96" name="Save a Copy as Add-on Package">
+  <LinkAvail state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/097-SetZoomLevel-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/097-SetZoomLevel-1.xml
new file mode 100644
index 0000000..f05570b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/097-SetZoomLevel-1.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="97" name="Set Zoom Level">
+  <Lock state="False" />
+  <Zoom value="100" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/097-SetZoomLevel-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/097-SetZoomLevel-2.xml
new file mode 100644
index 0000000..2c06927
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/097-SetZoomLevel-2.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="97" name="Set Zoom Level">
+  <Lock state="False" />
+  <Zoom value="ByCalculation" />
+  <Calculation><![CDATA[zoom percentage expression]]></Calculation>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/098-CopyAllRecordsRequests.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/098-CopyAllRecordsRequests.xml
new file mode 100644
index 0000000..0429168
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/098-CopyAllRecordsRequests.xml
@@ -0,0 +1 @@
+<Step enable="True" id="98" name="Copy All Records/Requests"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/099-GoToPortalRow-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/099-GoToPortalRow-1.xml
new file mode 100644
index 0000000..10a66ba
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/099-GoToPortalRow-1.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="99" name="Go to Portal Row">
+  <NoInteract state="False" />
+  <SelectAll state="False" />
+  <RowPageLocation value="First" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/099-GoToPortalRow-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/099-GoToPortalRow-2.xml
new file mode 100644
index 0000000..7b10c50
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/099-GoToPortalRow-2.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="99" name="Go to Portal Row">
+  <NoInteract state="True" />
+  <SelectAll state="True" />
+  <RowPageLocation value="ByCalculation" />
+  <Calculation><![CDATA[$loop_counter]]></Calculation>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/101-CopyRecordRequest.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/101-CopyRecordRequest.xml
new file mode 100644
index 0000000..57803cc
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/101-CopyRecordRequest.xml
@@ -0,0 +1 @@
+<Step enable="True" id="101" name="Copy Record/Request"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/102-FlushCacheToDisk.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/102-FlushCacheToDisk.xml
new file mode 100644
index 0000000..d68dc48
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/102-FlushCacheToDisk.xml
@@ -0,0 +1 @@
+<Step enable="True" id="102" name="Flush Cache to Disk"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/103-ExitScript-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/103-ExitScript-1.xml
new file mode 100644
index 0000000..5626b88
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/103-ExitScript-1.xml
@@ -0,0 +1 @@
+<Step enable="True" id="103" name="Exit Script" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/103-ExitScript-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/103-ExitScript-2.xml
new file mode 100644
index 0000000..8db695b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/103-ExitScript-2.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="103" name="Exit Script">
+  <Calculation><![CDATA[return value]]></Calculation>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/104-DeletePortalRow.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/104-DeletePortalRow.xml
new file mode 100644
index 0000000..4ccbc2c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/104-DeletePortalRow.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="104" name="Delete Portal Row">
+  <NoInteract state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/105-OpenSettings.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/105-OpenSettings.xml
new file mode 100644
index 0000000..a8d157b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/105-OpenSettings.xml
@@ -0,0 +1 @@
+<Step enable="True" id="105" name="Open Settings" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/106-CorrectWord.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/106-CorrectWord.xml
new file mode 100644
index 0000000..ce57bbf
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/106-CorrectWord.xml
@@ -0,0 +1 @@
+<Step enable="True" id="106" name="Correct Word"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/107-SpellingOptions.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/107-SpellingOptions.xml
new file mode 100644
index 0000000..485c60a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/107-SpellingOptions.xml
@@ -0,0 +1 @@
+<Step enable="True" id="107" name="Spelling Options" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/108-SelectDictionaries.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/108-SelectDictionaries.xml
new file mode 100644
index 0000000..45cf3eb
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/108-SelectDictionaries.xml
@@ -0,0 +1 @@
+<Step enable="True" id="108" name="Select Dictionaries"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/109-EditUserDictionary.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/109-EditUserDictionary.xml
new file mode 100644
index 0000000..bb98bd7
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/109-EditUserDictionary.xml
@@ -0,0 +1 @@
+<Step enable="True" id="109" name="Edit User Dictionary"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/111-OpenURL.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/111-OpenURL.xml
new file mode 100644
index 0000000..356ed9a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/111-OpenURL.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="111" name="Open URL">
+  <NoInteract state="True" />
+  <Option state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/112-OpenManageValueLists.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/112-OpenManageValueLists.xml
new file mode 100644
index 0000000..312bb53
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/112-OpenManageValueLists.xml
@@ -0,0 +1 @@
+<Step enable="True" id="112" name="Open Manage Value Lists" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/113-OpenSharing.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/113-OpenSharing.xml
new file mode 100644
index 0000000..b69a0fb
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/113-OpenSharing.xml
@@ -0,0 +1 @@
+<Step enable="True" id="113" name="Open Sharing" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/114-OpenFileOptions.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/114-OpenFileOptions.xml
new file mode 100644
index 0000000..0026d73
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/114-OpenFileOptions.xml
@@ -0,0 +1 @@
+<Step enable="True" id="114" name="Open File Options" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/115-AllowFormattingBar.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/115-AllowFormattingBar.xml
new file mode 100644
index 0000000..deda4d6
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/115-AllowFormattingBar.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="115" name="Allow Formatting Bar">
+  <Set state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/116-SetNextSerialValue.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/116-SetNextSerialValue.xml
new file mode 100644
index 0000000..9f47aee
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/116-SetNextSerialValue.xml
@@ -0,0 +1 @@
+<Step enable="True" id="116" name="Set Next Serial Value" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/117-ExecuteSQL.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/117-ExecuteSQL.xml
new file mode 100644
index 0000000..74dd5c9
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/117-ExecuteSQL.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="117" name="Execute SQL">
+  <NoInteract state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/118-OpenHosts.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/118-OpenHosts.xml
new file mode 100644
index 0000000..c89fb8e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/118-OpenHosts.xml
@@ -0,0 +1 @@
+<Step enable="True" id="118" name="Open Hosts" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/119-MoveResizeWindow.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/119-MoveResizeWindow.xml
new file mode 100644
index 0000000..98a7951
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/119-MoveResizeWindow.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="119" name="Move/Resize Window">
+  <LimitToWindowsOfCurrentFile state="True" />
+  <Window value="Current" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/120-ArrangeAllWindows.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/120-ArrangeAllWindows.xml
new file mode 100644
index 0000000..5ac8fd7
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/120-ArrangeAllWindows.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="120" name="Arrange All Windows">
+  <WindowArrangement value="TileHorizontally" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/121-CloseWindow-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/121-CloseWindow-1.xml
new file mode 100644
index 0000000..eaee1e8
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/121-CloseWindow-1.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="121" name="Close Window">
+  <LimitToWindowsOfCurrentFile state="True" />
+  <Window value="Current" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/121-CloseWindow-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/121-CloseWindow-2.xml
new file mode 100644
index 0000000..70d03d2
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/121-CloseWindow-2.xml
@@ -0,0 +1,7 @@
+<Step enable="True" id="121" name="Close Window">
+  <LimitToWindowsOfCurrentFile state="True" />
+  <Window value="ByName" />
+  <Name>
+    <Calculation><![CDATA["window name"]]></Calculation>
+  </Name>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/122-NewWindow-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/122-NewWindow-1.xml
new file mode 100644
index 0000000..74fd7dc
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/122-NewWindow-1.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="122" name="New Window">
+  <LayoutDestination value="CurrentLayout" />
+  <NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="3606018" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/122-NewWindow-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/122-NewWindow-2.xml
new file mode 100644
index 0000000..84c2118
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/122-NewWindow-2.xml
@@ -0,0 +1,8 @@
+<Step enable="True" id="122" name="New Window">
+  <LayoutDestination value="SelectedLayout" />
+  <Name>
+    <Calculation><![CDATA["window name"]]></Calculation>
+  </Name>
+  <NewWndStyles DimParentWindow="No" Toolbars="Yes" MenuBar="Yes" Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="1076299266" />
+  <Layout id="N" name="layout name" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/123-SelectWindow.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/123-SelectWindow.xml
new file mode 100644
index 0000000..e4d932d
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/123-SelectWindow.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="123" name="Select Window">
+  <LimitToWindowsOfCurrentFile state="True" />
+  <Window value="Current" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/124-SetWindowTitle.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/124-SetWindowTitle.xml
new file mode 100644
index 0000000..297a74a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/124-SetWindowTitle.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="124" name="Set Window Title">
+  <LimitToWindowsOfCurrentFile state="True" />
+  <Window value="Current" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/125-ElseIf.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/125-ElseIf.xml
new file mode 100644
index 0000000..1ee7b3b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/125-ElseIf.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="125" name="Else If">
+  <Restore state="False" />
+  <Calculation><![CDATA[condition]]></Calculation>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/126-ConstrainFoundSet-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/126-ConstrainFoundSet-1.xml
new file mode 100644
index 0000000..7802d23
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/126-ConstrainFoundSet-1.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="126" name="Constrain Found Set">
+  <Option state="False" />
+  <Restore state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/126-ConstrainFoundSet-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/126-ConstrainFoundSet-2.xml
new file mode 100644
index 0000000..f2f4205
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/126-ConstrainFoundSet-2.xml
@@ -0,0 +1,12 @@
+<Step enable="True" id="126" name="Constrain Found Set">
+  <Option state="False" />
+  <Restore state="True" />
+  <Query>
+    <RequestRow operation="Include">
+      <Criteria>
+        <Field table="TableOccurrence" id="N" name="field_name" />
+        <Text>=</Text>
+      </Criteria>
+    </RequestRow>
+  </Query>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/127-ExtendFoundSet.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/127-ExtendFoundSet.xml
new file mode 100644
index 0000000..719e85e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/127-ExtendFoundSet.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="127" name="Extend Found Set">
+  <Restore state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/128-PerformFindReplace.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/128-PerformFindReplace.xml
new file mode 100644
index 0000000..5cd16ff
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/128-PerformFindReplace.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="128" name="Perform Find/Replace">
+  <NoInteract state="False" />
+  <FindReplaceOperation MatchWholeWords="False" MatchCase="False" WithinOptions="All" AcrossOptions="All" direction="Forward" type="FindNext" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/129-OpenFindReplace.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/129-OpenFindReplace.xml
new file mode 100644
index 0000000..babddda
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/129-OpenFindReplace.xml
@@ -0,0 +1 @@
+<Step enable="True" id="129" name="Open Find/Replace" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/130-SetSelection.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/130-SetSelection.xml
new file mode 100644
index 0000000..c9b4445
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/130-SetSelection.xml
@@ -0,0 +1 @@
+<Step enable="True" id="130" name="Set Selection"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/131-InsertFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/131-InsertFile.xml
new file mode 100644
index 0000000..dc317d9
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/131-InsertFile.xml
@@ -0,0 +1,8 @@
+<Step enable="True" id="131" name="Insert File">
+  <UniversalPathList type="Embedded" />
+  <DialogOptions asFile="True" enable="False">
+    <Storage type="UserChoice" />
+    <Compress type="UserChoice" />
+    <FilterList />
+  </DialogOptions>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/132-ExportFieldContents.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/132-ExportFieldContents.xml
new file mode 100644
index 0000000..bad70cc
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/132-ExportFieldContents.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="132" name="Export Field Contents">
+  <CreateDirectories state="True" />
+  <AutoOpen state="False" />
+  <CreateEmail state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/133-OpenRecordRequest.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/133-OpenRecordRequest.xml
new file mode 100644
index 0000000..67d26f1
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/133-OpenRecordRequest.xml
@@ -0,0 +1 @@
+<Step enable="True" id="133" name="Open Record/Request"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/134-AddAccount.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/134-AddAccount.xml
new file mode 100644
index 0000000..1321bd5
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/134-AddAccount.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="134" name="Add Account">
+  <ChgPwdOnNextLogin value="False" />
+  <AddAccount>
+    <AccountType>FileMaker</AccountType>
+  </AddAccount>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/135-DeleteAccount.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/135-DeleteAccount.xml
new file mode 100644
index 0000000..8511eb5
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/135-DeleteAccount.xml
@@ -0,0 +1 @@
+<Step enable="True" id="135" name="Delete Account"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/136-ResetAccountPassword.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/136-ResetAccountPassword.xml
new file mode 100644
index 0000000..abac13e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/136-ResetAccountPassword.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="136" name="Reset Account Password">
+  <ChgPwdOnNextLogin value="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/137-EnableAccount.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/137-EnableAccount.xml
new file mode 100644
index 0000000..59dec97
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/137-EnableAccount.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="137" name="Enable Account">
+  <AccountOperation value="Activate" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/138-ReLogin-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/138-ReLogin-1.xml
new file mode 100644
index 0000000..bbc59fa
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/138-ReLogin-1.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="138" name="Re-Login">
+  <NoInteract state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/138-ReLogin-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/138-ReLogin-2.xml
new file mode 100644
index 0000000..693426f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/138-ReLogin-2.xml
@@ -0,0 +1,9 @@
+<Step enable="True" id="138" name="Re-Login">
+  <NoInteract state="True" />
+  <AccountName>
+    <Calculation><![CDATA["account name"]]></Calculation>
+  </AccountName>
+  <Password>
+    <Calculation><![CDATA["password expression"]]></Calculation>
+  </Password>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/139-ConvertFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/139-ConvertFile.xml
new file mode 100644
index 0000000..9f0ea40
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/139-ConvertFile.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="139" name="Convert File">
+  <NoInteract state="False" />
+  <Option state="False" />
+  <SkipIndexes state="False" />
+  <VerifySSLCertificates state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/140-OpenManageDataSources.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/140-OpenManageDataSources.xml
new file mode 100644
index 0000000..9174f0b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/140-OpenManageDataSources.xml
@@ -0,0 +1 @@
+<Step enable="True" id="140" name="Open Manage Data Sources" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/141-SetVariable.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/141-SetVariable.xml
new file mode 100644
index 0000000..840bf8e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/141-SetVariable.xml
@@ -0,0 +1,9 @@
+<Step enable="True" id="141" name="Set Variable">
+  <Value>
+    <Calculation><![CDATA[expression]]></Calculation>
+  </Value>
+  <Repetition>
+    <Calculation><![CDATA[1]]></Calculation>
+  </Repetition>
+  <Name>$variable_name</Name>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/142-InstallMenuSet.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/142-InstallMenuSet.xml
new file mode 100644
index 0000000..9424753
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/142-InstallMenuSet.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="142" name="Install Menu Set">
+  <UseAsFileDefault state="False" />
+  <CustomMenuSet id="1" name="[Standard FileMaker Menus]" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/143-SaveRecordsAsExcel.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/143-SaveRecordsAsExcel.xml
new file mode 100644
index 0000000..8adc6f0
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/143-SaveRecordsAsExcel.xml
@@ -0,0 +1,9 @@
+<Step enable="True" id="143" name="Save Records as Excel">
+  <NoInteract state="True" />
+  <CreateDirectories state="True" />
+  <Restore state="False" />
+  <AutoOpen state="False" />
+  <CreateEmail state="False" />
+  <SaveType value="BrowsedRecords" />
+  <UseFieldNames state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/144-SaveRecordsAsPDF-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/144-SaveRecordsAsPDF-1.xml
new file mode 100644
index 0000000..ff6bbbc
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/144-SaveRecordsAsPDF-1.xml
@@ -0,0 +1,28 @@
+<Step enable="True" id="144" name="Save Records as PDF">
+  <NoInteract state="True" />
+  <Option state="False" />
+  <CreateDirectories state="True" />
+  <Restore state="False" />
+  <AutoOpen state="False" />
+  <CreateEmail state="False" />
+  <PDFOptions source="RecordsBeingBrowsed">
+    <PDFSaveType>File</PDFSaveType>
+    <Document>
+      <Pages AllPages="True">
+        <NumberFrom>
+          <Calculation><![CDATA[1]]></Calculation>
+        </NumberFrom>
+        <PageRange>
+          <From>
+            <Calculation><![CDATA[1]]></Calculation>
+          </From>
+          <To>
+            <Calculation><![CDATA[1]]></Calculation>
+          </To>
+        </PageRange>
+      </Pages>
+    </Document>
+    <Security allowScreenReader="True" enableCopying="True" controlEditing="AnyExceptExtractingPages" controlPrinting="HighResolution" requireControlEditPassword="False" requireOpenPassword="False" />
+    <View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage" />
+  </PDFOptions>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/144-SaveRecordsAsPDF-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/144-SaveRecordsAsPDF-2.xml
new file mode 100644
index 0000000..7398291
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/144-SaveRecordsAsPDF-2.xml
@@ -0,0 +1,41 @@
+<Step enable="True" id="144" name="Save Records as PDF">
+  <NoInteract state="True" />
+  <Option state="True" />
+  <CreateDirectories state="True" />
+  <Restore state="True" />
+  <AutoOpen state="False" />
+  <CreateEmail state="False" />
+  <UniversalPathList>file:"filename.pdf"</UniversalPathList>
+  <Calculation><![CDATA[1]]></Calculation>
+  <PDFOptions source="RecordsBeingBrowsed">
+    <PDFSaveType>File</PDFSaveType>
+    <Document>
+      <Title>
+        <Calculation><![CDATA[title]]></Calculation>
+      </Title>
+      <Subject>
+        <Calculation><![CDATA[subject]]></Calculation>
+      </Subject>
+      <Author>
+        <Calculation><![CDATA[author]]></Calculation>
+      </Author>
+      <Keywords>
+        <Calculation><![CDATA[keywords]]></Calculation>
+      </Keywords>
+      <Pages AllPages="True">
+        <NumberFrom>
+          <Calculation><![CDATA[1]]></Calculation>
+        </NumberFrom>
+      </Pages>
+    </Document>
+    <Security allowScreenReader="True" enableCopying="True" controlEditing="InsertingDeletingRotatingPages" controlPrinting="LowResolution" requireControlEditPassword="True" requireOpenPassword="True">
+      <OpenPassword>
+        <Calculation><![CDATA[password]]></Calculation>
+      </OpenPassword>
+      <ControlPassword>
+        <Calculation><![CDATA[password]]></Calculation>
+      </ControlPassword>
+    </Security>
+    <View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage" />
+  </PDFOptions>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/145-GoToObject-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/145-GoToObject-1.xml
new file mode 100644
index 0000000..d30cb02
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/145-GoToObject-1.xml
@@ -0,0 +1 @@
+<Step enable="True" id="145" name="Go to Object" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/145-GoToObject-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/145-GoToObject-2.xml
new file mode 100644
index 0000000..85aa390
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/145-GoToObject-2.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="145" name="Go to Object">
+  <ObjectName>
+    <Calculation><![CDATA["object name"]]></Calculation>
+  </ObjectName>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/146-SetWebViewer-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/146-SetWebViewer-1.xml
new file mode 100644
index 0000000..5dfa4a0
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/146-SetWebViewer-1.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="146" name="Set Web Viewer">
+  <Action value="Reset" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/146-SetWebViewer-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/146-SetWebViewer-2.xml
new file mode 100644
index 0000000..64832e6
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/146-SetWebViewer-2.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="146" name="Set Web Viewer">
+  <Action value="Reload" />
+  <ObjectName>
+    <Calculation><![CDATA["myWebViewer"]]></Calculation>
+  </ObjectName>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/146-SetWebViewer-3.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/146-SetWebViewer-3.xml
new file mode 100644
index 0000000..4db6341
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/146-SetWebViewer-3.xml
@@ -0,0 +1,9 @@
+<Step enable="True" id="146" name="Set Web Viewer">
+  <Action value="GoToURL" />
+  <ObjectName>
+    <Calculation><![CDATA["myWebViewer"]]></Calculation>
+  </ObjectName>
+  <URL custom="False">
+    <Calculation><![CDATA["https://example.com/test"]]></Calculation>
+  </URL>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/147-SetFieldByName.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/147-SetFieldByName.xml
new file mode 100644
index 0000000..90f8213
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/147-SetFieldByName.xml
@@ -0,0 +1 @@
+<Step enable="True" id="147" name="Set Field By Name"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/148-InstallOnTimerScript-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/148-InstallOnTimerScript-1.xml
new file mode 100644
index 0000000..67f156f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/148-InstallOnTimerScript-1.xml
@@ -0,0 +1 @@
+<Step enable="True" id="148" name="Install OnTimer Script" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/148-InstallOnTimerScript-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/148-InstallOnTimerScript-2.xml
new file mode 100644
index 0000000..a2bac02
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/148-InstallOnTimerScript-2.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="148" name="Install OnTimer Script">
+  <Interval>
+    <Calculation><![CDATA[5]]></Calculation>
+  </Interval>
+  <Script id="N" name="script name" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/149-OpenEditSavedFinds.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/149-OpenEditSavedFinds.xml
new file mode 100644
index 0000000..5493c5e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/149-OpenEditSavedFinds.xml
@@ -0,0 +1 @@
+<Step enable="True" id="149" name="Open Edit Saved Finds" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/150-PerformQuickFind.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/150-PerformQuickFind.xml
new file mode 100644
index 0000000..f718d4f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/150-PerformQuickFind.xml
@@ -0,0 +1 @@
+<Step enable="True" id="150" name="Perform Quick Find"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/151-OpenManageLayouts.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/151-OpenManageLayouts.xml
new file mode 100644
index 0000000..6528bb8
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/151-OpenManageLayouts.xml
@@ -0,0 +1 @@
+<Step enable="True" id="151" name="Open Manage Layouts" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/152-SaveRecordsAsSnapshotLink.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/152-SaveRecordsAsSnapshotLink.xml
new file mode 100644
index 0000000..71ba4c1
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/152-SaveRecordsAsSnapshotLink.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="152" name="Save Records as Snapshot Link">
+  <CreateDirectories state="True" />
+  <CreateEmail state="False" />
+  <SaveType value="BrowsedRecords" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/154-SortRecordsByField.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/154-SortRecordsByField.xml
new file mode 100644
index 0000000..e86a2bd
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/154-SortRecordsByField.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="154" name="Sort Records by Field">
+  <SortRecordsByField value="SortAscending" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/155-FindMatchingRecords.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/155-FindMatchingRecords.xml
new file mode 100644
index 0000000..b679fa9
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/155-FindMatchingRecords.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="155" name="Find Matching Records">
+  <FindMatchingRecordsByField value="FindMatchingReplace" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/156-OpenManageContainers.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/156-OpenManageContainers.xml
new file mode 100644
index 0000000..7f12e18
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/156-OpenManageContainers.xml
@@ -0,0 +1 @@
+<Step enable="True" id="156" name="Open Manage Containers" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/157-InstallPlugInFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/157-InstallPlugInFile.xml
new file mode 100644
index 0000000..64a7286
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/157-InstallPlugInFile.xml
@@ -0,0 +1 @@
+<Step enable="True" id="157" name="Install Plug-In File"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/158-InsertPDF.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/158-InsertPDF.xml
new file mode 100644
index 0000000..055ffc0
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/158-InsertPDF.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="158" name="Insert PDF">
+  <UniversalPathList type="Embedded" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/159-InsertAudioVideo.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/159-InsertAudioVideo.xml
new file mode 100644
index 0000000..f7e9af0
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/159-InsertAudioVideo.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="159" name="Insert Audio/Video">
+  <UniversalPathList type="Embedded" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/160-InsertFromURL-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/160-InsertFromURL-1.xml
new file mode 100644
index 0000000..3082885
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/160-InsertFromURL-1.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="160" name="Insert from URL">
+  <NoInteract state="True" />
+  <DontEncodeURL state="False" />
+  <SelectAll state="True" />
+  <VerifySSLCertificates state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/160-InsertFromURL-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/160-InsertFromURL-2.xml
new file mode 100644
index 0000000..e71ed85
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/160-InsertFromURL-2.xml
@@ -0,0 +1,12 @@
+<Step enable="True" id="160" name="Insert from URL">
+  <NoInteract state="True" />
+  <DontEncodeURL state="False" />
+  <SelectAll state="True" />
+  <VerifySSLCertificates state="False" />
+  <CURLOptions>
+    <Calculation><![CDATA[$curl]]></Calculation>
+  </CURLOptions>
+  <Calculation><![CDATA[$endpoint]]></Calculation>
+  <Text />
+  <Field>$result</Field>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/161-InsertFromDevice.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/161-InsertFromDevice.xml
new file mode 100644
index 0000000..c61105b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/161-InsertFromDevice.xml
@@ -0,0 +1,8 @@
+<Step enable="True" id="161" name="Insert from Device">
+  <InsertFrom value="Camera" />
+  <DeviceOptions>
+    <Camera choice="Back" />
+    <Resolution choice="Full" />
+    <LightMode choice="Auto" />
+  </DeviceOptions>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/164-PerformScriptOnServer-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/164-PerformScriptOnServer-1.xml
new file mode 100644
index 0000000..2fa15a5
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/164-PerformScriptOnServer-1.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="164" name="Perform Script on Server">
+  <WaitForCompletion state="True" />
+  <Script id="N" name="script name" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/164-PerformScriptOnServer-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/164-PerformScriptOnServer-2.xml
new file mode 100644
index 0000000..54c0a73
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/164-PerformScriptOnServer-2.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="164" name="Perform Script on Server">
+  <WaitForCompletion state="True" />
+  <Calculation><![CDATA[parameter expression]]></Calculation>
+  <Script id="N" name="script name" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/165-OpenManageThemes.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/165-OpenManageThemes.xml
new file mode 100644
index 0000000..d380ef7
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/165-OpenManageThemes.xml
@@ -0,0 +1 @@
+<Step enable="True" id="165" name="Open Manage Themes" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/166-ShowHideMenubar.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/166-ShowHideMenubar.xml
new file mode 100644
index 0000000..1a00f5e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/166-ShowHideMenubar.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="166" name="Show/Hide Menubar">
+  <Lock state="False" />
+  <ShowHide value="Hide" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/167-RefreshObject-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/167-RefreshObject-1.xml
new file mode 100644
index 0000000..f355130
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/167-RefreshObject-1.xml
@@ -0,0 +1 @@
+<Step enable="True" id="167" name="Refresh Object" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/167-RefreshObject-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/167-RefreshObject-2.xml
new file mode 100644
index 0000000..1d510ae
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/167-RefreshObject-2.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="167" name="Refresh Object">
+  <ObjectName>
+    <Calculation><![CDATA["object name"]]></Calculation>
+  </ObjectName>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/168-SetLayoutObjectAnimation.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/168-SetLayoutObjectAnimation.xml
new file mode 100644
index 0000000..44e12d7
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/168-SetLayoutObjectAnimation.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="168" name="Set Layout Object Animation">
+  <Set state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/169-ClosePopover.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/169-ClosePopover.xml
new file mode 100644
index 0000000..2ae7329
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/169-ClosePopover.xml
@@ -0,0 +1 @@
+<Step enable="True" id="169" name="Close Popover"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/172-OpenUploadToHost.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/172-OpenUploadToHost.xml
new file mode 100644
index 0000000..cad8b04
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/172-OpenUploadToHost.xml
@@ -0,0 +1 @@
+<Step enable="True" id="172" name="Open Upload to Host" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/174-EnableTouchKeyboard.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/174-EnableTouchKeyboard.xml
new file mode 100644
index 0000000..3e97a6e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/174-EnableTouchKeyboard.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="174" name="Enable Touch Keyboard">
+  <ShowHide value="Show" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/175-PerformJavaScriptInWebViewer-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/175-PerformJavaScriptInWebViewer-1.xml
new file mode 100644
index 0000000..f551206
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/175-PerformJavaScriptInWebViewer-1.xml
@@ -0,0 +1 @@
+<Step enable="True" id="175" name="Perform JavaScript in Web Viewer" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/175-PerformJavaScriptInWebViewer-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/175-PerformJavaScriptInWebViewer-2.xml
new file mode 100644
index 0000000..e9b7c27
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/175-PerformJavaScriptInWebViewer-2.xml
@@ -0,0 +1,19 @@
+<Step enable="True" id="175" name="Perform JavaScript in Web Viewer">
+  <ObjectName>
+    <Calculation><![CDATA["myWebViewer"]]></Calculation>
+  </ObjectName>
+  <FunctionName>
+    <Calculation><![CDATA["updateData"]]></Calculation>
+  </FunctionName>
+  <Parameters Count="3">
+    <P>
+      <Calculation><![CDATA["first arg"]]></Calculation>
+    </P>
+    <P>
+      <Calculation><![CDATA[42]]></Calculation>
+    </P>
+    <P>
+      <Calculation><![CDATA[$variable_arg]]></Calculation>
+    </P>
+  </Parameters>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/177-AVPlayerPlay.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/177-AVPlayerPlay.xml
new file mode 100644
index 0000000..925017e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/177-AVPlayerPlay.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="177" name="AVPlayer Play">
+  <Source value="Object" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/178-AVPlayerSetPlaybackState.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/178-AVPlayerSetPlaybackState.xml
new file mode 100644
index 0000000..bdaa131
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/178-AVPlayerSetPlaybackState.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="178" name="AVPlayer Set Playback State">
+  <PlaybackState value="Stopped" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/179-AVPlayerSetOptions.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/179-AVPlayerSetOptions.xml
new file mode 100644
index 0000000..4cb517f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/179-AVPlayerSetOptions.xml
@@ -0,0 +1 @@
+<Step enable="True" id="179" name="AVPlayer Set Options"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/180-RefreshPortal.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/180-RefreshPortal.xml
new file mode 100644
index 0000000..a3f8c3a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/180-RefreshPortal.xml
@@ -0,0 +1 @@
+<Step enable="True" id="180" name="Refresh Portal"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/181-GetFolderPath.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/181-GetFolderPath.xml
new file mode 100644
index 0000000..c3c8fc0
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/181-GetFolderPath.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="181" name="Get Folder Path">
+  <AllowFolderCreation state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/182-TruncateTable.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/182-TruncateTable.xml
new file mode 100644
index 0000000..8de591e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/182-TruncateTable.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="182" name="Truncate Table">
+  <NoInteract state="False" />
+  <BaseTable id="-1" name="&lt;Current Table&gt;" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/183-OpenFavorites.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/183-OpenFavorites.xml
new file mode 100644
index 0000000..86cc1cb
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/183-OpenFavorites.xml
@@ -0,0 +1 @@
+<Step enable="True" id="183" name="Open Favorites" />
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/185-ConfigureRegionMonitorScript.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/185-ConfigureRegionMonitorScript.xml
new file mode 100644
index 0000000..90834e7
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/185-ConfigureRegionMonitorScript.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="185" name="Configure Region Monitor Script">
+  <MonitorType value="iBeacon" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/186-MBS.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/186-MBS.xml
new file mode 100644
index 0000000..885d965
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/186-MBS.xml
@@ -0,0 +1,49 @@
+<Step index="2" Source="MBSP" enable="True" id="186" name="MBS">
+  <PluginStep>
+    <Parameter ShowInLine="true" Label="Destination" Type="target" />
+    <Parameter ID="0" Label="Function" ShowInline="true" DataType="text" Type="calc" />
+    <Parameter ID="1" Label="P1" ShowInline="true" DataType="text" Type="calc" />
+    <Parameter ID="2" Label="P2" ShowInline="true" DataType="text" Type="calc" />
+    <Parameter ID="3" Label="P3" ShowInline="true" DataType="text" Type="calc" />
+    <Parameter ID="4" Label="P4" ShowInline="true" DataType="text" Type="calc" />
+    <Parameter ID="5" Label="P5" ShowInline="false" DataType="text" Type="calc" />
+    <Parameter ID="6" Label="P6" ShowInline="false" DataType="text" Type="calc" />
+    <Parameter ID="7" Label="P7" ShowInline="false" DataType="text" Type="calc" />
+    <Parameter ID="8" Label="P8" ShowInline="false" DataType="text" Type="calc" />
+    <Parameter ID="9" Label="P9" ShowInline="false" DataType="text" Type="calc" />
+  </PluginStep>
+  <SelectAll state="True" />
+  <Field />
+  <ParameterValues>
+    <Object index="0" type="Calc">
+      <Calculation><![CDATA[]]></Calculation>
+    </Object>
+    <Object index="1" type="Calc">
+      <Calculation><![CDATA[]]></Calculation>
+    </Object>
+    <Object index="2" type="Calc">
+      <Calculation><![CDATA[]]></Calculation>
+    </Object>
+    <Object index="3" type="Calc">
+      <Calculation><![CDATA[]]></Calculation>
+    </Object>
+    <Object index="4" type="Calc">
+      <Calculation><![CDATA[]]></Calculation>
+    </Object>
+    <Object index="5" type="Calc">
+      <Calculation><![CDATA[]]></Calculation>
+    </Object>
+    <Object index="6" type="Calc">
+      <Calculation><![CDATA[]]></Calculation>
+    </Object>
+    <Object index="7" type="Calc">
+      <Calculation><![CDATA[]]></Calculation>
+    </Object>
+    <Object index="8" type="Calc">
+      <Calculation><![CDATA[]]></Calculation>
+    </Object>
+    <Object index="9" type="Calc">
+      <Calculation><![CDATA[]]></Calculation>
+    </Object>
+  </ParameterValues>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/187-ConfigureLocalNotification.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/187-ConfigureLocalNotification.xml
new file mode 100644
index 0000000..f7fabd3
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/187-ConfigureLocalNotification.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="187" name="Configure Local Notification">
+  <Action value="Queue" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/188-GetFileExists.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/188-GetFileExists.xml
new file mode 100644
index 0000000..42e61d5
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/188-GetFileExists.xml
@@ -0,0 +1 @@
+<Step enable="True" id="188" name="Get File Exists"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/189-GetFileSize.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/189-GetFileSize.xml
new file mode 100644
index 0000000..3b33f53
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/189-GetFileSize.xml
@@ -0,0 +1 @@
+<Step enable="True" id="189" name="Get File Size"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/190-CreateDataFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/190-CreateDataFile.xml
new file mode 100644
index 0000000..e91841f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/190-CreateDataFile.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="190" name="Create Data File">
+  <CreateDirectories state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/191-OpenDataFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/191-OpenDataFile.xml
new file mode 100644
index 0000000..4ff1c07
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/191-OpenDataFile.xml
@@ -0,0 +1 @@
+<Step enable="True" id="191" name="Open Data File"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/192-WriteToDataFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/192-WriteToDataFile.xml
new file mode 100644
index 0000000..094a911
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/192-WriteToDataFile.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="192" name="Write to Data File">
+  <AppendLineFeed state="True" />
+  <DataSourceType value="1" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/193-ReadFromDataFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/193-ReadFromDataFile.xml
new file mode 100644
index 0000000..5db74d7
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/193-ReadFromDataFile.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="193" name="Read from Data File">
+  <DataSourceType value="3" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/194-GetDataFilePosition.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/194-GetDataFilePosition.xml
new file mode 100644
index 0000000..82ac600
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/194-GetDataFilePosition.xml
@@ -0,0 +1 @@
+<Step enable="True" id="194" name="Get Data File Position"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/195-SetDataFilePosition.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/195-SetDataFilePosition.xml
new file mode 100644
index 0000000..b5d07b4
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/195-SetDataFilePosition.xml
@@ -0,0 +1 @@
+<Step enable="True" id="195" name="Set Data File Position"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/196-CloseDataFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/196-CloseDataFile.xml
new file mode 100644
index 0000000..8f92a13
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/196-CloseDataFile.xml
@@ -0,0 +1 @@
+<Step enable="True" id="196" name="Close Data File"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/197-DeleteFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/197-DeleteFile.xml
new file mode 100644
index 0000000..10d5c2f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/197-DeleteFile.xml
@@ -0,0 +1 @@
+<Step enable="True" id="197" name="Delete File"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/199-RenameFile.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/199-RenameFile.xml
new file mode 100644
index 0000000..766c57f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/199-RenameFile.xml
@@ -0,0 +1 @@
+<Step enable="True" id="199" name="Rename File"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/200-SetErrorLogging.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/200-SetErrorLogging.xml
new file mode 100644
index 0000000..94b0333
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/200-SetErrorLogging.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="200" name="Set Error Logging">
+  <Option state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/201-ConfigureNFCReading.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/201-ConfigureNFCReading.xml
new file mode 100644
index 0000000..1c2d6dc
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/201-ConfigureNFCReading.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="201" name="Configure NFC Reading">
+  <Action value="Read" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/202-ConfigureMachineLearningModel.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/202-ConfigureMachineLearningModel.xml
new file mode 100644
index 0000000..affb008
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/202-ConfigureMachineLearningModel.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="202" name="Configure Machine Learning Model">
+  <ConfigureCoreML>Uninstall</ConfigureCoreML>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/203-ExecuteFileMakerDataAPI.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/203-ExecuteFileMakerDataAPI.xml
new file mode 100644
index 0000000..5a30e3e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/203-ExecuteFileMakerDataAPI.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="203" name="Execute FileMaker Data API">
+  <SelectAll state="True" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/205-OpenTransaction.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/205-OpenTransaction.xml
new file mode 100644
index 0000000..18b81a6
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/205-OpenTransaction.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="205" name="Open Transaction">
+  <Option state="False" />
+  <ESSForceCommit state="False" />
+  <SkipAutoEntry state="False" />
+  <Restore state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/206-CommitTransaction.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/206-CommitTransaction.xml
new file mode 100644
index 0000000..28a813b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/206-CommitTransaction.xml
@@ -0,0 +1 @@
+<Step enable="True" id="206" name="Commit Transaction"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/207-RevertTransaction.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/207-RevertTransaction.xml
new file mode 100644
index 0000000..5830ded
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/207-RevertTransaction.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="207" name="Revert Transaction">
+  <Option state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/208-SetSessionIdentifier.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/208-SetSessionIdentifier.xml
new file mode 100644
index 0000000..7b355b1
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/208-SetSessionIdentifier.xml
@@ -0,0 +1 @@
+<Step enable="True" id="208" name="Set Session Identifier"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/209-SetDictionary.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/209-SetDictionary.xml
new file mode 100644
index 0000000..211a152
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/209-SetDictionary.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="209" name="Set Dictionary">
+  <MainDictionary value="US English" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/210-PerformScriptOnServerWithCallback.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/210-PerformScriptOnServerWithCallback.xml
new file mode 100644
index 0000000..a91483f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/210-PerformScriptOnServerWithCallback.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="210" name="Perform Script on Server with Callback">
+  <CallbackScriptState value="Continue" />
+  <CallbackScript />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/211-TriggerClarisConnectFlow.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/211-TriggerClarisConnectFlow.xml
new file mode 100644
index 0000000..381f05b
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/211-TriggerClarisConnectFlow.xml
@@ -0,0 +1,11 @@
+<Step enable="True" id="211" name="Trigger Claris Connect Flow">
+  <NoInteract state="True" />
+  <DontEncodeURL state="False" />
+  <SelectAll state="True" />
+  <VerifySSLCertificates state="False" />
+  <Flow>flow identifier</Flow>
+  <CURLOptions>
+    <Calculation><![CDATA["--request POST --header \"Content-Type: application/json\" --data "]]></Calculation>
+  </CURLOptions>
+  <Text>payload</Text>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/212-ConfigureAIAccount-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/212-ConfigureAIAccount-1.xml
new file mode 100644
index 0000000..9765bb2
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/212-ConfigureAIAccount-1.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="212" name="Configure AI Account">
+  <LLMType value="ChatGPT" />
+  <SetLLMAccount />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/212-ConfigureAIAccount-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/212-ConfigureAIAccount-2.xml
new file mode 100644
index 0000000..a639c89
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/212-ConfigureAIAccount-2.xml
@@ -0,0 +1,11 @@
+<Step enable="True" id="212" name="Configure AI Account">
+  <LLMType value="ChatGPT" />
+  <SetLLMAccount>
+    <AccountName>
+      <Calculation><![CDATA["account name"]]></Calculation>
+    </AccountName>
+    <AccessAPIKey>
+      <Calculation><![CDATA["api key"]]></Calculation>
+    </AccessAPIKey>
+  </SetLLMAccount>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/212-ConfigureAIAccount-3.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/212-ConfigureAIAccount-3.xml
new file mode 100644
index 0000000..cb142de
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/212-ConfigureAIAccount-3.xml
@@ -0,0 +1,15 @@
+<Step enable="True" id="212" name="Configure AI Account">
+  <VerifySSLCertificates state="False" />
+  <LLMType value="Other" />
+  <SetLLMAccount>
+    <AccountName>
+      <Calculation><![CDATA["account name"]]></Calculation>
+    </AccountName>
+    <Endpoint>
+      <Calculation><![CDATA["https://server.example.com/llm/v1/"]]></Calculation>
+    </Endpoint>
+    <AccessAPIKey>
+      <Calculation><![CDATA["api key"]]></Calculation>
+    </AccessAPIKey>
+  </SetLLMAccount>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/213-FineTuneModel.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/213-FineTuneModel.xml
new file mode 100644
index 0000000..763ce7f
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/213-FineTuneModel.xml
@@ -0,0 +1,8 @@
+<Step enable="True" id="213" name="Fine-Tune Model">
+  <Option state="False" />
+  <UniversalPathList type="Embedded" />
+  <Table id="0" name="" />
+  <FineTuneLLM>
+    <DataSource>DataTable</DataSource>
+  </FineTuneLLM>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/214-PerformSQLQueryByNaturalLanguage.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/214-PerformSQLQueryByNaturalLanguage.xml
new file mode 100644
index 0000000..1c27138
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/214-PerformSQLQueryByNaturalLanguage.xml
@@ -0,0 +1,11 @@
+<Step enable="True" id="214" name="Perform SQL Query by Natural Language">
+  <Option state="False" />
+  <Stream state="False" />
+  <UniversalPathList type="Embedded" />
+  <PerformSQLQuerybyNaturalLanguage>
+    <OptionsSelectionType>By List</OptionsSelectionType>
+    <Action>Query</Action>
+    <TablesSelectionType>By List</TablesSelectionType>
+    <TableAliases />
+  </PerformSQLQuerybyNaturalLanguage>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/215-InsertEmbedding.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/215-InsertEmbedding.xml
new file mode 100644
index 0000000..6a645a2
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/215-InsertEmbedding.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="215" name="Insert Embedding">
+  <LLMEmbedding />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/216-InsertEmbeddingInFoundSet.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/216-InsertEmbeddingInFoundSet.xml
new file mode 100644
index 0000000..6720553
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/216-InsertEmbeddingInFoundSet.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="216" name="Insert Embedding in Found Set">
+  <LLMBulkEmbedding />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/217-SetAICallLogging.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/217-SetAICallLogging.xml
new file mode 100644
index 0000000..1862609
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/217-SetAICallLogging.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="217" name="Set AI Call Logging">
+  <Set state="False" />
+  <LLMDebugLog />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/218-PerformSemanticFind.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/218-PerformSemanticFind.xml
new file mode 100644
index 0000000..e8ebd1e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/218-PerformSemanticFind.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="218" name="Perform Semantic Find">
+  <LLMSemanticFind>
+    <Query type="1" />
+    <Records type="1" />
+  </LLMSemanticFind>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/219-PerformRAGAction.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/219-PerformRAGAction.xml
new file mode 100644
index 0000000..93bde05
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/219-PerformRAGAction.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="219" name="Perform RAG Action">
+  <RAGSpace>
+    <RAGSpaceAction>Add</RAGSpaceAction>
+    <DataSource>FromText</DataSource>
+  </RAGSpace>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/220-GenerateResponseFromModel.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/220-GenerateResponseFromModel.xml
new file mode 100644
index 0000000..198503e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/220-GenerateResponseFromModel.xml
@@ -0,0 +1,10 @@
+<Step enable="True" id="220" name="Generate Response from Model">
+  <Option state="False" />
+  <SelectAll state="False" />
+  <Stream state="False" />
+  <Set state="True" />
+  <LinkAvail state="False" />
+  <Restore state="False" />
+  <UniversalPathList type="Embedded" />
+  <LLMRequestWithTools />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/221-PerformFindByNaturalLanguage.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/221-PerformFindByNaturalLanguage.xml
new file mode 100644
index 0000000..dbdf5a0
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/221-PerformFindByNaturalLanguage.xml
@@ -0,0 +1,7 @@
+<Step enable="True" id="221" name="Perform Find by Natural Language">
+  <Option state="False" />
+  <SelectAll state="True" />
+  <LLMCreateFind>
+    <Action>Query</Action>
+  </LLMCreateFind>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/222-ConfigureRegressionModel.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/222-ConfigureRegressionModel.xml
new file mode 100644
index 0000000..766db21
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/222-ConfigureRegressionModel.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="222" name="Configure Regression Model">
+  <LLMTrain>
+    <LLMTrainAction>LLMTrainTrainModel</LLMTrainAction>
+    <LLMAlgorithm>LLMTrainAlgForest</LLMAlgorithm>
+  </LLMTrain>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/223-SetRevertTransactionOnError.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/223-SetRevertTransactionOnError.xml
new file mode 100644
index 0000000..87e772a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/223-SetRevertTransactionOnError.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="223" name="Set Revert Transaction on Error">
+  <Set state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/225-SaveRecordsAsJSONL.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/225-SaveRecordsAsJSONL.xml
new file mode 100644
index 0000000..bc1168d
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/225-SaveRecordsAsJSONL.xml
@@ -0,0 +1,8 @@
+<Step enable="True" id="225" name="Save Records as JSONL">
+  <Option state="False" />
+  <CreateDirectories state="False" />
+  <FineTuneFormat state="False" />
+  <AutoOpen state="False" />
+  <CreateEmail state="False" />
+  <SaveAsJSONL />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/226-ConfigurePromptTemplate.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/226-ConfigurePromptTemplate.xml
new file mode 100644
index 0000000..8300857
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/226-ConfigurePromptTemplate.xml
@@ -0,0 +1,7 @@
+<Step enable="True" id="226" name="Configure Prompt Template">
+  <Option state="False" />
+  <ConfigurePromptTemplate>
+    <ModelProvider>ChatGPT</ModelProvider>
+    <RequestType>SQLQuery</RequestType>
+  </ConfigurePromptTemplate>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/227-ConfigureRAGAccount.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/227-ConfigureRAGAccount.xml
new file mode 100644
index 0000000..7b93d79
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/227-ConfigureRAGAccount.xml
@@ -0,0 +1,4 @@
+<Step enable="True" id="227" name="Configure RAG Account ">
+  <VerifySSLCertificates state="False" />
+  <ConfigureRAGAccount />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/228-GoToListOfRecords.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/228-GoToListOfRecords.xml
new file mode 100644
index 0000000..093b3e1
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/228-GoToListOfRecords.xml
@@ -0,0 +1,5 @@
+<Step enable="True" id="228" name="Go to List of Records">
+  <ShowInNewWindow state="False" />
+  <LayoutDestination value="CurrentLayout" />
+  <NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="3606018" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/237-FlushWebViewerCookies.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/237-FlushWebViewerCookies.xml
new file mode 100644
index 0000000..0528c79
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/237-FlushWebViewerCookies.xml
@@ -0,0 +1 @@
+<Step enable="True" id="237" name="Flush Web Viewer Cookies"/>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/238-ConfigurePersistentData-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/238-ConfigurePersistentData-1.xml
new file mode 100644
index 0000000..e5c49d1
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/238-ConfigurePersistentData-1.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="238" name="Configure Persistent Data">
+  <Option state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/238-ConfigurePersistentData-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/238-ConfigurePersistentData-2.xml
new file mode 100644
index 0000000..442c734
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/238-ConfigurePersistentData-2.xml
@@ -0,0 +1,10 @@
+<Step enable="True" id="238" name="Configure Persistent Data">
+  <Option state="False" />
+  <Value>
+    <Calculation><![CDATA[value expression]]></Calculation>
+  </Value>
+  <InstanceId>
+    <Calculation><![CDATA["instance id"]]></Calculation>
+  </InstanceId>
+  <Name>"entry name"</Name>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/238-ConfigurePersistentData-3.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/238-ConfigurePersistentData-3.xml
new file mode 100644
index 0000000..3617e4a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/238-ConfigurePersistentData-3.xml
@@ -0,0 +1,7 @@
+<Step enable="True" id="238" name="Configure Persistent Data">
+  <Option state="True" />
+  <InstanceId>
+    <Calculation><![CDATA["instance id"]]></Calculation>
+  </InstanceId>
+  <Name>"entry name"</Name>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/240-InsertImageCaptionsInFoundSet.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/240-InsertImageCaptionsInFoundSet.xml
new file mode 100644
index 0000000..bea1679
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/240-InsertImageCaptionsInFoundSet.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="240" name="Insert Image Captions in Found Set">
+  <LLMBulkEmbedding />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/241-InsertImageCaption.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/241-InsertImageCaption.xml
new file mode 100644
index 0000000..408b625
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/241-InsertImageCaption.xml
@@ -0,0 +1,3 @@
+<Step enable="True" id="241" name="Insert Image Caption">
+  <LLMEmbedding />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/242-PrintPDF-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/242-PrintPDF-1.xml
new file mode 100644
index 0000000..7101b9e
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/242-PrintPDF-1.xml
@@ -0,0 +1,7 @@
+<Step enable="True" id="242" name="Print PDF">
+  <NoInteract state="True" />
+  <Option state="False" />
+  <UsePrintOptionsFromEnabled state="False" />
+  <SavePrintOptionsToEnabled state="False" />
+  <Restore state="False" />
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/242-PrintPDF-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/242-PrintPDF-2.xml
new file mode 100644
index 0000000..7745985
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/242-PrintPDF-2.xml
@@ -0,0 +1,22 @@
+<Step enable="True" id="242" name="Print PDF">
+  <NoInteract state="True" />
+  <Option state="True" />
+  <UsePrintOptionsFromEnabled state="False" />
+  <SavePrintOptionsToEnabled state="True" />
+  <Restore state="True" />
+  <Text />
+  <Field table="TableOccurrence" id="N" name="field_name" />
+  <PrintSettings PageNumberingOffset="0" PrintToFile="False" ToPage="1" FromPage="1" AllPages="False" collated="True" NumCopies="1" PrintType="BrowsedRecords">
+    <PlatformData PlatformType="PrNm"><![CDATA[...hex...]]></PlatformData>
+    <PlatformData PlatformType="M_PM"><![CDATA[...hex...]]></PlatformData>
+    <PlatformData PlatformType="M_PD"><![CDATA[...hex...]]></PlatformData>
+    <PlatformData PlatformType="MMod"><![CDATA[...hex...]]></PlatformData>
+    <SavePrintOptionsTo>
+      <Field>$variable</Field>
+    </SavePrintOptionsTo>
+    <Password>
+      <Calculation><![CDATA[password expression]]></Calculation>
+    </Password>
+    <SaveType>File</SaveType>
+  </PrintSettings>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/243-CreatePDF-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/243-CreatePDF-1.xml
new file mode 100644
index 0000000..0aab370
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/243-CreatePDF-1.xml
@@ -0,0 +1,22 @@
+<Step enable="True" id="243" name="Create PDF">
+  <Restore state="False" />
+  <CreatePDFFile>
+    <Document>
+      <Pages AllPages="True">
+        <NumberFrom>
+          <Calculation><![CDATA[1]]></Calculation>
+        </NumberFrom>
+        <PageRange>
+          <From>
+            <Calculation><![CDATA[1]]></Calculation>
+          </From>
+          <To>
+            <Calculation><![CDATA[1]]></Calculation>
+          </To>
+        </PageRange>
+      </Pages>
+    </Document>
+    <Security allowScreenReader="True" enableCopying="True" controlEditing="AnyExceptExtractingPages" controlPrinting="HighResolution" requireControlEditPassword="False" requireOpenPassword="False" />
+    <View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage" />
+  </CreatePDFFile>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/243-CreatePDF-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/243-CreatePDF-2.xml
new file mode 100644
index 0000000..fd82c2a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/243-CreatePDF-2.xml
@@ -0,0 +1,34 @@
+<Step enable="True" id="243" name="Create PDF">
+  <Restore state="True" />
+  <Calculation><![CDATA[1]]></Calculation>
+  <CreatePDFFile>
+    <Document>
+      <Title>
+        <Calculation><![CDATA[title expression]]></Calculation>
+      </Title>
+      <Subject>
+        <Calculation><![CDATA[subject expression]]></Calculation>
+      </Subject>
+      <Author>
+        <Calculation><![CDATA[author expression]]></Calculation>
+      </Author>
+      <Keywords>
+        <Calculation><![CDATA[keywords expression]]></Calculation>
+      </Keywords>
+      <Pages AllPages="True">
+        <NumberFrom>
+          <Calculation><![CDATA[1]]></Calculation>
+        </NumberFrom>
+      </Pages>
+    </Document>
+    <Security allowScreenReader="True" enableCopying="True" controlEditing="InsertingDeletingRotatingPages" controlPrinting="LowResolution" requireControlEditPassword="True" requireOpenPassword="True">
+      <OpenPassword>
+        <Calculation><![CDATA[password expression]]></Calculation>
+      </OpenPassword>
+      <ControlPassword>
+        <Calculation><![CDATA[password expression]]></Calculation>
+      </ControlPassword>
+    </Security>
+    <View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage" />
+  </CreatePDFFile>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/244-AppendPDF-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/244-AppendPDF-1.xml
new file mode 100644
index 0000000..a1aaa1c
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/244-AppendPDF-1.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="244" name="Append PDF">
+  <Option state="False" />
+  <AppendPDFFile>
+    <PDFSaveType>File</PDFSaveType>
+  </AppendPDFFile>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/244-AppendPDF-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/244-AppendPDF-2.xml
new file mode 100644
index 0000000..6ea4a01
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/244-AppendPDF-2.xml
@@ -0,0 +1,10 @@
+<Step enable="True" id="244" name="Append PDF">
+  <Option state="True" />
+  <UniversalPathList>image:../path/to/file.pdf</UniversalPathList>
+  <AppendPDFFile>
+    <PDFSaveType>File</PDFSaveType>
+    <OpenPassword>
+      <Calculation><![CDATA[password expression]]></Calculation>
+    </OpenPassword>
+  </AppendPDFFile>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/245-ClosePDF-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/245-ClosePDF-1.xml
new file mode 100644
index 0000000..fa9afd1
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/245-ClosePDF-1.xml
@@ -0,0 +1,8 @@
+<Step enable="True" id="245" name="Close PDF">
+  <CreateDirectories state="False" />
+  <AutoOpen state="False" />
+  <CreateEmail state="False" />
+  <ClosePDFFile>
+    <PDFSaveType>File</PDFSaveType>
+  </ClosePDFFile>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/245-ClosePDF-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/245-ClosePDF-2.xml
new file mode 100644
index 0000000..64da6aa
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/245-ClosePDF-2.xml
@@ -0,0 +1,9 @@
+<Step enable="True" id="245" name="Close PDF">
+  <CreateDirectories state="False" />
+  <AutoOpen state="True" />
+  <CreateEmail state="True" />
+  <UniversalPathList>file:"filename.pdf"</UniversalPathList>
+  <ClosePDFFile>
+    <PDFSaveType>File</PDFSaveType>
+  </ClosePDFFile>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/246-OpenPDF-1.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/246-OpenPDF-1.xml
new file mode 100644
index 0000000..5857209
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/246-OpenPDF-1.xml
@@ -0,0 +1,6 @@
+<Step enable="True" id="246" name="Open PDF">
+  <Option state="False" />
+  <OpenPDFFile>
+    <PDFSaveType>File</PDFSaveType>
+  </OpenPDFFile>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/246-OpenPDF-2.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/246-OpenPDF-2.xml
new file mode 100644
index 0000000..5e1d452
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/246-OpenPDF-2.xml
@@ -0,0 +1,10 @@
+<Step enable="True" id="246" name="Open PDF">
+  <Option state="True" />
+  <UniversalPathList>$variable_or_path</UniversalPathList>
+  <OpenPDFFile>
+    <PDFSaveType>File</PDFSaveType>
+    <OpenPassword>
+      <Calculation><![CDATA[password expression]]></Calculation>
+    </OpenPassword>
+  </OpenPDFFile>
+</Step>
diff --git a/tests/SharpFM.Tests/CanonicalSkill/fixtures/247-CancelPDF.xml b/tests/SharpFM.Tests/CanonicalSkill/fixtures/247-CancelPDF.xml
new file mode 100644
index 0000000..3580d8a
--- /dev/null
+++ b/tests/SharpFM.Tests/CanonicalSkill/fixtures/247-CancelPDF.xml
@@ -0,0 +1 @@
+<Step enable="True" id="247" name="Cancel PDF" />
diff --git a/tests/SharpFM.Tests/Scripting/CompletionProviderTests.cs b/tests/SharpFM.Tests/Scripting/CompletionProviderTests.cs
index eb1c282..8bba580 100644
--- a/tests/SharpFM.Tests/Scripting/CompletionProviderTests.cs
+++ b/tests/SharpFM.Tests/Scripting/CompletionProviderTests.cs
@@ -98,10 +98,10 @@ public void StepNameCompletion_ReturnsPocoStepsFromRegistry()
     }
 
     [Fact]
-    public void ParamValueCompletion_UsesValidValuesFromParamMetadata()
+    public void ParamValueCompletion_UsesDisplayValuesFromShape()
     {
-        // Confirms the completion provider reads ValidValues off
-        // ParamMetadata rather than the legacy StepParam shape.
+        // Confirms the completion provider reads display values off the
+        // step's shape slots.
         var (_, items) = FmScriptCompletionProvider.GetCompletions(
             "Set Error Capture [ ", 20);
         Assert.Contains(items, i => i.Text == "On");
diff --git a/tests/SharpFM.Tests/Scripting/ScriptValidatorTests.cs b/tests/SharpFM.Tests/Scripting/ScriptValidatorTests.cs
index ceedc02..b19a98d 100644
--- a/tests/SharpFM.Tests/Scripting/ScriptValidatorTests.cs
+++ b/tests/SharpFM.Tests/Scripting/ScriptValidatorTests.cs
@@ -75,26 +75,23 @@ public void CommentsOnly_NoDiagnostics()
     }
 
     [Fact]
-    public void GetValidValues_BooleanParam_ReturnsOnOff()
+    public void DisplayValues_BooleanSlot_ReturnsOnOff()
     {
-        var param = new SharpFM.Model.Scripting.Registry.ParamMetadata
-        {
-            Name = "x", XmlElement = "X", Type = "boolean",
-        };
-        var valid = SharpFM.Model.Scripting.Registry.StepRegistry.GetValidValues(param);
+        var slot = new SharpFM.Model.Scripting.Shapes.BoolStateChild("X");
+        var valid = SharpFM.Model.Scripting.Shapes.ShapeHrView.DisplayValuesOf(slot);
         Assert.Contains("On", valid);
         Assert.Contains("Off", valid);
     }
 
     [Fact]
-    public void GetValidValues_ExplicitValidValues_ReturnsThose()
+    public void DisplayValues_ExplicitDisplayValues_WinOverWire()
     {
-        var param = new SharpFM.Model.Scripting.Registry.ParamMetadata
+        var slot = new SharpFM.Model.Scripting.Shapes.EnumValueChild("X")
         {
-            Name = "x", XmlElement = "X", Type = "enum",
-            ValidValues = ["Alpha", "Beta"],
+            ValidValues = ["WireAlpha", "WireBeta"],
+            DisplayValues = ["Alpha", "Beta"],
         };
-        var valid = SharpFM.Model.Scripting.Registry.StepRegistry.GetValidValues(param);
+        var valid = SharpFM.Model.Scripting.Shapes.ShapeHrView.DisplayValuesOf(slot);
         Assert.Equal(new[] { "Alpha", "Beta" }, valid);
     }
 
diff --git a/tests/SharpFM.Tests/Scripting/Serialization/StepDisplayRendererTests.cs b/tests/SharpFM.Tests/Scripting/Serialization/StepDisplayRendererTests.cs
new file mode 100644
index 0000000..e0b82c7
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/Serialization/StepDisplayRendererTests.cs
@@ -0,0 +1,171 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Values;
+using Xunit;
+
+namespace SharpFM.Tests.Scripting.Serialization;
+
+public class StepDisplayRendererTests
+{
+    private sealed class VarStep : ScriptStep
+    {
+        public string Name { get; set; } = "";
+        public Calculation Value { get; set; } = new("");
+        public Calculation Repetition { get; set; } = new("1");
+        public VarStep() : base(true) { }
+        public override XElement ToXml() => throw new System.NotImplementedException();
+        public override string ToDisplayLine() => "";
+    }
+
+    // Name native; Value + Repetition augmented (labeled, after the natives);
+    // Repetition carries default "1" so it drops when unset.
+    private static StepMetadata VarMeta() => new()
+    {
+        Name = "Set Variable",
+        Id = 141,
+        Category = "control",
+        Shape =
+        [
+            new NamedCalcChild("Value") { PocoProperty = "Value", HrLabel = "Value", Display = DisplayMode.Augmented },
+            new NamedCalcChild("Repetition") { PocoProperty = "Repetition", HrLabel = "rep", Display = DisplayMode.Augmented, Optional = true, DefaultValue = "1" },
+            new NamedTextChild("Name") { PocoProperty = "Name", Display = DisplayMode.Native },
+        ],
+    };
+
+    [Fact]
+    public void SingleBracket_DefaultRepetitionSuppressed()
+    {
+        var step = new VarStep { Name = "$count", Value = new Calculation("0"), Repetition = new Calculation("1") };
+        Assert.Equal("Set Variable [ $count ; Value: 0 ]", StepDisplayRenderer.Render(step, VarMeta()));
+    }
+
+    [Fact]
+    public void SingleBracket_NonDefaultRepetitionShown()
+    {
+        var step = new VarStep { Name = "$arr", Value = new Calculation("0"), Repetition = new Calculation("2") };
+        Assert.Equal("Set Variable [ $arr ; Value: 0 ; rep: 2 ]", StepDisplayRenderer.Render(step, VarMeta()));
+    }
+
+    [Fact]
+    public void NativeOnly_BareToken()
+    {
+        var meta = new StepMetadata
+        {
+            Name = "If",
+            Id = 68,
+            Category = "control",
+            Shape = [new BareCalcChild { PocoProperty = "Value", Display = DisplayMode.Native }],
+        };
+        var step = new VarStep { Value = new Calculation("$x > 1") };
+        Assert.Equal("If [ $x > 1 ]", StepDisplayRenderer.Render(step, meta));
+    }
+
+    [Fact]
+    public void EnumSlot_TranslatesWireValueToDisplayForm()
+    {
+        var meta = new StepMetadata
+        {
+            Name = "Sort Records by Field",
+            Id = 154,
+            Category = "found-sets",
+            Shape =
+            [
+                new EnumValueChild("SortOrder")
+                {
+                    PocoProperty = "Name",
+                    ValidValues = ["SortAscending", "SortDescending"],
+                    DisplayValues = ["Ascending", "Descending"],
+                },
+            ],
+        };
+        var step = new VarStep { Name = "SortAscending" };
+        Assert.Equal("Sort Records by Field [ Ascending ]", StepDisplayRenderer.Render(step, meta));
+    }
+
+    [Fact]
+    public void EmptyValues_DropTheirTokens()
+    {
+        var step = new VarStep { Name = "", Value = new Calculation(""), Repetition = new Calculation("1") };
+        Assert.Equal("Set Variable", StepDisplayRenderer.Render(step, VarMeta()));
+    }
+
+    [Fact]
+    public void DisplayParser_InvertsTheRenderer()
+    {
+        var step = new VarStep { Name = "$arr", Value = new Calculation("0"), Repetition = new Calculation("2") };
+        var line = StepDisplayRenderer.Render(step, VarMeta());
+        var parsed = ScriptLineParser.ParseLine(line);
+        var rebuilt = StepDisplayParser.Parse<VarStep>(true, parsed.Params, VarMeta());
+
+        Assert.Equal("$arr", rebuilt.Name);
+        Assert.Equal("0", rebuilt.Value.Text);
+        Assert.Equal("2", rebuilt.Repetition.Text);
+    }
+
+    [Fact]
+    public void DisplayParser_InvertedBoolean_MapsBackToWire()
+    {
+        var meta = new StepMetadata
+        {
+            Name = "Delete All Records",
+            Id = 10,
+            Category = "records",
+            Shape =
+            [
+                new BoolStateChild("NoInteract") { PocoProperty = "Flag", HrLabel = "With dialog", DisplayInverted = true },
+            ],
+        };
+        var rebuilt = StepDisplayParser.Parse<FlagStep>(true, ["With dialog: On"], meta);
+        Assert.False(rebuilt.Flag); // display On = wire NoInteract False
+
+        var shown = StepDisplayRenderer.Render(rebuilt, meta);
+        Assert.Equal("Delete All Records [ With dialog: On ]", shown);
+    }
+
+    [Fact]
+    public void DisplayParser_EnumDisplayForm_MapsToWireValue()
+    {
+        var meta = new StepMetadata
+        {
+            Name = "Sort Records by Field",
+            Id = 154,
+            Category = "found-sets",
+            Shape =
+            [
+                new EnumValueChild("SortOrder")
+                {
+                    PocoProperty = "Name",
+                    ValidValues = ["SortAscending", "SortDescending"],
+                    DisplayValues = ["Ascending", "Descending"],
+                },
+            ],
+        };
+        var rebuilt = StepDisplayParser.Parse<VarStep>(true, ["Descending"], meta);
+        Assert.Equal("SortDescending", rebuilt.Name);
+    }
+
+    [Fact]
+    public void DisplayParser_BareFlagToken_SetsPresence()
+    {
+        var meta = new StepMetadata
+        {
+            Name = "Insert Text",
+            Id = 61,
+            Category = "fields",
+            Shape = [new FlagChild("SelectAll") { PocoProperty = "Flag", HrLabel = "Select" }],
+        };
+        var rebuilt = StepDisplayParser.Parse<FlagStep>(true, ["Select"], meta);
+        Assert.True(rebuilt.Flag);
+    }
+
+    private sealed class FlagStep : ScriptStep
+    {
+        public bool Flag { get; set; }
+        public FlagStep() : base(true) { }
+        public override XElement ToXml() => throw new System.NotImplementedException();
+        public override string ToDisplayLine() => "";
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/Serialization/StepXmlParserTests.cs b/tests/SharpFM.Tests/Scripting/Serialization/StepXmlParserTests.cs
new file mode 100644
index 0000000..0455441
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/Serialization/StepXmlParserTests.cs
@@ -0,0 +1,384 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Values;
+using SharpFM.Tests.CanonicalSkill;
+using Xunit;
+
+namespace SharpFM.Tests.Scripting.Serialization;
+
+public class StepXmlParserTests
+{
+    // Mirrors Set Variable's shape on a step with a parameterless ctor so the
+    // shape-driven parser can construct it by reflection.
+    private sealed class VarLikeStep : ScriptStep
+    {
+        public string Name { get; set; } = "";
+        public Calculation Value { get; set; } = new("");
+        public Calculation Repetition { get; set; } = new("1");
+        public VarLikeStep() : base(true) { }
+        public override XElement ToXml() => StepXmlRenderer.Render(this, Meta);
+        public override string ToDisplayLine() => "";
+
+        public static StepMetadata Meta { get; } = new()
+        {
+            Name = "Set Variable",
+            Id = 141,
+            Category = "control",
+            Shape =
+            [
+                new NamedCalcChild("Value") { PocoProperty = "Value" },
+                new NamedCalcChild("Repetition") { PocoProperty = "Repetition" },
+                new NamedTextChild("Name") { PocoProperty = "Name" },
+            ],
+        };
+    }
+
+    [Fact]
+    public void Parses_SetVariable_PopulatesProperties()
+    {
+        var canonical = CanonicalSkillFixtures.Load("141-SetVariable");
+        var step = StepXmlParser.Parse<VarLikeStep>(canonical, VarLikeStep.Meta);
+
+        Assert.True(step.Enabled);
+        Assert.Equal("$variable_name", step.Name);
+        Assert.Equal("expression", step.Value.Text);
+        Assert.Equal("1", step.Repetition.Text);
+    }
+
+    [Fact]
+    public void RoundTrips_SetVariable_ParseThenRender()
+    {
+        var canonical = CanonicalSkillFixtures.Load("141-SetVariable");
+        var step = StepXmlParser.Parse<VarLikeStep>(canonical, VarLikeStep.Meta);
+        var emitted = step.ToXml();
+
+        Assert.True(StructuralXml.Equal(canonical, emitted, out var why), why);
+    }
+
+    [Fact]
+    public void Parses_DisabledStep_FromEnableAttr()
+    {
+        var xml = XElement.Parse(
+            "<Step enable=\"False\" id=\"141\" name=\"Set Variable\">"
+            + "<Value><Calculation><![CDATA[1]]></Calculation></Value>"
+            + "<Repetition><Calculation><![CDATA[1]]></Calculation></Repetition>"
+            + "<Name>$x</Name></Step>");
+        var step = StepXmlParser.Parse<VarLikeStep>(xml, VarLikeStep.Meta);
+        Assert.False(step.Enabled);
+    }
+
+    // Mirrors Go to Layout: a value-discriminated union. The discriminator
+    // element is bound to the union's computed WireValue (get-only), so it is
+    // emit-only — parse selects the case from MatchElement/MatchValues instead.
+    private sealed class LayoutLikeStep : ScriptStep
+    {
+        public LayoutTarget Target { get; set; } = new LayoutTarget.Original();
+        public LayoutLikeStep() : base(true) { }
+        public override XElement ToXml() => StepXmlRenderer.Render(this, Meta);
+        public override string ToDisplayLine() => "";
+
+        public static StepMetadata Meta { get; } = new()
+        {
+            Name = "Go to Layout",
+            Id = 6,
+            Category = "navigation",
+            Shape =
+            [
+                new VariantBlock(
+                [
+                    new VariantCase(typeof(LayoutTarget.Original),
+                        [new EnumValueChild("LayoutDestination") { PocoProperty = "WireValue" }])
+                    { MatchElement = "LayoutDestination", MatchValues = ["OriginalLayout"] },
+                    new VariantCase(typeof(LayoutTarget.ByNameCalc),
+                        [
+                            new EnumValueChild("LayoutDestination") { PocoProperty = "WireValue" },
+                            new NamedCalcChild("Layout") { PocoProperty = "Calc" },
+                        ])
+                    { MatchElement = "LayoutDestination", MatchValues = ["LayoutNameByCalc", "LayoutNameByCalculation"] },
+                    new VariantCase(typeof(LayoutTarget.Named),
+                        [
+                            new EnumValueChild("LayoutDestination") { PocoProperty = "WireValue" },
+                            new NamedRefChild("Layout"),
+                        ])
+                    { MatchElement = "LayoutDestination" },
+                ]) { PocoProperty = "Target" },
+            ],
+        };
+    }
+
+    [Fact]
+    public void VariantBlock_Parses_ValueDiscriminatedCase()
+    {
+        var xml = XElement.Parse(
+            "<Step enable=\"True\" id=\"6\" name=\"Go to Layout\">"
+            + "<LayoutDestination value=\"OriginalLayout\"/></Step>");
+        var step = StepXmlParser.Parse<LayoutLikeStep>(xml, LayoutLikeStep.Meta);
+        Assert.IsType<LayoutTarget.Original>(step.Target);
+    }
+
+    [Fact]
+    public void VariantBlock_Parses_LegacyWireValueAlias()
+    {
+        var xml = XElement.Parse(
+            "<Step enable=\"True\" id=\"6\" name=\"Go to Layout\">"
+            + "<LayoutDestination value=\"LayoutNameByCalculation\"/>"
+            + "<Layout><Calculation><![CDATA[\"List View\"]]></Calculation></Layout></Step>");
+        var step = StepXmlParser.Parse<LayoutLikeStep>(xml, LayoutLikeStep.Meta);
+        var byName = Assert.IsType<LayoutTarget.ByNameCalc>(step.Target);
+        Assert.Equal("\"List View\"", byName.Calc.Text);
+    }
+
+    [Fact]
+    public void VariantBlock_FallsThrough_ToPresenceOnlyCase()
+    {
+        var xml = XElement.Parse(
+            "<Step enable=\"True\" id=\"6\" name=\"Go to Layout\">"
+            + "<LayoutDestination value=\"SelectedLayout\"/>"
+            + "<Layout id=\"3\" name=\"Detail\"/></Step>");
+        var step = StepXmlParser.Parse<LayoutLikeStep>(xml, LayoutLikeStep.Meta);
+        var named = Assert.IsType<LayoutTarget.Named>(step.Target);
+        Assert.Equal(3, named.Layout.Id);
+        Assert.Equal("Detail", named.Layout.Name);
+    }
+
+    [Fact]
+    public void VariantBlock_RoundTrips_ParseThenRender()
+    {
+        var xml = XElement.Parse(
+            "<Step enable=\"True\" id=\"6\" name=\"Go to Layout\">"
+            + "<LayoutDestination value=\"LayoutNumberByCalc\"/>"
+            + "<Layout><Calculation><![CDATA[2 + 1]]></Calculation></Layout></Step>");
+        var meta = new StepMetadata
+        {
+            Name = "Go to Layout",
+            Id = 6,
+            Category = "navigation",
+            Shape =
+            [
+                new VariantBlock(
+                [
+                    new VariantCase(typeof(LayoutTarget.ByNumberCalc),
+                        [
+                            new EnumValueChild("LayoutDestination") { PocoProperty = "WireValue" },
+                            new NamedCalcChild("Layout") { PocoProperty = "Calc" },
+                        ])
+                    { MatchElement = "LayoutDestination", MatchValues = ["LayoutNumberByCalc"] },
+                ]) { PocoProperty = "Target" },
+            ],
+        };
+        var step = StepXmlParser.Parse<LayoutLikeStep>(xml, meta);
+        var emitted = StepXmlRenderer.Render(step, meta);
+        Assert.True(StructuralXml.Equal(xml, emitted, out var why), why);
+    }
+
+    // Mirrors Perform Script: a presence-discriminated union — the XML carries
+    // either <Script> or <Calculated>, never both.
+    private sealed class PerformLikeStep : ScriptStep
+    {
+        public PerformScriptTarget Target { get; set; } = new PerformScriptTarget.ByReference(new NamedRef(0, ""));
+        public PerformLikeStep() : base(true) { }
+        public override XElement ToXml() => StepXmlRenderer.Render(this, Meta);
+        public override string ToDisplayLine() => "";
+
+        public static StepMetadata Meta { get; } = new()
+        {
+            Name = "Perform Script",
+            Id = 1,
+            Category = "control",
+            Shape =
+            [
+                new VariantBlock(
+                [
+                    new VariantCase(typeof(PerformScriptTarget.ByReference),
+                        [new NamedRefChild("Script")]) { MatchElement = "Script" },
+                    new VariantCase(typeof(PerformScriptTarget.ByCalculation),
+                        [new NamedCalcChild("Calculated") { PocoProperty = "NameCalc" }])
+                    { MatchElement = "Calculated" },
+                ]) { PocoProperty = "Target" },
+            ],
+        };
+    }
+
+    [Fact]
+    public void VariantBlock_Parses_PresenceDiscriminatedCases()
+    {
+        var byRef = StepXmlParser.Parse<PerformLikeStep>(XElement.Parse(
+            "<Step enable=\"True\" id=\"1\" name=\"Perform Script\">"
+            + "<Script id=\"7\" name=\"Startup\"/></Step>"), PerformLikeStep.Meta);
+        var reference = Assert.IsType<PerformScriptTarget.ByReference>(byRef.Target);
+        Assert.Equal(7, reference.Script.Id);
+
+        var byCalc = StepXmlParser.Parse<PerformLikeStep>(XElement.Parse(
+            "<Step enable=\"True\" id=\"1\" name=\"Perform Script\">"
+            + "<Calculated><Calculation><![CDATA[$script]]></Calculation></Calculated></Step>"), PerformLikeStep.Meta);
+        var calculated = Assert.IsType<PerformScriptTarget.ByCalculation>(byCalc.Target);
+        Assert.Equal("$script", calculated.NameCalc.Text);
+    }
+
+    [Fact]
+    public void VariantBlock_NoMatchingCase_LeavesPocoDefault()
+    {
+        var step = StepXmlParser.Parse<PerformLikeStep>(XElement.Parse(
+            "<Step enable=\"True\" id=\"1\" name=\"Perform Script\"/>"), PerformLikeStep.Meta);
+        Assert.IsType<PerformScriptTarget.ByReference>(step.Target);
+    }
+
+    // Mirrors Perform JavaScript in Web Viewer: <Parameters Count="N"> holding
+    // <P><Calculation> children bound to a List<Calculation> property.
+    private sealed class JsLikeStep : ScriptStep
+    {
+        public List<Calculation> Parameters { get; set; } = [];
+        public JsLikeStep() : base(true) { }
+        public override XElement ToXml() => StepXmlRenderer.Render(this, Meta);
+        public override string ToDisplayLine() => "";
+
+        public static StepMetadata Meta { get; } = new()
+        {
+            Name = "Perform JavaScript in Web Viewer",
+            Id = 175,
+            Category = "misc",
+            Shape = [new ParametersList()],
+        };
+    }
+
+    // Mirrors Insert PDF: one element carrying text content plus a type
+    // attribute, each bound to its own property.
+    private sealed class PathLikeStep : ScriptStep
+    {
+        public string Path { get; set; } = "";
+        public string StorageType { get; set; } = "Embedded";
+        public PathLikeStep() : base(true) { }
+        public override XElement ToXml() => StepXmlRenderer.Render(this, Meta);
+        public override string ToDisplayLine() => "";
+
+        public static StepMetadata Meta { get; } = new()
+        {
+            Name = "Insert PDF",
+            Id = 158,
+            Category = "fields",
+            Shape =
+            [
+                new NamedTextChild("UniversalPathList")
+                {
+                    PocoProperty = "Path",
+                    Attr = "type",
+                    AttrProperty = "StorageType",
+                    AttrDefault = "Embedded",
+                },
+            ],
+        };
+    }
+
+    [Fact]
+    public void NamedTextChild_RoundTrips_AttributeAndText()
+    {
+        var step = new PathLikeStep { Path = "image:pic.pdf", StorageType = "Reference" };
+        var emitted = step.ToXml();
+        Assert.Equal("Reference", emitted.Element("UniversalPathList")?.Attribute("type")?.Value);
+        Assert.Equal("image:pic.pdf", emitted.Element("UniversalPathList")?.Value);
+
+        var parsed = StepXmlParser.Parse<PathLikeStep>(emitted, PathLikeStep.Meta);
+        Assert.Equal("image:pic.pdf", parsed.Path);
+        Assert.Equal("Reference", parsed.StorageType);
+    }
+
+    [Fact]
+    public void NamedTextChild_AbsentElement_UsesAttrDefault()
+    {
+        var parsed = StepXmlParser.Parse<PathLikeStep>(
+            XElement.Parse("<Step enable=\"True\" id=\"158\" name=\"Insert PDF\"/>"),
+            PathLikeStep.Meta);
+        Assert.Equal("", parsed.Path);
+        Assert.Equal("Embedded", parsed.StorageType);
+    }
+
+    // Mirrors Save a Copy as XML's <SaXML>: a wrapper emitted only when its
+    // gate property is non-null.
+    private sealed class GatedWrapperStep : ScriptStep
+    {
+        public Calculation? JsonOptions { get; set; }
+        public GatedWrapperStep() : base(true) { }
+        public override XElement ToXml() => StepXmlRenderer.Render(this, Meta);
+        public override string ToDisplayLine() => "";
+
+        public static StepMetadata Meta { get; } = new()
+        {
+            Name = "Save a Copy as XML",
+            Id = 3,
+            Category = "files",
+            Shape =
+            [
+                new WrapperChild("SaXML",
+                [
+                    new BareCalcChild { PocoProperty = "JsonOptions" },
+                ]) { PocoProperty = "JsonOptions", Optional = true },
+            ],
+        };
+    }
+
+    [Fact]
+    public void OptionalWrapper_OmittedWhenGateNull_EmittedWhenSet()
+    {
+        Assert.Null(new GatedWrapperStep().ToXml().Element("SaXML"));
+
+        var configured = new GatedWrapperStep { JsonOptions = new Calculation("JSONGetElement ( $$x ; \"a\" )") };
+        var emitted = configured.ToXml();
+        Assert.NotNull(emitted.Element("SaXML"));
+
+        var parsed = StepXmlParser.Parse<GatedWrapperStep>(emitted, GatedWrapperStep.Meta);
+        Assert.Equal(configured.JsonOptions.Text, parsed.JsonOptions?.Text);
+    }
+
+    // Mirrors the AI/ML bag steps: the whole body round-trips through a
+    // StepChildBag-typed Passthrough.
+    private sealed class BagLikeStep : ScriptStep
+    {
+        public StepChildBag Children { get; set; } = new();
+        public BagLikeStep() : base(true) { }
+        public override XElement ToXml() => StepXmlRenderer.Render(this, Meta);
+        public override string ToDisplayLine() => "";
+
+        public static StepMetadata Meta { get; } = new()
+        {
+            Name = "Perform RAG Action",
+            Id = 232,
+            Category = "misc",
+            Shape = [new Passthrough { PocoProperty = "Children" }],
+        };
+    }
+
+    [Fact]
+    public void Passthrough_RoundTrips_StepChildBag()
+    {
+        var xml = XElement.Parse(
+            "<Step enable=\"True\" id=\"232\" name=\"Perform RAG Action\">"
+            + "<Account><Calculation><![CDATA[\"rag\"]]></Calculation></Account>"
+            + "<Prompt><Calculation><![CDATA[$q]]></Calculation></Prompt></Step>");
+        var parsed = StepXmlParser.Parse<BagLikeStep>(xml, BagLikeStep.Meta);
+        Assert.Equal(2, parsed.Children.Children.Count);
+
+        var emitted = parsed.ToXml();
+        Assert.True(StructuralXml.Equal(xml, emitted, out var why), why);
+    }
+
+    [Fact]
+    public void ParametersList_RoundTrips_CalculationItems()
+    {
+        var step = new JsLikeStep
+        {
+            Parameters = [new Calculation("\"arg1\""), new Calculation("$two")],
+        };
+        var emitted = step.ToXml();
+        var parsed = StepXmlParser.Parse<JsLikeStep>(emitted, JsLikeStep.Meta);
+
+        Assert.Equal(2, parsed.Parameters.Count);
+        Assert.Equal("\"arg1\"", parsed.Parameters[0].Text);
+        Assert.Equal("$two", parsed.Parameters[1].Text);
+
+        var reEmitted = parsed.ToXml();
+        Assert.True(StructuralXml.Equal(emitted, reEmitted, out var why), why);
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/Serialization/StepXmlRendererTests.cs b/tests/SharpFM.Tests/Scripting/Serialization/StepXmlRendererTests.cs
new file mode 100644
index 0000000..e0ae715
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/Serialization/StepXmlRendererTests.cs
@@ -0,0 +1,89 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
+using SharpFM.Model.Scripting.Steps;
+using SharpFM.Model.Scripting.Values;
+using SharpFM.Tests.CanonicalSkill;
+using Xunit;
+
+namespace SharpFM.Tests.Scripting.Serialization;
+
+public class StepXmlRendererTests
+{
+    [Fact]
+    public void Renders_SetVariable_ToCanonicalForm()
+    {
+        var shape = new ShapeNode[]
+        {
+            new NamedCalcChild("Value") { PocoProperty = "Value", Required = true },
+            new NamedCalcChild("Repetition") { PocoProperty = "Repetition" },
+            new NamedTextChild("Name") { PocoProperty = "Name", Required = true },
+        };
+        var meta = SetVariableStep.Metadata with { Shape = shape };
+        var step = new SetVariableStep(true, "$variable_name",
+            new Calculation("expression"), new Calculation("1"));
+
+        var emitted = StepXmlRenderer.Render(step, meta);
+        var canonical = CanonicalSkillFixtures.Load("141-SetVariable");
+
+        Assert.True(StructuralXml.Equal(canonical, emitted, out var why), why);
+    }
+
+    // Synthetic step exercising bool/enum/calc primitives and optional omission.
+    private sealed class SampleStep : ScriptStep
+    {
+        public bool Restore { get; set; }
+        public string FlushType { get; set; } = "Always";
+        public Calculation Condition { get; set; } = new("");
+        public string Note { get; set; } = "";
+        public SampleStep() : base(true) { }
+        public override XElement ToXml() => throw new System.NotImplementedException();
+        public override string ToDisplayLine() => "";
+    }
+
+    private static StepMetadata Meta(params ShapeNode[] shape) =>
+        new() { Name = "Sample", Id = 999, Category = "test", Shape = shape };
+
+    [Fact]
+    public void Emits_BoolState_And_Enum()
+    {
+        var step = new SampleStep { Restore = false, FlushType = "Always" };
+        var xml = StepXmlRenderer.Render(step, Meta(
+            new BoolStateChild("Restore"),
+            new EnumValueChild("FlushType")));
+
+        Assert.Equal("False", xml.Element("Restore")!.Attribute("state")!.Value);
+        Assert.Equal("Always", xml.Element("FlushType")!.Attribute("value")!.Value);
+    }
+
+    [Fact]
+    public void OptionalBareCalc_OmittedWhenEmpty_EmittedWhenSet()
+    {
+        var empty = StepXmlRenderer.Render(new SampleStep { Condition = new Calculation("") },
+            Meta(new BareCalcChild { PocoProperty = "Condition", Optional = true }));
+        Assert.Null(empty.Element("Calculation"));
+
+        var set = StepXmlRenderer.Render(new SampleStep { Condition = new Calculation("x > 1") },
+            Meta(new BareCalcChild { PocoProperty = "Condition", Optional = true }));
+        Assert.Equal("x > 1", set.Element("Calculation")!.Value);
+    }
+
+    [Fact]
+    public void OptionalNamedText_OmittedWhenEmpty()
+    {
+        var xml = StepXmlRenderer.Render(new SampleStep { Note = "" },
+            Meta(new NamedTextChild("Note") { Optional = true }));
+        Assert.Null(xml.Element("Note"));
+    }
+
+    [Fact]
+    public void StepAttributes_AreEmitted()
+    {
+        var xml = StepXmlRenderer.Render(new SampleStep(), Meta());
+        Assert.Equal("True", xml.Attribute("enable")!.Value);
+        Assert.Equal("999", xml.Attribute("id")!.Value);
+        Assert.Equal("Sample", xml.Attribute("name")!.Value);
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/Serialization/StepXmlValidatorTests.cs b/tests/SharpFM.Tests/Scripting/Serialization/StepXmlValidatorTests.cs
new file mode 100644
index 0000000..64e0af0
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/Serialization/StepXmlValidatorTests.cs
@@ -0,0 +1,72 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Serialization;
+using SharpFM.Model.Scripting.Shapes;
+using Xunit;
+
+namespace SharpFM.Tests.Scripting.Serialization;
+
+public class StepXmlValidatorTests
+{
+    // Set Variable: Value, Repetition, Name (Name present and last).
+    private static StepMetadata SetVarMeta() => new()
+    {
+        Name = "Set Variable",
+        Id = 141,
+        Category = "control",
+        Shape =
+        [
+            new NamedCalcChild("Value"),
+            new NamedCalcChild("Repetition"),
+            new NamedTextChild("Name"),
+        ],
+    };
+
+    [Fact]
+    public void CanonicalOrder_NoIssues()
+    {
+        var step = XElement.Parse(
+            "<Step enable=\"True\" id=\"141\" name=\"Set Variable\">"
+            + "<Value><Calculation><![CDATA[1]]></Calculation></Value>"
+            + "<Repetition><Calculation><![CDATA[1]]></Calculation></Repetition>"
+            + "<Name>$x</Name></Step>");
+        Assert.Empty(StepXmlValidator.Validate(step, SetVarMeta()));
+    }
+
+    [Fact]
+    public void NameNotLast_IsFlagged()
+    {
+        // The §7.1/7.4 trap shape: Name appears before Value.
+        var step = XElement.Parse(
+            "<Step enable=\"True\" id=\"141\" name=\"Set Variable\">"
+            + "<Name>$x</Name>"
+            + "<Value><Calculation><![CDATA[1]]></Calculation></Value>"
+            + "<Repetition><Calculation><![CDATA[1]]></Calculation></Repetition></Step>");
+        var issues = StepXmlValidator.Validate(step, SetVarMeta());
+        Assert.Contains(issues, i => i.Contains("Value") && i.Contains("out of canonical order"));
+    }
+
+    [Fact]
+    public void UnknownChild_IsFlagged()
+    {
+        var step = XElement.Parse(
+            "<Step enable=\"True\" id=\"141\" name=\"Set Variable\">"
+            + "<Value><Calculation><![CDATA[1]]></Calculation></Value>"
+            + "<Repetition><Calculation><![CDATA[1]]></Calculation></Repetition>"
+            + "<Name>$x</Name>"
+            + "<Bogus/></Step>");
+        var issues = StepXmlValidator.Validate(step, SetVarMeta());
+        Assert.Contains(issues, i => i.Contains("Bogus") && i.Contains("not a recognized child"));
+    }
+
+    [Fact]
+    public void OptionalAbsentChild_IsAllowed()
+    {
+        // Repetition omitted — still in order, no issue.
+        var step = XElement.Parse(
+            "<Step enable=\"True\" id=\"141\" name=\"Set Variable\">"
+            + "<Value><Calculation><![CDATA[1]]></Calculation></Value>"
+            + "<Name>$x</Name></Step>");
+        Assert.Empty(StepXmlValidator.Validate(step, SetVarMeta()));
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/Steps/AVPlayerSetPlaybackStateStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/AVPlayerSetPlaybackStateStepTests.cs
index 654e86d..dc3e5d5 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/AVPlayerSetPlaybackStateStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/AVPlayerSetPlaybackStateStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -37,7 +38,7 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("AVPlayer Set Playback State", out var metadata));
         Assert.Equal(178, metadata!.Id);
-        Assert.Single(metadata.Params);
-        Assert.Equal("enum", metadata.Params[0].Type);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.Equal("enum", ShapeHrView.KindOf(ShapeHrView.HrNodes(metadata.Shape)[0]));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/AddAccountStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/AddAccountStepTests.cs
index 6caf515..9df25e6 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/AddAccountStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/AddAccountStepTests.cs
@@ -8,7 +8,9 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class AddAccountStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="134" name="Add Account"><AccountType value="FileMaker"/><AccountName><Calculation><![CDATA[$x]]></Calculation></AccountName><Password><Calculation><![CDATA[$x]]></Calculation></Password><PrivilegeSet>$example</PrivilegeSet><ChgPwdOnNextLogin value="True"/></Step>""";
+    // Canonical (skill): ChgPwdOnNextLogin first, then the <AddAccount> wrapper
+    // with a text <AccountType> (was a flat, value-attr, wrapper-less form).
+    private const string CanonicalXml = """<Step enable="True" id="134" name="Add Account"><ChgPwdOnNextLogin value="True"/><AddAccount><AccountType>FileMaker</AccountType><AccountName><Calculation><![CDATA[$x]]></Calculation></AccountName><Password><Calculation><![CDATA[$x]]></Calculation></Password><PrivilegeSet>$example</PrivilegeSet></AddAccount></Step>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
diff --git a/tests/SharpFM.Tests/Scripting/Steps/AdjustWindowStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/AdjustWindowStepTests.cs
index d50b272..de878e7 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/AdjustWindowStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/AdjustWindowStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -37,7 +38,7 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Adjust Window", out var metadata));
         Assert.Equal(31, metadata!.Id);
-        Assert.Single(metadata.Params);
-        Assert.Equal("enum", metadata.Params[0].Type);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.Equal("enum", ShapeHrView.KindOf(ShapeHrView.HrNodes(metadata.Shape)[0]));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/AllowFormattingBarStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/AllowFormattingBarStepTests.cs
index 6869d95..d24b017 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/AllowFormattingBarStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/AllowFormattingBarStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Allow Formatting Bar", out var metadata));
         Assert.Equal(115, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/AllowUserAbortStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/AllowUserAbortStepTests.cs
index b297f8e..1a08dbb 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/AllowUserAbortStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/AllowUserAbortStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Allow User Abort", out var metadata));
         Assert.Equal(85, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/AppendPdfStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/AppendPdfStepTests.cs
new file mode 100644
index 0000000..3714e89
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/Steps/AppendPdfStepTests.cs
@@ -0,0 +1,32 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Steps;
+using Xunit;
+
+namespace SharpFM.Tests.Scripting.Steps;
+
+public class AppendPdfStepTests
+{
+    private const string MinimalXml =
+        """<Step enable="True" id="244" name="Append PDF"><Option state="False" /><AppendPDFFile><PDFSaveType>File</PDFSaveType></AppendPDFFile></Step>""";
+
+    private const string PathPasswordXml =
+        """<Step enable="True" id="244" name="Append PDF"><Option state="True" /><UniversalPathList>image:../path/to/file.pdf</UniversalPathList><AppendPDFFile><PDFSaveType>File</PDFSaveType><OpenPassword><Calculation><![CDATA[password expression]]></Calculation></OpenPassword></AppendPDFFile></Step>""";
+
+    [Theory]
+    [InlineData(MinimalXml)]
+    [InlineData(PathPasswordXml)]
+    public void RoundTrip_CanonicalXml_IsPreserved(string canonicalXml)
+    {
+        var source = XElement.Parse(canonicalXml);
+        var step = AppendPdfStep.Metadata.FromXml!(source);
+        Assert.True(XNode.DeepEquals(source, step.ToXml()));
+    }
+
+    [Fact]
+    public void Registry_HasStep()
+    {
+        Assert.True(StepRegistry.ByName.TryGetValue("Append PDF", out var metadata));
+        Assert.Equal(244, metadata!.Id);
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ArrangeAllWindowsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ArrangeAllWindowsStepTests.cs
index d7fe1f3..9427862 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ArrangeAllWindowsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ArrangeAllWindowsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -37,7 +38,7 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Arrange All Windows", out var metadata));
         Assert.Equal(120, metadata!.Id);
-        Assert.Single(metadata.Params);
-        Assert.Equal("enum", metadata.Params[0].Type);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.Equal("enum", ShapeHrView.KindOf(ShapeHrView.HrNodes(metadata.Shape)[0]));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/BeepStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/BeepStepTests.cs
index 3b06fa2..0b72794 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/BeepStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/BeepStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -59,6 +60,6 @@ public void Registry_HasBeep()
         Assert.Equal(93, metadata!.Id);
         Assert.Equal("miscellaneous", metadata.Category);
         Assert.Null(metadata.BlockPair);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/CancelPdfStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/CancelPdfStepTests.cs
new file mode 100644
index 0000000..123ae84
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/Steps/CancelPdfStepTests.cs
@@ -0,0 +1,28 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Steps;
+using Xunit;
+
+namespace SharpFM.Tests.Scripting.Steps;
+
+public class CancelPdfStepTests
+{
+    private const string CanonicalXml = """
+        <Step enable="True" id="247" name="Cancel PDF" />
+        """;
+
+    [Fact]
+    public void RoundTrip_CanonicalXml_IsPreserved()
+    {
+        var source = XElement.Parse(CanonicalXml);
+        var step = CancelPdfStep.Metadata.FromXml!(source);
+        Assert.True(XNode.DeepEquals(source, step.ToXml()));
+    }
+
+    [Fact]
+    public void Registry_HasStep()
+    {
+        Assert.True(StepRegistry.ByName.TryGetValue("Cancel PDF", out var metadata));
+        Assert.Equal(247, metadata!.Id);
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/Steps/CheckFoundSetStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/CheckFoundSetStepTests.cs
index 1876832..239c658 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/CheckFoundSetStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/CheckFoundSetStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Check Found Set", out var metadata));
         Assert.Equal(20, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/CheckRecordStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/CheckRecordStepTests.cs
index 93995b9..0843a75 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/CheckRecordStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/CheckRecordStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Check Record", out var metadata));
         Assert.Equal(19, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ClosePdfStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ClosePdfStepTests.cs
new file mode 100644
index 0000000..cb1deb5
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/Steps/ClosePdfStepTests.cs
@@ -0,0 +1,32 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Steps;
+using Xunit;
+
+namespace SharpFM.Tests.Scripting.Steps;
+
+public class ClosePdfStepTests
+{
+    private const string MinimalXml =
+        """<Step enable="True" id="245" name="Close PDF"><CreateDirectories state="False" /><AutoOpen state="False" /><CreateEmail state="False" /><ClosePDFFile><PDFSaveType>File</PDFSaveType></ClosePDFFile></Step>""";
+
+    private const string PathXml =
+        """<Step enable="True" id="245" name="Close PDF"><CreateDirectories state="False" /><AutoOpen state="True" /><CreateEmail state="True" /><UniversalPathList>file:"filename.pdf"</UniversalPathList><ClosePDFFile><PDFSaveType>File</PDFSaveType></ClosePDFFile></Step>""";
+
+    [Theory]
+    [InlineData(MinimalXml)]
+    [InlineData(PathXml)]
+    public void RoundTrip_CanonicalXml_IsPreserved(string canonicalXml)
+    {
+        var source = XElement.Parse(canonicalXml);
+        var step = ClosePdfStep.Metadata.FromXml!(source);
+        Assert.True(XNode.DeepEquals(source, step.ToXml()));
+    }
+
+    [Fact]
+    public void Registry_HasStep()
+    {
+        Assert.True(StepRegistry.ByName.TryGetValue("Close PDF", out var metadata));
+        Assert.Equal(245, metadata!.Id);
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ClosePopoverStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ClosePopoverStepTests.cs
index 0ad026c..4e358ef 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ClosePopoverStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ClosePopoverStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Close Popover", out var metadata));
         Assert.Equal(169, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/CommitRecordsRequestsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/CommitRecordsRequestsStepTests.cs
index aea7fad..14a98e6 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/CommitRecordsRequestsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/CommitRecordsRequestsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -62,6 +63,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Commit Records/Requests", out var metadata));
         Assert.Equal(75, metadata!.Id);
-        Assert.Equal(3, metadata.Params.Count);
+        Assert.Equal(3, ShapeHrView.HrNodes(metadata.Shape).Count);
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/CommitTransactionStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/CommitTransactionStepTests.cs
index ac18b23..7ebae9c 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/CommitTransactionStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/CommitTransactionStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Commit Transaction", out var metadata));
         Assert.Equal(206, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ConfigureAIAccountStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ConfigureAIAccountStepTests.cs
index bafd405..9e42dcb 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ConfigureAIAccountStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ConfigureAIAccountStepTests.cs
@@ -8,7 +8,9 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class ConfigureAIAccountStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="212" name="Configure AI Account"><AccoutName><Calculation><![CDATA[$x]]></Calculation></AccoutName><LLMType value="OpenAI"/><Endpoint><Calculation><![CDATA[$x]]></Calculation></Endpoint><VerifySSLCertificates state="True"/><AccessAPIKey><Calculation><![CDATA[$x]]></Calculation></AccessAPIKey></Step>""";
+    // Canonical (skill): optional VerifySSLCertificates, then LLMType, then the
+    // <SetLLMAccount> wrapper (was a flat form with the <AccoutName> typo).
+    private const string CanonicalXml = """<Step enable="True" id="212" name="Configure AI Account"><VerifySSLCertificates state="True"/><LLMType value="OpenAI"/><SetLLMAccount><AccountName><Calculation><![CDATA[$x]]></Calculation></AccountName><Endpoint><Calculation><![CDATA[$x]]></Calculation></Endpoint><AccessAPIKey><Calculation><![CDATA[$x]]></Calculation></AccessAPIKey></SetLLMAccount></Step>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ConfigurePromptTemplateStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ConfigurePromptTemplateStepTests.cs
index 27a9c7d..e680949 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ConfigurePromptTemplateStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ConfigurePromptTemplateStepTests.cs
@@ -8,7 +8,7 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class ConfigurePromptTemplateStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="226" name="Configure Prompt Template"><TemplateName><Calculation><![CDATA[$x]]></Calculation></TemplateName><ModelProvider value="OpenAI"/><RequestType value="SQL Query"/><SQLPrompt><Calculation><![CDATA[$x]]></Calculation></SQLPrompt><NaturalLanguagePrompt><Calculation><![CDATA[$x]]></Calculation></NaturalLanguagePrompt><FindRequestPrompt><Calculation><![CDATA[$x]]></Calculation></FindRequestPrompt><RAGPPrompt><Calculation><![CDATA[$x]]></Calculation></RAGPPrompt><Option state="True"/></Step>""";
+    private const string CanonicalXml = """<Step enable="True" id="226" name="Configure Prompt Template"><Option state="False"/><ConfigurePromptTemplate><ModelProvider>ChatGPT</ModelProvider><RequestType>SQLQuery</RequestType></ConfigurePromptTemplate></Step>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ConfigureRAGAccountStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ConfigureRAGAccountStepTests.cs
index 4ad8b21..459da6b 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ConfigureRAGAccountStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ConfigureRAGAccountStepTests.cs
@@ -8,7 +8,9 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class ConfigureRAGAccountStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="227" name="Configure RAG Account "><RAGAccountName><Calculation><![CDATA[$x]]></Calculation></RAGAccountName><Endpoint><Calculation><![CDATA[$x]]></Calculation></Endpoint><AccessAPIKey><Calculation><![CDATA[$x]]></Calculation></AccessAPIKey><VerifySSLCertificates state="True"/></Step>""";
+    // Canonical (skill): VerifySSLCertificates first, then a <ConfigureRAGAccount>
+    // wrapper holding the account fields (was a flat, wrapper-less, mis-ordered form).
+    private const string CanonicalXml = """<Step enable="True" id="227" name="Configure RAG Account "><VerifySSLCertificates state="True"/><ConfigureRAGAccount><RAGAccountName><Calculation><![CDATA[$x]]></Calculation></RAGAccountName><Endpoint><Calculation><![CDATA[$x]]></Calculation></Endpoint><AccessAPIKey><Calculation><![CDATA[$x]]></Calculation></AccessAPIKey></ConfigureRAGAccount></Step>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ControlFlowStepsTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ControlFlowStepsTests.cs
index 9ca5336..5e20181 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ControlFlowStepsTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ControlFlowStepsTests.cs
@@ -112,11 +112,12 @@ public void ElseIf_RoundTrip_UsesCorrectIdAndName()
     }
 
     [Fact]
-    public void Else_RoundTrip_NoChildElements()
+    public void Else_RoundTrip_EmitsCanonicalRestore()
     {
+        // Canonical §8.1: Else carries <Restore state="False"/>.
         var step = ScriptStep.FromXml(MakeStep(ElseXml));
         var xml = step.ToXml();
-        Assert.Empty(xml.Elements());
+        Assert.Equal("False", xml.Element("Restore")!.Attribute("state")!.Value);
         Assert.Equal("69", xml.Attribute("id")!.Value);
     }
 
@@ -162,11 +163,15 @@ public void Loop_Display_DoesNotShowCatalogDefaults()
     }
 
     [Fact]
-    public void Loop_RoundTrip_NoChildElements()
+    public void Loop_RoundTrip_EmitsCanonicalRestoreAndFlushType()
     {
+        // Canonical §8.1: Loop carries <Restore state="False"/> then <FlushType value="Always"/>.
         var step = ScriptStep.FromXml(MakeStep(LoopXml));
         var xml = step.ToXml();
-        Assert.Empty(xml.Elements());
+        Assert.Equal("False", xml.Element("Restore")!.Attribute("state")!.Value);
+        Assert.Equal("Always", xml.Element("FlushType")!.Attribute("value")!.Value);
+        Assert.Equal(new[] { "Restore", "FlushType" },
+            xml.Elements().Select(e => e.Name.LocalName).ToArray());
         Assert.Equal("71", xml.Attribute("id")!.Value);
     }
 
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ConvertFileStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ConvertFileStepTests.cs
index eb8fdb4..43f3903 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ConvertFileStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ConvertFileStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -9,7 +10,7 @@ namespace SharpFM.Tests.Scripting.Steps;
 public class ConvertFileStepTests
 {
     private const string CanonicalXml = """
-        <Step enable="True" id="139" name="Convert File"><Option state="False"/><SkipIndexes state="False"/><NoInteract state="False"/><DataSourceType value="File"/><VerifySSLCertificates state="True"/></Step>
+        <Step enable="True" id="139" name="Convert File"><NoInteract state="False"/><Option state="False"/><SkipIndexes state="False"/><VerifySSLCertificates state="True"/></Step>
         """;
 
     [Fact]
@@ -38,7 +39,7 @@ public void Display_RoundTripsThroughFromDisplayParams()
     public void DataSourceType_Unlabeled_RoundTripsByPosition()
     {
         var xml = XElement.Parse("""
-            <Step enable="True" id="139" name="Convert File"><Option state="False"/><SkipIndexes state="False"/><NoInteract state="False"/><DataSourceType value="XMLSource"/><VerifySSLCertificates state="False"/></Step>
+            <Step enable="True" id="139" name="Convert File"><NoInteract state="False"/><Option state="False"/><SkipIndexes state="False"/><VerifySSLCertificates state="False"/><DataSourceType value="XMLSource"/></Step>
             """);
         var step = (ConvertFileStep)ConvertFileStep.Metadata.FromXml!(xml);
         Assert.Equal("XMLSource", step.DataSourceType);
@@ -50,6 +51,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Convert File", out var metadata));
         Assert.Equal(139, metadata!.Id);
-        Assert.Equal(5, metadata.Params.Count);
+        Assert.Equal(5, ShapeHrView.HrNodes(metadata.Shape).Count);
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/CopyAllRecordsRequestsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/CopyAllRecordsRequestsStepTests.cs
index 5eb6692..88f7054 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/CopyAllRecordsRequestsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/CopyAllRecordsRequestsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Copy All Records/Requests", out var metadata));
         Assert.Equal(98, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/CopyRecordRequestStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/CopyRecordRequestStepTests.cs
index 3709fd7..b9b01e9 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/CopyRecordRequestStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/CopyRecordRequestStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Copy Record/Request", out var metadata));
         Assert.Equal(101, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/CorrectWordStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/CorrectWordStepTests.cs
index 6384382..efa395f 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/CorrectWordStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/CorrectWordStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Correct Word", out var metadata));
         Assert.Equal(106, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/CreatePdfStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/CreatePdfStepTests.cs
new file mode 100644
index 0000000..c1ad538
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/Steps/CreatePdfStepTests.cs
@@ -0,0 +1,32 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Steps;
+using Xunit;
+
+namespace SharpFM.Tests.Scripting.Steps;
+
+public class CreatePdfStepTests
+{
+    private const string PageRangeXml =
+        """<Step enable="True" id="243" name="Create PDF"><Restore state="False" /><CreatePDFFile><Document><Pages AllPages="True"><NumberFrom><Calculation><![CDATA[1]]></Calculation></NumberFrom><PageRange><From><Calculation><![CDATA[1]]></Calculation></From><To><Calculation><![CDATA[1]]></Calculation></To></PageRange></Pages></Document><Security allowScreenReader="True" enableCopying="True" controlEditing="AnyExceptExtractingPages" controlPrinting="HighResolution" requireControlEditPassword="False" requireOpenPassword="False" /><View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage" /></CreatePDFFile></Step>""";
+
+    private const string MetadataAndSecurityXml =
+        """<Step enable="True" id="243" name="Create PDF"><Restore state="True" /><Calculation><![CDATA[1]]></Calculation><CreatePDFFile><Document><Title><Calculation><![CDATA[title expression]]></Calculation></Title><Subject><Calculation><![CDATA[subject expression]]></Calculation></Subject><Author><Calculation><![CDATA[author expression]]></Calculation></Author><Keywords><Calculation><![CDATA[keywords expression]]></Calculation></Keywords><Pages AllPages="True"><NumberFrom><Calculation><![CDATA[1]]></Calculation></NumberFrom></Pages></Document><Security allowScreenReader="True" enableCopying="True" controlEditing="InsertingDeletingRotatingPages" controlPrinting="LowResolution" requireControlEditPassword="True" requireOpenPassword="True"><OpenPassword><Calculation><![CDATA[password expression]]></Calculation></OpenPassword><ControlPassword><Calculation><![CDATA[password expression]]></Calculation></ControlPassword></Security><View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage" /></CreatePDFFile></Step>""";
+
+    [Theory]
+    [InlineData(PageRangeXml)]
+    [InlineData(MetadataAndSecurityXml)]
+    public void RoundTrip_CanonicalXml_IsPreserved(string canonicalXml)
+    {
+        var source = XElement.Parse(canonicalXml);
+        var step = CreatePdfStep.Metadata.FromXml!(source);
+        Assert.True(XNode.DeepEquals(source, step.ToXml()));
+    }
+
+    [Fact]
+    public void Registry_HasStep()
+    {
+        Assert.True(StepRegistry.ByName.TryGetValue("Create PDF", out var metadata));
+        Assert.Equal(243, metadata!.Id);
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/Steps/DeleteAllRecordsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/DeleteAllRecordsStepTests.cs
index 7ba1edb..a69993a 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/DeleteAllRecordsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/DeleteAllRecordsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Delete All Records", out var metadata));
         Assert.Equal(10, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/DeletePortalRowStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/DeletePortalRowStepTests.cs
index 5688dac..b86fd9c 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/DeletePortalRowStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/DeletePortalRowStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Delete Portal Row", out var metadata));
         Assert.Equal(104, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/DeleteRecordRequestStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/DeleteRecordRequestStepTests.cs
index 57248de..eea6f26 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/DeleteRecordRequestStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/DeleteRecordRequestStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Delete Record/Request", out var metadata));
         Assert.Equal(9, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/DuplicateRecordRequestStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/DuplicateRecordRequestStepTests.cs
index 4921f6e..0fb6514 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/DuplicateRecordRequestStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/DuplicateRecordRequestStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Duplicate Record/Request", out var metadata));
         Assert.Equal(8, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/EditUserDictionaryStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/EditUserDictionaryStepTests.cs
index 8167ba3..336bf9a 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/EditUserDictionaryStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/EditUserDictionaryStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Edit User Dictionary", out var metadata));
         Assert.Equal(109, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/EnableTouchKeyboardStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/EnableTouchKeyboardStepTests.cs
index c5e5690..cc3b866 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/EnableTouchKeyboardStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/EnableTouchKeyboardStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -37,7 +38,7 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Enable Touch Keyboard", out var metadata));
         Assert.Equal(174, metadata!.Id);
-        Assert.Single(metadata.Params);
-        Assert.Equal("enum", metadata.Params[0].Type);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.Equal("enum", ShapeHrView.KindOf(ShapeHrView.HrNodes(metadata.Shape)[0]));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/EnterBrowseModeStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/EnterBrowseModeStepTests.cs
index 4477717..0675929 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/EnterBrowseModeStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/EnterBrowseModeStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Enter Browse Mode", out var metadata));
         Assert.Equal(55, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/EnterPreviewModeStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/EnterPreviewModeStepTests.cs
index 6982432..1c962bb 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/EnterPreviewModeStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/EnterPreviewModeStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Enter Preview Mode", out var metadata));
         Assert.Equal(41, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ExitApplicationStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ExitApplicationStepTests.cs
index a326733..1bba388 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ExitApplicationStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ExitApplicationStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Exit Application", out var metadata));
         Assert.Equal(44, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/FlushCacheToDiskStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/FlushCacheToDiskStepTests.cs
index bbb6901..b729be7 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/FlushCacheToDiskStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/FlushCacheToDiskStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Flush Cache to Disk", out var metadata));
         Assert.Equal(102, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/FreezeWindowStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/FreezeWindowStepTests.cs
index 1dc535b..ef1f935 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/FreezeWindowStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/FreezeWindowStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Freeze Window", out var metadata));
         Assert.Equal(79, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/GoToNextFieldStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/GoToNextFieldStepTests.cs
index 66b7481..8cd393d 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/GoToNextFieldStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/GoToNextFieldStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -12,7 +13,7 @@ namespace SharpFM.Tests.Scripting.Steps;
 /// </summary>
 public class GoToNextFieldStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="5" name="Go to Next Field"/>""";
+    private const string CanonicalXml = """<Step enable="True" id="4" name="Go to Next Field"/>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
@@ -34,7 +35,7 @@ public void Display_EmitsBareName()
     [Fact]
     public void Disabled_RoundTrips()
     {
-        var source = XElement.Parse("""<Step enable="False" id="5" name="Go to Next Field"/>""");
+        var source = XElement.Parse("""<Step enable="False" id="4" name="Go to Next Field"/>""");
         var step = GoToNextFieldStep.Metadata.FromXml!(source);
 
         Assert.False(step.Enabled);
@@ -45,7 +46,7 @@ public void Disabled_RoundTrips()
     public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Go to Next Field", out var metadata));
-        Assert.Equal(5, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Equal(4, metadata!.Id);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/GoToPreviousFieldStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/GoToPreviousFieldStepTests.cs
index 18d6244..1bac870 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/GoToPreviousFieldStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/GoToPreviousFieldStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -12,7 +13,7 @@ namespace SharpFM.Tests.Scripting.Steps;
 /// </summary>
 public class GoToPreviousFieldStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="4" name="Go to Previous Field"/>""";
+    private const string CanonicalXml = """<Step enable="True" id="5" name="Go to Previous Field"/>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
@@ -34,7 +35,7 @@ public void Display_EmitsBareName()
     [Fact]
     public void Disabled_RoundTrips()
     {
-        var source = XElement.Parse("""<Step enable="False" id="4" name="Go to Previous Field"/>""");
+        var source = XElement.Parse("""<Step enable="False" id="5" name="Go to Previous Field"/>""");
         var step = GoToPreviousFieldStep.Metadata.FromXml!(source);
 
         Assert.False(step.Enabled);
@@ -45,7 +46,7 @@ public void Disabled_RoundTrips()
     public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Go to Previous Field", out var metadata));
-        Assert.Equal(4, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Equal(5, metadata!.Id);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/GoToRelatedRecordStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/GoToRelatedRecordStepTests.cs
index 4945c10..41995c4 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/GoToRelatedRecordStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/GoToRelatedRecordStepTests.cs
@@ -7,8 +7,9 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class GoToRelatedRecordStepTests
 {
+    // Canonical (skill): no trailing <Animation> element for this step.
     private const string CanonicalXml = """
-        <Step enable="True" id="74" name="Go to Related Record"><Option state="False" /><MatchAllRecords state="False" /><ShowInNewWindow state="False" /><Restore state="True" /><LayoutDestination value="SelectedLayout" /><NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="3606018" /><Table id="5" name="Customers" /><Layout id="10" name="Customer Detail" /><Animation value="None" /></Step>
+        <Step enable="True" id="74" name="Go to Related Record"><Option state="False" /><MatchAllRecords state="False" /><ShowInNewWindow state="False" /><Restore state="True" /><LayoutDestination value="SelectedLayout" /><NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="3606018" /><Table id="5" name="Customers" /><Layout id="10" name="Customer Detail" /></Step>
         """;
 
     [Fact]
diff --git a/tests/SharpFM.Tests/Scripting/Steps/HaltScriptStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/HaltScriptStepTests.cs
index ff2bd73..6da08bc 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/HaltScriptStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/HaltScriptStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Halt Script", out var metadata));
         Assert.Equal(90, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/IfStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/IfStepTests.cs
index 3b2a00b..c6b38ba 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/IfStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/IfStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using SharpFM.Model.Scripting.Values;
 using Xunit;
@@ -8,15 +9,15 @@
 namespace SharpFM.Tests.Scripting.Steps;
 
 /// <summary>
-/// IfStep pilot: calc + block-pair POCO with an intentional
-/// drop of the <c>Restore</c> param per the zero-loss audit
-/// in docs/advanced-filemaker-scripting-syntax.md.
+/// IfStep pilot: calc + block-pair POCO. Per the vendored FileMaker XML skill
+/// (§8.1), the canonical If emits <c>&lt;Restore state="False"/&gt;</c> before
+/// the <c>&lt;Calculation&gt;</c>; SharpFM emits it and canonicalizes inputs
+/// that omit it.
 /// </summary>
 public class IfStepTests
 {
-    // Canonical shape from agentic-fm's snippet — note the
-    // <Restore state="False"/> element that FM Pro itself never emits.
-    private const string AgenticFmSnippet = """
+    // Canonical §8.1 shape — <Restore state="False"/> then <Calculation>.
+    private const string CanonicalSnippet = """
         <?xml version="1.0"?>
         <fmxmlsnippet type="FMObjectList">
           <Step enable="True" id="68" name="If">
@@ -26,8 +27,8 @@ public class IfStepTests
         </fmxmlsnippet>
         """;
 
-    // FM Pro clipboard form — no <Restore> element at all.
-    private const string FmProStyleStep = """
+    // Legacy input form that omitted <Restore>; emission canonicalizes it back in.
+    private const string NoRestoreStep = """
         <Step enable="True" id="68" name="If"><Calculation><![CDATA[$error <> 0]]></Calculation></Step>
         """;
 
@@ -35,25 +36,28 @@ private static XElement StepFromSnippet(string snippet) =>
         XDocument.Parse(snippet).Root!.Element("Step")!;
 
     [Fact]
-    public void RoundTrip_WithRestoreInSource_DropsRestore()
+    public void RoundTrip_WithRestoreInSource_PreservesRestore()
     {
-        // Input has <Restore/>; output must not. This codifies the
-        // intentional drop described in the zero-loss audit.
-        var source = StepFromSnippet(AgenticFmSnippet);
+        var source = StepFromSnippet(CanonicalSnippet);
         var step = IfStep.Metadata.FromXml!(source);
         var output = step.ToXml();
 
-        Assert.Null(output.Element("Restore"));
+        Assert.Equal("False", output.Element("Restore")!.Attribute("state")!.Value);
         Assert.Equal("$error <> 0", output.Element("Calculation")!.Value);
+        // Restore precedes Calculation per canonical order.
+        Assert.Equal(new[] { "Restore", "Calculation" },
+            output.Elements().Select(e => e.Name.LocalName).ToArray());
     }
 
     [Fact]
-    public void RoundTrip_FmProStyle_IsByteIdentical()
+    public void RoundTrip_NoRestoreInput_CanonicalizesByAddingRestore()
     {
-        var source = XElement.Parse(FmProStyleStep);
+        var source = XElement.Parse(NoRestoreStep);
         var step = IfStep.Metadata.FromXml!(source);
+        var output = step.ToXml();
 
-        Assert.True(XNode.DeepEquals(source, step.ToXml()));
+        Assert.Equal("False", output.Element("Restore")!.Attribute("state")!.Value);
+        Assert.Equal("$error <> 0", output.Element("Calculation")!.Value);
     }
 
     [Fact]
@@ -77,11 +81,11 @@ public void Registry_HasIfWithBlockPair()
     }
 
     [Fact]
-    public void Metadata_Params_DescribeCalculation()
+    public void Metadata_Shape_DescribesCalculation()
     {
         var metadata = StepRegistry.ByName["If"];
-        var param = Assert.Single(metadata.Params);
-        Assert.Equal("Calculation", param.XmlElement);
-        Assert.Equal("calculation", param.Type);
+        var param = Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.IsType<BareCalcChild>(param);
+        Assert.Equal("calculation", ShapeHrView.KindOf(param));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/InstallOnTimerScriptStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/InstallOnTimerScriptStepTests.cs
index bcedaa6..d9f74d6 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/InstallOnTimerScriptStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/InstallOnTimerScriptStepTests.cs
@@ -7,8 +7,9 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class InstallOnTimerScriptStepTests
 {
+    // Canonical §8.1 element order: Interval -> Script (was Script -> Interval).
     private const string CanonicalXml = """
-        <Step enable="True" id="148" name="Install OnTimer Script"><Script id="5" name="Refresh" /><Interval><Calculation><![CDATA[30]]></Calculation></Interval></Step>
+        <Step enable="True" id="148" name="Install OnTimer Script"><Interval><Calculation><![CDATA[30]]></Calculation></Interval><Script id="5" name="Refresh" /></Step>
         """;
 
     [Fact]
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ModifyLastFindStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ModifyLastFindStepTests.cs
index 06a2d39..7cbb116 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ModifyLastFindStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ModifyLastFindStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Modify Last Find", out var metadata));
         Assert.Equal(24, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/MoveResizeWindowStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/MoveResizeWindowStepTests.cs
index 0510e60..932216c 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/MoveResizeWindowStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/MoveResizeWindowStepTests.cs
@@ -8,7 +8,7 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class MoveResizeWindowStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="119" name="Move/Resize Window"><Window value="ByName"/><Name><Calculation><![CDATA[$x]]></Calculation></Name><LimitToWindowsOfCurrentFile state="True"/><Height><Calculation><![CDATA[$x]]></Calculation></Height><Width><Calculation><![CDATA[$x]]></Calculation></Width><DistanceFromTop><Calculation><![CDATA[$x]]></Calculation></DistanceFromTop><DistanceFromLeft><Calculation><![CDATA[$x]]></Calculation></DistanceFromLeft></Step>""";
+    private const string CanonicalXml = """<Step enable="True" id="119" name="Move/Resize Window"><LimitToWindowsOfCurrentFile state="True"/><Window value="ByName"/><Name><Calculation><![CDATA[$x]]></Calculation></Name><Height><Calculation><![CDATA[$x]]></Calculation></Height><Width><Calculation><![CDATA[$x]]></Calculation></Width><DistanceFromTop><Calculation><![CDATA[$x]]></Calculation></DistanceFromTop><DistanceFromLeft><Calculation><![CDATA[$x]]></Calculation></DistanceFromLeft></Step>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
diff --git a/tests/SharpFM.Tests/Scripting/Steps/NewFileStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/NewFileStepTests.cs
index 295ac03..bbf2cf2 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/NewFileStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/NewFileStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("New File", out var metadata));
         Assert.Equal(82, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/NewRecordRequestStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/NewRecordRequestStepTests.cs
index 717ece2..50b3718 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/NewRecordRequestStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/NewRecordRequestStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("New Record/Request", out var metadata));
         Assert.Equal(7, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/NewWindowStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/NewWindowStepTests.cs
index 4979cdc..e2f96b1 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/NewWindowStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/NewWindowStepTests.cs
@@ -8,7 +8,11 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class NewWindowStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="122" name="New Window"><LayoutDestination value="SelectedLayout"/><Name><Calculation><![CDATA[$x]]></Calculation></Name><Height><Calculation><![CDATA[$x]]></Calculation></Height><Width><Calculation><![CDATA[$x]]></Calculation></Width><DistanceFromTop><Calculation><![CDATA[$x]]></Calculation></DistanceFromTop><DistanceFromLeft><Calculation><![CDATA[$x]]></Calculation></DistanceFromLeft><NewWndStyles>$example</NewWndStyles></Step>""";
+    // Canonical (skill): LayoutDestination, optional Name, the NewWndStyles
+    // attribute element (NewWindowStyles value type), optional Layout. Was a
+    // mechanically-generated form with a text-bodied <NewWndStyles> and always-
+    // emitted empty dimension elements.
+    private const string CanonicalXml = """<Step enable="True" id="122" name="New Window"><LayoutDestination value="SelectedLayout"/><Name><Calculation><![CDATA["win"]]></Calculation></Name><NewWndStyles Style="Document" Close="Yes" Minimize="Yes" Maximize="Yes" Resize="Yes" Styles="3606018"/><Layout id="5" name="Detail"/></Step>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OmitRecordStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OmitRecordStepTests.cs
index f56680f..f32706d 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OmitRecordStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OmitRecordStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Omit Record", out var metadata));
         Assert.Equal(25, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenEditSavedFindsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenEditSavedFindsStepTests.cs
index 7e307cf..b315bbc 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenEditSavedFindsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenEditSavedFindsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Edit Saved Finds", out var metadata));
         Assert.Equal(149, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenFavoritesStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenFavoritesStepTests.cs
index 996adf7..41eb736 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenFavoritesStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenFavoritesStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Favorites", out var metadata));
         Assert.Equal(183, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenFileOptionsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenFileOptionsStepTests.cs
index 1ad14ca..7c2d07f 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenFileOptionsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenFileOptionsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open File Options", out var metadata));
         Assert.Equal(114, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenFindReplaceStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenFindReplaceStepTests.cs
index ce1a878..60182db 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenFindReplaceStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenFindReplaceStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Find/Replace", out var metadata));
         Assert.Equal(129, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenHelpStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenHelpStepTests.cs
index 7cbef4a..75fa6a2 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenHelpStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenHelpStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Help", out var metadata));
         Assert.Equal(32, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenHostsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenHostsStepTests.cs
index 6333564..dcec789 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenHostsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenHostsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Hosts", out var metadata));
         Assert.Equal(118, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenManageContainersStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenManageContainersStepTests.cs
index f37c840..051aebc 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenManageContainersStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenManageContainersStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Manage Containers", out var metadata));
         Assert.Equal(156, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenManageDataSourcesStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenManageDataSourcesStepTests.cs
index 01472c8..e035947 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenManageDataSourcesStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenManageDataSourcesStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Manage Data Sources", out var metadata));
         Assert.Equal(140, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenManageDatabaseStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenManageDatabaseStepTests.cs
index 8a407a1..d399c66 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenManageDatabaseStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenManageDatabaseStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Manage Database", out var metadata));
         Assert.Equal(38, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenManageLayoutsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenManageLayoutsStepTests.cs
index ec8a830..7d40964 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenManageLayoutsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenManageLayoutsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Manage Layouts", out var metadata));
         Assert.Equal(151, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenManageThemesStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenManageThemesStepTests.cs
index 2e050db..c0bc3ba 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenManageThemesStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenManageThemesStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Manage Themes", out var metadata));
         Assert.Equal(165, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenManageValueListsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenManageValueListsStepTests.cs
index 196c1f8..834cd7e 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenManageValueListsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenManageValueListsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Manage Value Lists", out var metadata));
         Assert.Equal(112, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenPdfStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenPdfStepTests.cs
new file mode 100644
index 0000000..55d9d99
--- /dev/null
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenPdfStepTests.cs
@@ -0,0 +1,32 @@
+using System.Xml.Linq;
+using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Steps;
+using Xunit;
+
+namespace SharpFM.Tests.Scripting.Steps;
+
+public class OpenPdfStepTests
+{
+    private const string MinimalXml =
+        """<Step enable="True" id="246" name="Open PDF"><Option state="False" /><OpenPDFFile><PDFSaveType>File</PDFSaveType></OpenPDFFile></Step>""";
+
+    private const string PathPasswordXml =
+        """<Step enable="True" id="246" name="Open PDF"><Option state="True" /><UniversalPathList>$variable_or_path</UniversalPathList><OpenPDFFile><PDFSaveType>File</PDFSaveType><OpenPassword><Calculation><![CDATA[password expression]]></Calculation></OpenPassword></OpenPDFFile></Step>""";
+
+    [Theory]
+    [InlineData(MinimalXml)]
+    [InlineData(PathPasswordXml)]
+    public void RoundTrip_CanonicalXml_IsPreserved(string canonicalXml)
+    {
+        var source = XElement.Parse(canonicalXml);
+        var step = OpenPdfStep.Metadata.FromXml!(source);
+        Assert.True(XNode.DeepEquals(source, step.ToXml()));
+    }
+
+    [Fact]
+    public void Registry_HasStep()
+    {
+        Assert.True(StepRegistry.ByName.TryGetValue("Open PDF", out var metadata));
+        Assert.Equal(246, metadata!.Id);
+    }
+}
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenRecordRequestStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenRecordRequestStepTests.cs
index 9b3e331..bbb5b83 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenRecordRequestStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenRecordRequestStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Record/Request", out var metadata));
         Assert.Equal(133, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenScriptWorkspaceStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenScriptWorkspaceStepTests.cs
index 5962617..893fafa 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenScriptWorkspaceStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenScriptWorkspaceStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Script Workspace", out var metadata));
         Assert.Equal(88, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenSettingsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenSettingsStepTests.cs
index 3191afe..e50c32b 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenSettingsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenSettingsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Settings", out var metadata));
         Assert.Equal(105, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenSharingStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenSharingStepTests.cs
index 86c55eb..af48ae8 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenSharingStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenSharingStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Sharing", out var metadata));
         Assert.Equal(113, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenTransactionStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenTransactionStepTests.cs
index ca9acf8..ab00183 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenTransactionStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenTransactionStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -8,11 +9,10 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class OpenTransactionStepTests
 {
-    // Restore is intentionally dropped per the zero-loss audit — it's
-    // semantically fixed and carries no information. Test fixture omits
-    // it so round-trip is byte-identical against what our POCO emits.
+    // Canonical order is Option, ESSForceCommit, SkipAutoEntry, Restore;
+    // the Restore flag is part of the canonical form and round-trips.
     private const string CanonicalXml = """
-        <Step enable="True" id="205" name="Open Transaction"><SkipAutoEntry state="True"/><Option state="True"/><ESSForceCommit state="True"/></Step>
+        <Step enable="True" id="205" name="Open Transaction"><Option state="True"/><ESSForceCommit state="True"/><SkipAutoEntry state="True"/><Restore state="False"/></Step>
         """;
 
     [Fact]
@@ -39,15 +39,16 @@ public void Display_RoundTripsThroughFromDisplayParams()
     }
 
     [Fact]
-    public void RestoreElement_InSource_IsIntentionallyDropped()
+    public void RestoreElement_IsPartOfCanonicalForm_AndRoundTrips()
     {
-        // Upstream agentic-fm snippets include <Restore state="False"/>,
-        // which we drop on both read and write.
+        // The canonical form emits <Restore> in the trailing position; it
+        // round-trips on both read and write.
         var withRestore = XElement.Parse("""
-            <Step enable="True" id="205" name="Open Transaction"><SkipAutoEntry state="False"/><Option state="False"/><ESSForceCommit state="False"/><Restore state="False"/></Step>
+            <Step enable="True" id="205" name="Open Transaction"><Option state="False"/><ESSForceCommit state="False"/><SkipAutoEntry state="False"/><Restore state="False"/></Step>
             """);
         var step = OpenTransactionStep.Metadata.FromXml!(withRestore);
-        Assert.Null(step.ToXml().Element("Restore"));
+        Assert.NotNull(step.ToXml().Element("Restore"));
+        Assert.True(XNode.DeepEquals(withRestore, step.ToXml()));
     }
 
     [Fact]
@@ -55,6 +56,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Transaction", out var metadata));
         Assert.Equal(205, metadata!.Id);
-        Assert.Equal(3, metadata.Params.Count);
+        Assert.Equal(3, ShapeHrView.HrNodes(metadata.Shape).Count);
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/OpenUploadToHostStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/OpenUploadToHostStepTests.cs
index fd58d08..5400883 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/OpenUploadToHostStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/OpenUploadToHostStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Open Upload to Host", out var metadata));
         Assert.Equal(172, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/PasteStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/PasteStepTests.cs
index 3344387..5339deb 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/PasteStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/PasteStepTests.cs
@@ -8,7 +8,8 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class PasteStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="48" name="Paste"><SelectAll state="False"/><NoStyle state="False"/><LinkAvail state="False"/><Field table="Invoices" id="12" name="Status"/></Step>""";
+    // Canonical (skill) bool order: NoStyle, SelectAll, LinkAvail (was SelectAll first).
+    private const string CanonicalXml = """<Step enable="True" id="48" name="Paste"><NoStyle state="False"/><SelectAll state="False"/><LinkAvail state="False"/><Field table="Invoices" id="12" name="Status"/></Step>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
diff --git a/tests/SharpFM.Tests/Scripting/Steps/RefreshWindowStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/RefreshWindowStepTests.cs
index aa80b7a..d948e17 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/RefreshWindowStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/RefreshWindowStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -39,6 +40,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Refresh Window", out var metadata));
         Assert.Equal(80, metadata!.Id);
-        Assert.Equal(2, metadata.Params.Count);
+        Assert.Equal(2, ShapeHrView.HrNodes(metadata.Shape).Count);
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ReplaceFieldContentsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ReplaceFieldContentsStepTests.cs
index 3d9f04d..c84bd55 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ReplaceFieldContentsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ReplaceFieldContentsStepTests.cs
@@ -7,13 +7,14 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class ReplaceFieldContentsStepTests
 {
+    // Canonical (skill): NoInteract, Restore, With, then the optional payload and
+    // target Field; <SerialNumbers> carries increment/InitialValue.
     private const string CanonicalXml = """
-        <Step enable="True" id="91" name="Replace Field Contents"><NoInteract state="True" /><With value="Calculation" /><Calculation><![CDATA["value"]]></Calculation><SerialNumbers PerformAutoEnter="True" UpdateEntryOptions="False" UseEntryOptions="True" /><Field table="Customer" id="3" name="id" /></Step>
+        <Step enable="True" id="91" name="Replace Field Contents"><NoInteract state="True" /><Restore state="False" /><With value="Calculation" /><Calculation><![CDATA["value"]]></Calculation><SerialNumbers PerformAutoEnter="True" UpdateEntryOptions="False" increment="0" InitialValue="" UseEntryOptions="True" /><Field table="Customer" id="3" name="id" /></Step>
         """;
 
-    // Source with Restore element (as from agentic-fm snippets) — our POCO drops it.
     private const string WithRestoreXml = """
-        <Step enable="True" id="91" name="Replace Field Contents"><NoInteract state="True" /><Restore state="True" /><With value="Calculation" /><Calculation><![CDATA["value"]]></Calculation><SerialNumbers PerformAutoEnter="True" UpdateEntryOptions="False" UseEntryOptions="True" /><Field table="Customer" id="3" name="id" /></Step>
+        <Step enable="True" id="91" name="Replace Field Contents"><NoInteract state="True" /><Restore state="True" /><With value="Calculation" /><Calculation><![CDATA["value"]]></Calculation><Field table="Customer" id="3" name="id" /></Step>
         """;
 
     [Fact]
@@ -25,12 +26,13 @@ public void RoundTrip_CanonicalXml_IsPreserved()
     }
 
     [Fact]
-    public void RestoreElement_IsDropped()
+    public void RestoreElement_IsPreserved()
     {
+        // Canonical form emits <Restore> (skill); earlier revisions dropped it.
         var source = XElement.Parse(WithRestoreXml);
         var step = ReplaceFieldContentsStep.Metadata.FromXml!(source);
         var output = step.ToXml();
-        Assert.Null(output.Element("Restore"));
+        Assert.Equal("True", output.Element("Restore")!.Attribute("state")!.Value);
     }
 
     [Fact]
diff --git a/tests/SharpFM.Tests/Scripting/Steps/RevertRecordRequestStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/RevertRecordRequestStepTests.cs
index 865233d..cf01c5e 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/RevertRecordRequestStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/RevertRecordRequestStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Revert Record/Request", out var metadata));
         Assert.Equal(51, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SaveACopyAsXMLStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SaveACopyAsXMLStepTests.cs
index cb12f48..0318ba0 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SaveACopyAsXMLStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SaveACopyAsXMLStepTests.cs
@@ -8,7 +8,10 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class SaveACopyAsXMLStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="3" name="Save a Copy as XML"><Option state="True"/><UniversalPathList>$example</UniversalPathList><Calculation><![CDATA[$x]]></Calculation></Step>""";
+    // Canonical (skill): the pre-FM 26 form is just <Option>; the FM 26 export
+    // options (OutputEntireBinaryData / SpecifyJSONOptions / SaXML) are covered
+    // by the canonical-skill fixture suite (003-SaveACopyAsXML-2).
+    private const string CanonicalXml = """<Step enable="True" id="3" name="Save a Copy as XML"><Option state="True"/></Step>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SaveRecordsAsExcelStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SaveRecordsAsExcelStepTests.cs
index f27a079..30f541d 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SaveRecordsAsExcelStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SaveRecordsAsExcelStepTests.cs
@@ -7,8 +7,11 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class SaveRecordsAsExcelStepTests
 {
+    // Canonical (skill): the default-valued <Profile> is omitted (emitted only
+    // when the export format is customized); the path and doc-metadata calcs
+    // remain when set.
     private const string CanonicalXml = """
-        <Step enable="True" id="143" name="Save Records as Excel"><NoInteract state="True" /><CreateDirectories state="True" /><Restore state="True" /><AutoOpen state="False" /><CreateEmail state="False" /><Profile FieldDelimiter="&#9;" IsPredefined="-1" FieldNameRow="-1" DataType="XLXE" /><UniversalPathList>$path</UniversalPathList><WorkSheet><Calculation><![CDATA["Sheet1"]]></Calculation></WorkSheet><Title><Calculation><![CDATA["title"]]></Calculation></Title><Subject><Calculation><![CDATA["subject"]]></Calculation></Subject><Author><Calculation><![CDATA["author"]]></Calculation></Author><SaveType value="BrowsedRecords" /><UseFieldNames state="False" /></Step>
+        <Step enable="True" id="143" name="Save Records as Excel"><NoInteract state="True" /><CreateDirectories state="True" /><Restore state="True" /><AutoOpen state="False" /><CreateEmail state="False" /><UniversalPathList>$path</UniversalPathList><WorkSheet><Calculation><![CDATA["Sheet1"]]></Calculation></WorkSheet><Title><Calculation><![CDATA["title"]]></Calculation></Title><Subject><Calculation><![CDATA["subject"]]></Calculation></Subject><Author><Calculation><![CDATA["author"]]></Calculation></Author><SaveType value="BrowsedRecords" /><UseFieldNames state="False" /></Step>
         """;
 
     [Fact]
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SaveRecordsAsPdfStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SaveRecordsAsPdfStepTests.cs
index c741012..c72eda9 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SaveRecordsAsPdfStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SaveRecordsAsPdfStepTests.cs
@@ -8,7 +8,7 @@ namespace SharpFM.Tests.Scripting.Steps;
 public class SaveRecordsAsPdfStepTests
 {
     private const string CanonicalXml = """
-        <Step enable="True" id="144" name="Save Records as PDF"><NoInteract state="True" /><Option state="False" /><CreateDirectories state="True" /><Restore state="True" /><AutoOpen state="False" /><CreateEmail state="False" /><UniversalPathList>$output</UniversalPathList><Calculation><![CDATA["title"]]></Calculation><PDFOptions source="RecordsBeingBrowsed"><Document><Title><Calculation><![CDATA["title"]]></Calculation></Title><Subject><Calculation><![CDATA["subject"]]></Calculation></Subject><Author><Calculation><![CDATA["author"]]></Calculation></Author><Keywords><Calculation><![CDATA["keywords"]]></Calculation></Keywords><Pages AllPages="True"><NumberFrom><Calculation><![CDATA[1]]></Calculation></NumberFrom></Pages></Document><Security allowScreenReader="True" enableCopying="True" controlEditing="AnyExceptExtractingPages" controlPrinting="HighResolution" requireControlEditPassword="False" requireOpenPassword="False" /><View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage" /></PDFOptions></Step>
+        <Step enable="True" id="144" name="Save Records as PDF"><NoInteract state="True" /><Option state="False" /><CreateDirectories state="True" /><Restore state="True" /><AutoOpen state="False" /><CreateEmail state="False" /><UniversalPathList>$output</UniversalPathList><Calculation><![CDATA["title"]]></Calculation><PDFOptions source="RecordsBeingBrowsed"><PDFSaveType>File</PDFSaveType><Document><Title><Calculation><![CDATA["title"]]></Calculation></Title><Subject><Calculation><![CDATA["subject"]]></Calculation></Subject><Author><Calculation><![CDATA["author"]]></Calculation></Author><Keywords><Calculation><![CDATA["keywords"]]></Calculation></Keywords><Pages AllPages="True"><NumberFrom><Calculation><![CDATA[1]]></Calculation></NumberFrom></Pages></Document><Security allowScreenReader="True" enableCopying="True" controlEditing="AnyExceptExtractingPages" controlPrinting="HighResolution" requireControlEditPassword="False" requireOpenPassword="False" /><View magnification="100" pageLayout="SinglePage" show="PagesPanelAndPage" /></PDFOptions></Step>
         """;
 
     [Fact]
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ScrollWindowStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ScrollWindowStepTests.cs
index 4648b56..26df0e1 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ScrollWindowStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ScrollWindowStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -37,7 +38,7 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Scroll Window", out var metadata));
         Assert.Equal(81, metadata!.Id);
-        Assert.Single(metadata.Params);
-        Assert.Equal("enum", metadata.Params[0].Type);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.Equal("enum", ShapeHrView.KindOf(ShapeHrView.HrNodes(metadata.Shape)[0]));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SelectAllStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SelectAllStepTests.cs
index 3bb0699..5ca1a0d 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SelectAllStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SelectAllStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Select All", out var metadata));
         Assert.Equal(50, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SelectDictionariesStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SelectDictionariesStepTests.cs
index 7893027..61cf74c 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SelectDictionariesStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SelectDictionariesStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Select Dictionaries", out var metadata));
         Assert.Equal(108, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SendDDEExecuteStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SendDDEExecuteStepTests.cs
index 15b104e..30fa683 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SendDDEExecuteStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SendDDEExecuteStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -37,7 +38,7 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Send DDE Execute", out var metadata));
         Assert.Equal(64, metadata!.Id);
-        Assert.Single(metadata.Params);
-        Assert.Equal("enum", metadata.Params[0].Type);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.Equal("enum", ShapeHrView.KindOf(ShapeHrView.HrNodes(metadata.Shape)[0]));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SendEventStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SendEventStepTests.cs
index 138818b..0114635 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SendEventStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SendEventStepTests.cs
@@ -7,8 +7,10 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class SendEventStepTests
 {
+    // Canonical (skill): no empty <Text/> element; <Event> carries only its
+    // populated attributes.
     private const string CanonicalXml = """
-        <Step enable="True" id="57" name="Send Event"><ContentType value="Text" /><Text /><Event CopyResultToClipboard="False" WaitForCompletion="True" BringTargetToForeground="False" TargetType="NUTD" TargetName="&lt;unknown&gt;" id="dosc" class="misc" /></Step>
+        <Step enable="True" id="57" name="Send Event"><ContentType value="Text" /><Event CopyResultToClipboard="False" WaitForCompletion="True" BringTargetToForeground="False" TargetType="NUTD" TargetName="&lt;unknown&gt;" id="dosc" class="misc" /></Step>
         """;
 
     [Fact]
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SetErrorCaptureStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SetErrorCaptureStepTests.cs
index de72e87..96bd615 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SetErrorCaptureStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SetErrorCaptureStepTests.cs
@@ -2,6 +2,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -84,10 +85,11 @@ public void Registry_HasSetErrorCaptureWithParam()
         Assert.Equal("control", metadata.Category);
         Assert.Null(metadata.BlockPair);
 
-        var param = Assert.Single(metadata.Params);
-        Assert.Equal("Set", param.XmlElement);
-        Assert.Equal("boolean", param.Type);
-        Assert.Equal("state", param.XmlAttr);
+        var param = Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        var state = Assert.IsType<BoolStateChild>(param);
+        Assert.Equal("Set", state.Element);
+        Assert.Equal("state", state.Attr);
+        Assert.Equal("boolean", ShapeHrView.KindOf(param));
 
         // Description is sourced from agentic-fm's snippet comment
         // and powers tooltip / hover UIs as they're wired up later.
@@ -99,7 +101,7 @@ public void Registry_HasSetErrorCaptureWithParam()
     public void GetValidValues_ReturnsOnAndOff()
     {
         var metadata = StepRegistry.ByName["Set Error Capture"];
-        var values = StepRegistry.GetValidValues(metadata.Params[0]);
+        var values = ShapeHrView.DisplayValuesOf(ShapeHrView.HrNodes(metadata.Shape)[0]);
         Assert.Contains("On", values);
         Assert.Contains("Off", values);
     }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SetLayoutObjectAnimationStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SetLayoutObjectAnimationStepTests.cs
index 7275873..1762daf 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SetLayoutObjectAnimationStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SetLayoutObjectAnimationStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Set Layout Object Animation", out var metadata));
         Assert.Equal(168, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SetMultiUserStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SetMultiUserStepTests.cs
index b475687..73c1587 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SetMultiUserStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SetMultiUserStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -37,7 +38,7 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Set Multi-User", out var metadata));
         Assert.Equal(84, metadata!.Id);
-        Assert.Single(metadata.Params);
-        Assert.Equal("enum", metadata.Params[0].Type);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.Equal("enum", ShapeHrView.KindOf(ShapeHrView.HrNodes(metadata.Shape)[0]));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SetRevertTransactionOnErrorStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SetRevertTransactionOnErrorStepTests.cs
index 598456e..a147520 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SetRevertTransactionOnErrorStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SetRevertTransactionOnErrorStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Set Revert Transaction on Error", out var metadata));
         Assert.Equal(223, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SetUseSystemFormatsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SetUseSystemFormatsStepTests.cs
index c5fa0ea..21b6be9 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SetUseSystemFormatsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SetUseSystemFormatsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -44,6 +45,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Set Use System Formats", out var metadata));
         Assert.Equal(94, metadata!.Id);
-        Assert.Single(metadata.Params);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SetWebViewerStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SetWebViewerStepTests.cs
index 4a13272..99783dc 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SetWebViewerStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SetWebViewerStepTests.cs
@@ -8,7 +8,9 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class SetWebViewerStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="146" name="Set Web Viewer"><ObjectName><Calculation><![CDATA[$x]]></Calculation></ObjectName><Action value="GoToURL"/><URL><Calculation><![CDATA[$x]]></Calculation></URL></Step>""";
+    // Canonical (skill): Action first, then optional ObjectName and URL; <URL>
+    // carries a custom flag attribute.
+    private const string CanonicalXml = """<Step enable="True" id="146" name="Set Web Viewer"><Action value="GoToURL"/><ObjectName><Calculation><![CDATA[$x]]></Calculation></ObjectName><URL custom="False"><Calculation><![CDATA[$x]]></Calculation></URL></Step>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SetWindowTitleStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SetWindowTitleStepTests.cs
index 81c5ebd..6e81e49 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SetWindowTitleStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SetWindowTitleStepTests.cs
@@ -8,7 +8,7 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class SetWindowTitleStepTests
 {
-    private const string CanonicalXml = """<Step enable="True" id="124" name="Set Window Title"><Window value="Current"/><Name><Calculation><![CDATA[$x]]></Calculation></Name><LimitToWindowsOfCurrentFile state="True"/><NewName><Calculation><![CDATA[$x]]></Calculation></NewName></Step>""";
+    private const string CanonicalXml = """<Step enable="True" id="124" name="Set Window Title"><LimitToWindowsOfCurrentFile state="True"/><Window value="Current"/><Name><Calculation><![CDATA[$x]]></Calculation></Name><NewName><Calculation><![CDATA[$x]]></Calculation></NewName></Step>""";
 
     [Fact]
     public void RoundTrip_CanonicalXml_IsPreserved()
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SetZoomLevelStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SetZoomLevelStepTests.cs
index 7725b3a..a461611 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SetZoomLevelStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SetZoomLevelStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -39,6 +40,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Set Zoom Level", out var metadata));
         Assert.Equal(97, metadata!.Id);
-        Assert.Equal(2, metadata.Params.Count);
+        Assert.Equal(2, ShapeHrView.HrNodes(metadata.Shape).Count);
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ShowAllRecordsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ShowAllRecordsStepTests.cs
index 548487a..0d204a7 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ShowAllRecordsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ShowAllRecordsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Show All Records", out var metadata));
         Assert.Equal(23, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ShowHideMenubarStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ShowHideMenubarStepTests.cs
index ba31e28..376c66a 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ShowHideMenubarStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ShowHideMenubarStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -39,6 +40,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Show/Hide Menubar", out var metadata));
         Assert.Equal(166, metadata!.Id);
-        Assert.Equal(2, metadata.Params.Count);
+        Assert.Equal(2, ShapeHrView.HrNodes(metadata.Shape).Count);
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ShowHideTextRulerStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ShowHideTextRulerStepTests.cs
index c5694b7..6bd36c5 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ShowHideTextRulerStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ShowHideTextRulerStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -37,7 +38,7 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Show/Hide Text Ruler", out var metadata));
         Assert.Equal(92, metadata!.Id);
-        Assert.Single(metadata.Params);
-        Assert.Equal("enum", metadata.Params[0].Type);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.Equal("enum", ShapeHrView.KindOf(ShapeHrView.HrNodes(metadata.Shape)[0]));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ShowHideToolbarsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ShowHideToolbarsStepTests.cs
index 881d90d..394ed7f 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ShowHideToolbarsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ShowHideToolbarsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -39,6 +40,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Show/Hide Toolbars", out var metadata));
         Assert.Equal(29, metadata!.Id);
-        Assert.Equal(3, metadata.Params.Count);
+        Assert.Equal(3, ShapeHrView.HrNodes(metadata.Shape).Count);
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ShowOmittedOnlyStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ShowOmittedOnlyStepTests.cs
index 2940ec1..af51427 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ShowOmittedOnlyStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ShowOmittedOnlyStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Show Omitted Only", out var metadata));
         Assert.Equal(27, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/SpellingOptionsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/SpellingOptionsStepTests.cs
index 79d2dc1..e3d0091 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/SpellingOptionsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/SpellingOptionsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Spelling Options", out var metadata));
         Assert.Equal(107, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/TriggerClarisConnectFlowStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/TriggerClarisConnectFlowStepTests.cs
index 6786290..f9b7a46 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/TriggerClarisConnectFlowStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/TriggerClarisConnectFlowStepTests.cs
@@ -7,10 +7,9 @@ namespace SharpFM.Tests.Scripting.Steps;
 
 public class TriggerClarisConnectFlowStepTests
 {
-    // The catalog records this step with id: null (unconfirmed). We default
-    // to 0 but preserve whatever id appears in the source XML.
+    // Canonical step id is 211 (skill, control reference); was defaulted to 0.
     private const string CanonicalXml = """
-        <Step enable="True" id="0" name="Trigger Claris Connect Flow"><NoInteract state="True" /><DontEncodeURL state="False" /><SelectAll state="True" /><VerifySSLCertificates state="False" /><Flow>https://flow.example.com</Flow><CURLOptions><Calculation><![CDATA["--request POST"]]></Calculation></CURLOptions><Text>$response</Text></Step>
+        <Step enable="True" id="211" name="Trigger Claris Connect Flow"><NoInteract state="True" /><DontEncodeURL state="False" /><SelectAll state="True" /><VerifySSLCertificates state="False" /><Flow>https://flow.example.com</Flow><CURLOptions><Calculation><![CDATA["--request POST"]]></Calculation></CURLOptions><Text>$response</Text></Step>
         """;
 
     [Fact]
diff --git a/tests/SharpFM.Tests/Scripting/Steps/UndoRedoStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/UndoRedoStepTests.cs
index 2aea994..fb4f450 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/UndoRedoStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/UndoRedoStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -37,7 +38,7 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Undo/Redo", out var metadata));
         Assert.Equal(45, metadata!.Id);
-        Assert.Single(metadata.Params);
-        Assert.Equal("enum", metadata.Params[0].Type);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.Equal("enum", ShapeHrView.KindOf(ShapeHrView.HrNodes(metadata.Shape)[0]));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/UnsortRecordsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/UnsortRecordsStepTests.cs
index 442b7cd..8a4456e 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/UnsortRecordsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/UnsortRecordsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -46,6 +47,6 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("Unsort Records", out var metadata));
         Assert.Equal(21, metadata!.Id);
-        Assert.Empty(metadata.Params);
+        Assert.Empty(ShapeHrView.HrNodes(metadata.Shape));
     }
 }
diff --git a/tests/SharpFM.Tests/Scripting/Steps/ViewAsStepTests.cs b/tests/SharpFM.Tests/Scripting/Steps/ViewAsStepTests.cs
index 50ea730..8c5b01e 100644
--- a/tests/SharpFM.Tests/Scripting/Steps/ViewAsStepTests.cs
+++ b/tests/SharpFM.Tests/Scripting/Steps/ViewAsStepTests.cs
@@ -1,6 +1,7 @@
 using System.Xml.Linq;
 using SharpFM.Model.Scripting;
 using SharpFM.Model.Scripting.Registry;
+using SharpFM.Model.Scripting.Shapes;
 using SharpFM.Model.Scripting.Steps;
 using Xunit;
 
@@ -37,7 +38,7 @@ public void Registry_HasStep()
     {
         Assert.True(StepRegistry.ByName.TryGetValue("View As", out var metadata));
         Assert.Equal(30, metadata!.Id);
-        Assert.Single(metadata.Params);
-        Assert.Equal("enum", metadata.Params[0].Type);
+        Assert.Single(ShapeHrView.HrNodes(metadata.Shape));
+        Assert.Equal("enum", ShapeHrView.KindOf(ShapeHrView.HrNodes(metadata.Shape)[0]));
     }
 }
diff --git a/tests/SharpFM.Tests/SharpFM.Tests.csproj b/tests/SharpFM.Tests/SharpFM.Tests.csproj
index 4062e31..8e363f2 100644
--- a/tests/SharpFM.Tests/SharpFM.Tests.csproj
+++ b/tests/SharpFM.Tests/SharpFM.Tests.csproj
@@ -26,4 +26,11 @@
     <ProjectReference Include="..\..\src\SharpFM\SharpFM.csproj" />
   </ItemGroup>
 
+  <!-- Canonical-skill round-trip fixtures: generated from the vendored skill
+       markdown (see docs/filemaker-xml-canonical). Copied next to the test
+       assembly so the round-trip suite can read them at run time. -->
+  <ItemGroup>
+    <None Include="CanonicalSkill\fixtures\**\*.xml" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
 </Project>