LT-22802: Apply a tool's slice filter list in the Avalonia detail view (#1146)

* test: pin the relevance rule with the most rows riding on it

Raised by Jason on #1135, after the merge. MoStemMsa.IsFieldRelevant withholds
FromPartsOfSpeech ("Attaches to Categories") unless the owning entry has a
proclitic or enclitic, and Morphology.fwlayout:39 declares that part
visibility="always" -- so before the relevance gate the row composed on every
stem MSA, and now it disappears for every entry without a clitic. That is the
gate's most visible consequence and nothing pinned it.

The test is Jason's, run and confirmed to bite: suppressing the gate fails its
negative half with "Expected: False, But was: True", while the positive control
-- add a proclitic allomorph, change nothing else -- keeps passing.

Also corrects two comments that claimed more than the code does. The composer
implements the SECOND of SliceFilter.IncludeSlice's two gates; the first looks
the slice id up in the tool's filter list, and the id never reaches the
composer, so that half is LT-22802. The fixture summary said it covered the
remainder of the overrides, which was untrue while this test was missing, and
still excludes the InflectionClass limb that withholds the row from a compound
rule's left/right MSA.

xWorksTests filter Avalonia 1642 passed, 0 failed.

* LT-22802: Apply a tool's slice filter list in the Avalonia detail view

Legacy SliceFilter.IncludeSlice has two gates: look the slice's authored id up
in the filter list the tool's filterPath names and withhold the row when it is
listed, then ask IsFieldRelevant. LT-22672 added the second. This adds the
first.

The id was discarded at import, so three pieces:

- XmlLayoutImporter carries the slice's id onto ViewNode.SliceId, and id leaves
  the unhandled-attribute report.
- DetailComposer.Walk withholds a node whose SliceId the tool lists, checked
  before the node kind is dispatched so a withheld node takes its subtree with
  it -- where legacy checks it, at the top of ProcessSubpartNode.
- RecordEditView reads filterPath from its own configuration and parses the
  same file into the id set, memoized per view. A tool with no filterPath, or
  a file that cannot be read, filters nothing: an extra row beats a view that
  will not open.

NOTHING VISIBLE CHANGES TODAY, and the ticket's symptom section overstates it.
The only shipped filter entries that still resolve to a real slice are the five
CmPossibility ids in basicPlusFilter.xml, and the only tool they reach is
Exception "Features" (ProdRestrictEdit) -- which is not in the Avalonia tool
catalog, so it renders legacy even under UIMode=New. The other 27 ids across
the six filter files name nodes that no longer exist. Category Edit is in the
catalog and carries the same filterPath, but its layout reaches none of those
ids.

So this is parity landed before it is needed: the day ProdRestrictEdit joins
LexiconFeatureCatalog, the view already withholds what legacy withholds instead
of growing five rows nobody looks for.

Tested at the mechanism, not the wiring. Suppressing the composer gate fails
the filter tests with the full row list -- Name, Abbreviation, Description,
Status, Discussion, Confidence, Researchers, Restrictions -- and the importer
tests pin the id. Reading filterPath in RecordEditView has NO test and cannot
be checked in the app while the tool renders legacy; it becomes verifiable, by
Jason's acceptance steps, when that tool is activated.

FwAvaloniaTests 751 passed, xWorksTests filter Avalonia 1645 passed, 0 failed.

* LT-22802: Cover the step that reads a tool's filter list

The filter-list read was the one part with no test, and the part that could
quietly make the whole feature a no-op: every other test in this area supplies
the id set by hand, so a broken read leaves them all green.

Demonstrated rather than assumed. Pointing the XPath at the wrong element name
fails only the new test; the three composer tests still pass.

The read moves to an internal static taking the tool's configuration node, so
it is reachable without a mediator or property table -- the same way the
reference-vector menu entry points are tested. The property keeps only its
memoization.

One test drives the whole chain against a shipped filter file: the attribute
name, the path resolution, the XPath and the id attribute. It asserts the ids
are PRESENT rather than exhaustive, so editing that file leaves it alone while
breaking any link in the chain does not.

xWorksTests filter Avalonia 1650 passed, 0 failed.

* Merge remote-tracking branch 'origin/main' into LT-22802-slice-filter-lists

ViewNode gained an optional parameter on each side -- sliceId here, and
helpTopicId on main -- with the same conflict at its one call site in
the importer. Both are kept; they are independent.

* Merge remote-tracking branch 'origin/main' into LT-22802-slice-filter-lists

Main now has #1145, which this branch also carried as its first commit.
Squash-merging gave it a different identity, so both files it touched
conflicted with that commit's own later edits there.

Resolved toward main, whose comments had been corrected, with one
change: the relevance doc named LT-22802 as covering the other gate.
This branch is that gate, so the doc now points at IsFilteredOutByTool,
in the same class. The fixture summary keeps its pointer to
DetailSliceFilterTests, where that gate is tested.

* LT-22802: Rejoin a doc line the comment wrapper split

The comment-hygiene wrapper broke the new pointer to IsFilteredOutByTool
so that one word sat alone on the last line. Reflowed.

Comments only.

* Merge remote-tracking branch 'origin/main' into LT-22802-slice-filter-lists

* LT-22802: Stop an override from shifting a node's help topic and id

sliceId was inserted ahead of helpTopicId in ViewNode's constructor,
when resolving a merge conflict between the two. Both override clone
helpers pass that tail positionally, and both parameters are strings,
so n.HelpTopicId bound to sliceId and helpTopicId fell back to null --
with no warning. Any layout with a Field Visibility or Move Field
override lost every authored help topic, and each of its rows took the
help id as its slice id.

The helpers also never carried SliceId at all. Moving the parameter
back alone would have restored help topics and left SliceId null
after every override, so a tool's filter list would stop withholding
rows in exactly the layouts users have customised.

sliceId goes last again, and both helpers name the tail and pass both
fields, so a parameter added ahead of them cannot shift either one.

The existing test for fields an override must preserve now covers both,
and a duplicated node is checked for them too. Rebuilding the merged
code fails both tests exactly as reported: help topic null, slice id
the help id. Dropping only the SliceId carry fails them on SliceId.

Reported in review.

* LT-22802: Carry a node's slice id through the canonical JSON

The serializer wrote and read helpTopicID but had no slice id, so a
layout loaded from canonical JSON would lose the id a tool's filter
list names. No shipped path loads JSON today; this keeps that path
from springing the same trap if it is enabled.

Written as "sliceId", not "id": "id" is already the stable id's key,
and sharing it would overwrite every node's stable id on the way out.

The round-trip test that sets every property now sets helpTopicId and
sliceId, which it had not been covering, and checks the two ids stay
apart. Dropping the write fails it on SliceId.

* LT-22802: Test that a tool's filter list reaches the composer

The file reader and the composer's gate were each tested, but not the
join between them: deleting the view's hiddenSliceIds argument left
the whole suite green. No shipped tool reaches a live filter id today,
so nothing else would have noticed.

The view's composition moves out of ShowAvaloniaEntry into
ComposeDetail, unchanged, so a test can reach it without the settle,
adapter and message work around it.

The test installs the shipped ProdRestrictEdit configuration, whose
filter list is basicPlusFilter.xml, and composes a production
restriction through the view. The same view with the filterPath removed
is the control, and shows the Status row. Removing the argument fails
the test, with Status among the composed rows.

Reported in review.

* LT-22802: Put each summary back on the member it describes

Extracting ComposeDetail left it under ShowAvaloniaEntry's summary as
well as its own, and ShowAvaloniaEntry with none. That summary is back
on its method.

The memoized filter list caches a failed read too, which reads like an
oversight; the comment now says it is deliberate, since a missing
filter file is an install fault and re-reading it would log the same
failure for every record shown.

The reading tests' summary argued for their own existence, and its
claim that every other test supplies the id set by hand stopped being
true with the wiring test. It now says what the fixture reads.

Reported in review. Comments only.

Co-Authored-By: Zachary Burnham <zachary_burnham@sil.org>
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: 3 people

Src/Common/FwAvalonia/FwAvaloniaTests/CanonicalJsonTests.cs

@@ -111,7 +111,9 @@ public void EveryViewNodeProperty_SurvivesRoundTrip()
 				{
 					new ViewChooserLink("goto", "Edit the Publications list", "publicationsEdit"),
 					new ViewChooserLink("simple", "Add a slot", "MakeInflAffixSlotChooserCommand", "TopPOS")
-				});
+				},
+				helpTopicId: "khtpField-LexEntry-Senses",
+				sliceId: "CmPossibilityStatus");
 			var model = new ViewDefinitionModel("LexEntry", "Normal", "detail",
 				new List<ViewNode> { node }, new List<ViewDiagnostic>());
 
@@ -172,6 +174,10 @@ public void EveryViewNodeProperty_SurvivesRoundTrip()
 				Assert.That(r.ChooserLinks[0].Target, Is.Null, "ChooserLinks[0].Target");
 				Assert.That(r.ChooserLinks[1].Type, Is.EqualTo("simple"), "ChooserLinks[1].Type");
 				Assert.That(r.ChooserLinks[1].Target, Is.EqualTo("TopPOS"), "ChooserLinks[1].Target");
+				Assert.That(r.HelpTopicId, Is.EqualTo("khtpField-LexEntry-Senses"), nameof(r.HelpTopicId));
+				Assert.That(r.SliceId, Is.EqualTo("CmPossibilityStatus"), nameof(r.SliceId));
+				Assert.That(r.StableId, Is.Not.EqualTo(r.SliceId),
+					"both are written as ids, and one must not overwrite the other");
 			});
 		}
 	}

Src/Common/FwAvalonia/FwAvaloniaTests/SliceIdImportTests.cs

@@ -0,0 +1,84 @@
+// Copyright (c) 2026 SIL International
+// This software is licensed under the LGPL, version 2.1 or later
+// (http://www.gnu.org/licenses/lgpl-2.1.html)
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using NUnit.Framework;
+using SIL.FieldWorks.Common.FwAvalonia.ViewDefinition;
+
+namespace FwAvaloniaTests
+{
+	/// <summary>
+	/// A slice's authored <c>id=</c> is the name a tool's filter list uses to withhold the row.
+	/// It has to survive import, or the composer has nothing to match a filter against
+	/// (LT-22802).
+	/// </summary>
+	[TestFixture]
+	public class SliceIdImportTests
+	{
+		private const string PartsXml = @"
+<PartInventory><bin>
+  <part id='CmPossibility-Detail-Status'>
+    <slice id='CmPossibilityStatus' label='Status' editor='string' field='Status'/>
+  </part>
+  <part id='CmPossibility-Detail-Name'>
+    <slice label='Name' editor='string' field='Name'/>
+  </part>
+</bin></PartInventory>";
+
+		private static ViewDefinitionModel Import(string layoutXml)
+		{
+			var parts = new DictionaryPartResolver(XElement.Parse(PartsXml));
+			return new XmlLayoutImporter().Import(XElement.Parse(layoutXml), parts);
+		}
+
+		private static IEnumerable<ViewNode> Flatten(ViewNode n)
+		{
+			yield return n;
+			foreach (var c in n.Children)
+				foreach (var d in Flatten(c))
+					yield return d;
+		}
+
+		private static ViewDefinitionModel BothRows() => Import(@"
+<layout class='CmPossibility' type='detail' name='default'>
+  <part ref='Status'/>
+  <part ref='Name'/>
+</layout>");
+
+		[Test]
+		public void Slice_WithAnId_CarriesItOntoTheNode()
+		{
+			var nodes = BothRows().Roots.SelectMany(Flatten).ToList();
+
+			Assert.That(nodes.Select(n => n.SliceId), Does.Contain("CmPossibilityStatus"),
+				"the filter list names rows by this id; dropping it at import leaves the "
+				+ "composer unable to apply the tool's filter at all");
+		}
+
+		[Test]
+		public void Slice_WithoutAnId_LeavesItNull()
+		{
+			var name = BothRows().Roots.SelectMany(Flatten)
+				.Single(n => n.Field == "Name");
+
+			Assert.That(name.SliceId, Is.Null,
+				"most slices author no id, and a synthesized one could collide with a real "
+				+ "entry in some tool's filter list");
+		}
+
+		[Test]
+		public void SliceId_IsNotReportedAsAnUnhandledAttribute()
+		{
+			var unhandled = BothRows().Diagnostics
+				.Where(d => d.Code == "unhandled-attribute" && d.Message.Contains("id"))
+				.ToList();
+
+			Assert.That(unhandled, Is.Empty,
+				"id is consumed now, so it must leave the unhandled-attribute report -- that "
+				+ "report is the list of things the Avalonia view still ignores");
+		}
+	}
+}

Src/Common/FwAvalonia/FwAvaloniaTests/ViewDefinitionOverrideApplierTests.cs

@@ -48,8 +48,8 @@ public void Apply_EmptyPatch_ReproducesBaseExactly()
 		}
 
 		// Every node is rebuilt on apply, so a clone that omits a field strips it tree-wide once
-		// any override exists. These three fields are outside ToSnapshot() and aren't covered by
-		// the EmptyPatch test.
+		// any override exists. These fields are outside ToSnapshot() and aren't covered by the
+		// EmptyPatch test.
 		[Test]
 		public void Apply_PreservesNodeFieldsNoOperationTouches()
 		{
@@ -59,7 +59,8 @@ public void Apply_PreservesNodeFieldsNoOperationTouches()
 				new ViewNode("g/a", ViewNodeKind.Field, "A", null, "F", "multistring",
 					EditorClassification.Known, "vern", ViewVisibility.Always,
 					ViewExpansion.NotApplicable, false, null, null,
-					enumStringList: options, visibleWritingSystems: writingSystems, toggleValue: true)));
+					enumStringList: options, visibleWritingSystems: writingSystems, toggleValue: true,
+					helpTopicId: "khtpField-LexEntry-Form", sliceId: "CmPossibilityStatus")));
 			var patch = new ViewDefinitionOverride("LexEntry", "detail", "jtview",
 				new[]
 				{
@@ -76,6 +77,11 @@ public void Apply_PreservesNodeFieldsNoOperationTouches()
 			Assert.That(rebuilt.ToggleValue, Is.True, "a toggle value survives the rebuild");
 			Assert.That(rebuilt.EnumStringList?.Ids, Is.EqualTo(options.Ids),
 				"an enum option list survives the rebuild");
+			Assert.That(rebuilt.HelpTopicId, Is.EqualTo("khtpField-LexEntry-Form"),
+				"an authored help topic survives the rebuild");
+			Assert.That(rebuilt.SliceId, Is.EqualTo("CmPossibilityStatus"),
+				"and so does the slice id a tool's filter list names; losing it would show a "
+				+ "withheld row in every layout carrying an override");
 		}
 
 		// The writing-system subset a user picks for one field, recorded against its stable id.
@@ -155,6 +161,30 @@ public void Apply_DuplicateNode_CopiesLeafUnderNewId()
 			Assert.That(children[1].Field, Is.EqualTo("F"));
 		}
 
+		// A duplicate is the same authored part, so a filter list that withholds the source
+		// withholds the copy, and its help is the source's.
+		[Test]
+		public void Apply_DuplicateNode_KeepsTheSourcesSliceIdAndHelpTopic()
+		{
+			var shipped = Model(GroupNode("g", "Group",
+				new ViewNode("g/a", ViewNodeKind.Field, "A", null, "F", "string",
+					EditorClassification.Known, "vern", ViewVisibility.Always,
+					ViewExpansion.NotApplicable, false, null, null,
+					helpTopicId: "khtpField-LexEntry-Form", sliceId: "CmPossibilityStatus")));
+			var patch = new ViewDefinitionOverride("LexEntry", "detail", "jtview",
+				new[]
+				{
+					new ViewOverrideOperation(ViewOverrideOperationKind.DuplicateNode, "g/a-copy",
+						parentStableId: "g", index: 1, sourceStableId: "g/a")
+				}, null);
+
+			var copy = ViewDefinitionOverrideApplier.Apply(shipped, patch).Roots[0].Children[1];
+
+			Assert.That(copy.StableId, Is.EqualTo("g/a-copy"), "precondition: this is the copy");
+			Assert.That(copy.SliceId, Is.EqualTo("CmPossibilityStatus"));
+			Assert.That(copy.HelpTopicId, Is.EqualTo("khtpField-LexEntry-Form"));
+		}
+
 		[Test]
 		public void Apply_DuplicateNode_SourceWithChildren_ReportsDiagnostic_AndDoesNotInsert()
 		{

Src/Common/FwAvalonia/ViewDefinition/ViewDefinitionJsonSerializer.cs

@@ -90,6 +90,7 @@ private static JObject WriteNode(ViewNode node)
 			AddIfPresent(o, "contextMenu", node.ContextMenuId);
 			AddIfPresent(o, "hotlinks", node.HotlinksId);
 			AddIfPresent(o, "helpTopicID", node.HelpTopicId);
+			AddIfPresent(o, "sliceId", node.SliceId);
 			AddIfPresent(o, "ghost", node.GhostField);
 			AddIfPresent(o, "ghostWs", node.GhostWs);
 			AddIfPresent(o, "ghostClass", node.GhostClass);
@@ -214,7 +215,8 @@ private static ViewNode ReadNode(JToken token)
 				ghostInitMethod: (string)o["ghostInitMethod"],
 				condition: ReadCondition((JObject)o["condition"]),
 				chooserLinks: ((JArray)o["chooserLinks"])?.Select(ReadChooserLink).ToList(),
-				helpTopicId: (string)o["helpTopicID"]);
+				helpTopicId: (string)o["helpTopicID"],
+				sliceId: (string)o["sliceId"]);
 		}
 
 		private static T ParseEnum<T>(JObject o, string name, T fallback) where T : struct

Src/Common/FwAvalonia/ViewDefinition/ViewDefinitionModel.cs

@@ -387,8 +387,10 @@ public ViewNode(
 			IReadOnlyList<string> visibleWritingSystems = null,
 			bool toggleValue = false,
 			bool reorder = false,
-			string helpTopicId = null)
+			string helpTopicId = null,
+			string sliceId = null)
 		{
+			SliceId = sliceId;
 			HelpTopicId = helpTopicId;
 			Reorder = reorder;
 			ToggleValue = toggleValue;
@@ -432,6 +434,13 @@ public ViewNode(
 
 		public ViewNodeKind Kind { get; }
 
+		/// <summary>
+		/// The slice's authored <c>id=</c>, the name a tool's filter list uses to withhold the
+		/// row. Null on the nodes that author none, which is most of them. NOT
+		/// <see cref="StableId"/>, which is synthesized and always present.
+		/// </summary>
+		public string SliceId { get; }
+
 		public string Label { get; }
 
 		public string Abbreviation { get; }

Src/Common/FwAvalonia/ViewDefinition/ViewDefinitionOverrideApplier.cs

@@ -299,8 +299,9 @@ void Visit(ViewNode node)
 			return map;
 		}
 
-		// Reconstruct an immutable node with the overridden fields, copying every other one.
-		// Every trailing optional constructor argument must be passed, or that field is stripped.
+		// Rebuild an immutable node with the overridden fields, copying every other one. Pass
+		// every trailing optional argument, by name, or that field is stripped or shifted into
+		// its neighbour.
 		private static ViewNode CloneWith(ViewNode n, ViewVisibility visibility, string label,
 			IReadOnlyList<ViewNode> children, IReadOnlyList<string> visibleWritingSystems)
 			=> new ViewNode(
@@ -310,7 +311,7 @@ private static ViewNode CloneWith(ViewNode n, ViewVisibility visibility, string
 				n.ContextMenuId, n.HotlinksId, n.GhostField, n.GhostWs, n.GhostClass, n.GhostLabel,
 				n.ForVariant, n.CustomEditorClass, n.CustomEditorAssembly, n.GhostInitMethod, n.Condition,
 				n.ChooserLinks, n.EnumStringList, visibleWritingSystems, n.ToggleValue, n.Reorder,
-				n.HelpTopicId);
+				helpTopicId: n.HelpTopicId, sliceId: n.SliceId);
 
 		// Copy a (leaf) node under a new StableId; AutomationId is dropped so the duplicate gets a fresh,
 		// non-colliding identity (the renderer derives one from the new StableId by convention).
@@ -322,6 +323,6 @@ private static ViewNode CloneWithId(ViewNode n, string newId)
 				n.ContextMenuId, n.HotlinksId, n.GhostField, n.GhostWs, n.GhostClass, n.GhostLabel,
 				n.ForVariant, n.CustomEditorClass, n.CustomEditorAssembly, n.GhostInitMethod, n.Condition,
 				n.ChooserLinks, n.EnumStringList, n.VisibleWritingSystems, n.ToggleValue, n.Reorder,
-				n.HelpTopicId);
+				helpTopicId: n.HelpTopicId, sliceId: n.SliceId);
 	}
 }

Src/Common/FwAvalonia/ViewDefinition/XmlLayoutImporter.cs

@@ -34,7 +34,7 @@ public sealed class XmlLayoutImporter : IViewDefinitionImporter
 		public static readonly HashSet<string> HandledSliceAttributes =
 			new HashSet<string>(System.StringComparer.Ordinal)
 			{
-				"label", "abbr", "field", "ws", "editor", "visibility", "expansion",
+				"id", "label", "abbr", "field", "ws", "editor", "visibility", "expansion",
 				"localizationKey", "labelId", "automationId", "routing", "menu", "contextMenu", "hotlinks",
 				"forVariant", "visibleWritingSystems", "reorder", "helpTopicID"
 			};
@@ -395,6 +395,7 @@ private ViewNode CreateNode(
 							menuId, contextMenuId, hotlinksId,
 							chooserLinks: chooserLinks.Count > 0 ? chooserLinks : null,
 							visibleWritingSystems: visibleWss,
+							sliceId: Attr(contentEl, "id"),
 							helpTopicId: Attr(contentEl, "helpTopicID"));
 					}
 
@@ -412,6 +413,8 @@ private ViewNode CreateNode(
 						chooserLinks: chooserLinks.Count > 0 ? chooserLinks : null,
 						enumStringList: enumStringList,
 						visibleWritingSystems: visibleWss,
+						// A tool's filter list withholds rows by this authored id.
+						sliceId: Attr(contentEl, "id"),
 						// Legacy toggleValue= on a boolean slice (the displayed checkbox is the
 						// logical inverse of the stored property); carried so the composer inverts read+write.
 						toggleValue: ParseOptionalBool(Attr(contentEl, "toggleValue")) ?? false,

Src/xWorks/Avalonia/Composer/DetailComposer.cs

@@ -117,10 +117,12 @@ public static ComposedDetail Compose(ILexEntry entry, LcmCache cache, bool showH
 			SlicePluginRegistry plugins = null,
 			ViewDefinitionOverrideResolver overrides = null,
 			ISet<string> showAllWritingSystemsFields = null,
-			Action<string> writingSystemFocused = null)
+			Action<string> writingSystemFocused = null,
+			ISet<string> hiddenSliceIds = null)
 			=> Compose((ICmObject)entry, cache, "Normal", showHiddenFields, plugins, overrides,
 				showAllWritingSystemsFields: showAllWritingSystemsFields,
-				writingSystemFocused: writingSystemFocused);
+				writingSystemFocused: writingSystemFocused,
+				hiddenSliceIds: hiddenSliceIds);
 
 		/// <summary>
 		/// Compose the structured detail view for ANY record root + starting layout -- the
@@ -141,7 +143,8 @@ public static ComposedDetail Compose(ICmObject obj, LcmCache cache, string layou
 			ViewDefinitionOverrideResolver overrides = null,
 			string layoutChoiceField = null,
 			ISet<string> showAllWritingSystemsFields = null,
-			Action<string> writingSystemFocused = null)
+			Action<string> writingSystemFocused = null,
+			ISet<string> hiddenSliceIds = null)
 		{
 			if (obj == null) throw new ArgumentNullException(nameof(obj));
 			if (cache == null) throw new ArgumentNullException(nameof(cache));
@@ -162,7 +165,7 @@ public static ComposedDetail Compose(ICmObject obj, LcmCache cache, string layou
 			IDetailEditContext composedContext = null;
 			var state = new ComposeState(cache, showHiddenFields,
 				plugins ?? SlicePluginRegistry.Default, () => composedContext, overrides,
-				showAllWritingSystemsFields, writingSystemFocused);
+				showAllWritingSystemsFields, writingSystemFocused, hiddenSliceIds);
 			state.EnterModel(root);
 			foreach (var node in root.Roots)
 				state.Walk(node, obj, 0);
@@ -352,8 +355,10 @@ public ComposeState(LcmCache cache, bool showHiddenFields,
 				SlicePluginRegistry plugins, Func<IDetailEditContext> editContextAccessor,
 				ViewDefinitionOverrideResolver overrides = null,
 				ISet<string> showAllWritingSystemsFields = null,
-				Action<string> writingSystemFocused = null)
+				Action<string> writingSystemFocused = null,
+				ISet<string> hiddenSliceIds = null)
 			{
+				_hiddenSliceIds = hiddenSliceIds;
 				_cache = cache;
 				_showHidden = showHiddenFields;
 				_plugins = plugins;
@@ -572,8 +577,9 @@ private readonly HashSet<Tuple<int, int>> _propsToMonitor
 			/// irrelevant on a clitic or particle, Position on a non-infix, InflectionClasses on
 			/// some affix forms, FromPartsOfSpeech on an entry with no clitic.
 			///
-			/// The relevance gate of the two <c>SliceFilter.IncludeSlice</c> applies. The other
-			/// looks the slice's id up in the tool's filter list, and LT-22802 covers it.
+			/// The relevance gate of the two <c>SliceFilter.IncludeSlice</c> applies. The other,
+			/// <see cref="IsFilteredOutByTool"/>, looks the slice's id up in the tool's
+			/// filter list.
 			///
 			/// Not the same as hidden: show-hidden-fields leaves an irrelevant field withheld,
 			/// so this is asked whatever <c>_showHidden</c> says.
@@ -601,10 +607,26 @@ private bool IsIrrelevantForObject(ViewNode node, ICmObject obj)
 				return !obj.IsFieldRelevant(flid, _propsToMonitor);
 			}
 
+			// The tool's filter list, by authored slice id; null when the tool configures none.
+			private readonly ISet<string> _hiddenSliceIds;
+
+			/// <summary>
+			/// Whether the TOOL withholds this row: a tool's configuration can name slice ids
+			/// to leave out, and a node carrying one of them is dropped. Checked before the
+			/// node kind is dispatched, so a withheld node takes its subtree with it.
+			/// </summary>
+			private bool IsFilteredOutByTool(ViewNode node)
+				=> _hiddenSliceIds != null
+					&& !string.IsNullOrEmpty(node?.SliceId)
+					&& _hiddenSliceIds.Contains(node.SliceId);
+
 			public void Walk(ViewNode node, ICmObject obj, int depth)
 			{
-				if (IsHidden(node) || depth > MaxDepth || IsIrrelevantForObject(node, obj))
+				if (IsHidden(node) || depth > MaxDepth || IsFilteredOutByTool(node)
+					|| IsIrrelevantForObject(node, obj))
+				{
 					return;
+				}
 
 				// Rows added while this node walks are stamped with its help-topic inputs.
 				_walkNodes.Push(node);