From e5a812082ae033afb1eed82c0f2df3d0f6bdc93f Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Wed, 17 Apr 2024 08:53:20 +0200
Subject: Adding upstream version 2.1.6.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 xml/upgrade-2.10.xsl | 2569 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 2569 insertions(+)
 create mode 100644 xml/upgrade-2.10.xsl

(limited to 'xml/upgrade-2.10.xsl')

diff --git a/xml/upgrade-2.10.xsl b/xml/upgrade-2.10.xsl
new file mode 100644
index 0000000..526ef6d
--- /dev/null
+++ b/xml/upgrade-2.10.xsl
@@ -0,0 +1,2569 @@
+<!--
+ Copyright 2018 Red Hat, Inc.
+ Author: Jan Pokorny <jpokorny@redhat.com>
+ Part of pacemaker project
+ SPDX-License-Identifier: GPL-2.0-or-later
+ -->
+
+<!--
+ Not compatible with @id-ref occurrences!  Normalize generic 2.X-compatible
+ instances with upgrade-2.10-enter.xsl (optionally denormalize back akin
+ to the original with upgrade-2.10-leave.xsl once the upgrade is finished).
+-->
+
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                xmlns:cibtr="http://clusterlabs.org/ns/pacemaker/cibtr-2"
+                exclude-result-prefixes="cibtr">
+<xsl:output method="xml" encoding="UTF-8" indent="yes" omit-xml-declaration="yes"/>
+
+<xsl:param name="cibtr:cib-min-ver" select="'3.0'"/>
+<xsl:param name="cibtr:label-warning" select="'WARNING: '"/>
+<xsl:param name="cibtr:label-info"    select="'INFO: '"/>
+<xsl:param name="cibtr:label-debug"   select="'DEBUG: '"/>
+
+<!--
+
+ HELPER DEFINITIONS
+
+ -->
+
+<cibtr:map>
+
+  <!--
+   Target tag:     cluster_property_set
+   Object:         ./nvpair/@name
+   Selector ctxt:  ./nvpair/@value
+   Move ctxt:      op_defaults ~ /cib/configuration/op_defaults
+                   rsc_defaults ~ /cib/configuration/rsc_defaults
+   Related commit: c1c66fe13
+                   +
+                   7a9891f29
+                   7d0d1b0eb
+                   1f643d610
+                   73a5d63a8
+                   +
+                   642a09b22
+                   0c03e366d
+                   a28a558f9
+   -->
+  <cibtr:table for="cluster-properties" msg-prefix="Cluster properties"
+               where-cases="op_defaults|rsc_defaults">
+    <cibtr:replace what="cluster-infrastructure"
+                   with=""
+                   in-case-of="heartbeat|openais|classic openais|classic openais (with plugin)|cman"
+                   msg-extra="corosync (2+) infrastructure can be used instead, though the value is not of significance"/>
+
+    <cibtr:replace what="cluster_recheck_interval"
+                   with="cluster-recheck-interval"/>
+    <cibtr:replace what="dc_deadtime"
+                   with="dc-deadtime"/>
+
+    <cibtr:replace what="default-action-timeout"
+                   with="timeout"
+                   where="op_defaults"/>
+    <cibtr:replace what="default_action_timeout"
+                   with="timeout"
+                   where="op_defaults"/>
+
+    <cibtr:replace what="default-migration-threshold"
+                   with=""
+                   msg-extra="migration-threshold in rsc_defaults can be configured instead"/>
+    <cibtr:replace what="default_migration_threshold"
+                   with=""
+                   msg-extra="migration-threshold in rsc_defaults can be configured instead"/>
+
+    <cibtr:replace what="default-resource-stickiness"
+                   with="resource-stickiness"
+                   where="rsc_defaults"/>
+    <cibtr:replace what="default_resource_stickiness"
+                   with="resource-stickiness"
+                   where="rsc_defaults"/>
+
+    <cibtr:replace what="default-resource-failure-stickiness"
+                   with="migration-threshold"
+                   where="rsc_defaults"
+                   in-case-of="-INFINITY"
+                   redefined-as="1"/>
+    <cibtr:replace what="default-resource-failure-stickiness"
+                   with=""
+                   msg-extra="migration-threshold in rsc_defaults can be configured instead"/>
+    <cibtr:replace what="default_resource_failure_stickiness"
+                   with="migration-threshold"
+                   where="rsc_defaults"
+                   in-case-of="-INFINITY"
+                   redefined-as="1"/>
+    <cibtr:replace what="default_resource_failure_stickiness"
+                   with=""
+                   msg-extra="migration-threshold in rsc_defaults can be configured instead"/>
+
+    <cibtr:replace what="election_timeout"
+                   with="election-timeout"/>
+    <cibtr:replace what="expected-quorum-votes"
+                   with=""
+                   msg-extra="corosync (2+) infrastructure tracks quorum on its own"/>
+
+    <cibtr:replace what="is-managed-default"
+                   with="is-managed"
+                   where="rsc_defaults"/>
+    <cibtr:replace what="is_managed_default"
+                   with="is-managed"
+                   where="rsc_defaults"/>
+    <cibtr:replace what="no_quorum_policy"
+                   with="no-quorum-policy"/>
+
+    <cibtr:replace what="notification-agent"
+                   with=""
+                   msg-extra="standalone alerts can be configured instead"/>
+    <cibtr:replace what="notification-recipient"
+                   with=""
+                   msg-extra="standalone alerts can be configured instead"/>
+
+    <cibtr:replace what="remove_after_stop"
+                   with="remove-after-stop"/>
+    <cibtr:replace what="shutdown_escalation"
+                   with="shutdown-escalation"/>
+    <cibtr:replace what="startup_fencing"
+                   with="startup-fencing"/>
+    <cibtr:replace what="stonith_action"
+                   with="stonith-action"/>
+    <cibtr:replace what="stonith_enabled"
+                   with="stonith-enabled"/>
+    <cibtr:replace what="stop_orphan_actions"
+                   with="stop-orphan-actions"/>
+    <cibtr:replace what="stop_orphan_resources"
+                   with="stop-orphan-resources"/>
+    <cibtr:replace what="symmetric_cluster"
+                   with="symmetric-cluster"/>
+    <cibtr:replace what="transition_idle_timeout"
+                   with="cluster-delay"/>
+  </cibtr:table>
+
+  <!--
+   Target tag:     node
+   Object:         ./@*
+   Selector ctxt:  ./@*
+   Move ctxt:      N/A
+   Related commit: 55ab749bf
+   -->
+  <cibtr:table for="cluster-node" msg-prefix="Cluster node">
+    <cibtr:replace what="type"
+                   with="type"
+                   in-case-of="normal"
+                   redefined-as="member"/>
+  </cibtr:table>
+
+  <!--
+   Target tag:     primitive
+                   template
+   Object:         ./instance_attributes/nvpair/@name
+   Selector ctxt:  N/A
+   Move ctxt:      N/A
+   Related commit: 06d4559cb
+                   +
+                   6c8e0be20
+   -->
+  <cibtr:table for="resource-instance-attributes" msg-prefix="Resource instance_attributes">
+    <cibtr:replace what="pcmk_arg_map"
+                   with=""/>
+    <!-- simplified as pcmk_arg_map can encode multiple
+         comma-separated pairs (everything would be dropped then,
+         except for a single dangling case: "port" coming first) -->
+    <cibtr:replace what="pcmk_arg_map"
+                   with="pcmk_host_argument"
+                   in-case-of-droppable-prefix="port:"/>
+
+    <cibtr:replace what="pcmk_list_cmd"
+                   with="pcmk_list_action"/>
+    <cibtr:replace what="pcmk_monitor_cmd"
+                   with="pcmk_monitor_action"/>
+    <cibtr:replace what="pcmk_off_cmd"
+                   with="pcmk_off_action"/>
+    <cibtr:replace what="pcmk_on_cmd"
+                   with="pcmk_on_action"/>
+    <cibtr:replace what="pcmk_reboot_cmd"
+                   with="pcmk_reboot_action"/>
+    <cibtr:replace what="pcmk_status_cmd"
+                   with="pcmk_status_action"/>
+  </cibtr:table>
+
+  <!--
+   Target tag:     primitive
+                   template
+   Object:         ./meta_attributes/nvpair/@name
+   Selector ctxt:  N/A
+   Move ctxt:      N/A
+   Related commit: c713bbe39
+                   +
+                   6052ad6da
+   -->
+  <cibtr:table for="resource-meta-attributes" msg-prefix="Resource meta_attributes">
+    <cibtr:replace what="isolation"
+                   with="target-role"
+                   redefined-as="Stopped"
+                   msg-extra="i.e. resource at hand disabled; isolation wrappers obsoleted with bundle resources"
+                   msg-severity="WARNING"/>
+    <cibtr:replace what="isolation-host"
+                   with="target-role"
+                   redefined-as="Stopped"
+                   msg-extra="i.e. resource at hand disabled; isolation wrappers obsoleted with bundle resources"
+                   msg-severity="WARNING"/>
+    <cibtr:replace what="isolation-instance"
+                   with="target-role"
+                   redefined-as="Stopped"
+                   msg-extra="i.e. resource at hand disabled; isolation wrappers obsoleted with bundle resources"
+                   msg-severity="WARNING"/>
+    <cibtr:replace what="isolation-wrapper"
+                   with="target-role"
+                   redefined-as="Stopped"
+                   msg-extra="i.e. resource at hand disabled; isolation wrappers obsoleted with bundle resources"
+                   msg-severity="WARNING"/>
+
+    <cibtr:replace what="resource-failure-stickiness"
+                   with="migration-threshold"
+                   in-case-of="-INFINITY"
+                   redefined-as="1"/>
+    <cibtr:replace what="resource-failure-stickiness"
+                   with=""
+                   msg-extra="migration-threshold can be configured instead"/>
+    <cibtr:replace what="resource_failure_stickiness"
+                   with="migration-threshold"
+                   in-case-of="-INFINITY"
+                   redefined-as="1"/>
+    <cibtr:replace what="resource_failure_stickiness"
+                   with=""
+                   msg-extra="migration-threshold can be configured instead"/>
+  </cibtr:table>
+
+  <!--
+   Target tag:     primitive
+                   template
+   Object:         ./operations/op/@*
+                   ./operations/op/meta_attributes/nvpair/@name
+                   ./operations/op/instance_attributes/nvpair/@name
+   Selector ctxt:  ./operations/op/@name
+   Move ctxt:      meta_attributes ~ ./meta_attributes/nvpair
+   Related commit: 014a543d5
+   -->
+  <cibtr:table for="resources-operation" msg-prefix="Resources-operation"
+               where-cases="meta_attributes">
+    <!-- keep this in sync with resource-operation-instance-attributes table -->
+    <cibtr:replace what="requires"
+                   with=""
+                   msg-extra="only start/promote operation taken into account"/>
+    <cibtr:replace what="requires"
+                   with="requires"
+                   in-case-of="start|promote"
+                   where="meta_attributes"/>
+  </cibtr:table>
+
+  <!--
+   Target tag:     primitive
+                   template
+   Object:         ./operations/op/instance_attributes/nvpair/@name
+   Selector ctxt:  ./operations/op/@name
+   Move ctxt:      per-resource-meta_attributes ~ ./meta_attributes/nvpair
+                   meta_attributes ~ ./operations/op/meta_attributes/nvpair
+   Related commit: 023897afc
+                   3100c0e8b
+   -->
+  <cibtr:table for="resource-operation-instance-attributes"
+               msg-prefix="Resources-operation instance_attributes"
+               where-cases="meta_attributes|per-resource-meta_attributes">
+    <!-- this is easier to solve through resources-operation table handling,
+         in the inverse mode, but for compatibility purposes, we need to have
+         it tracked here, so mark it the same way as if we were moving it over
+         to sibling per-op meta_attributes (while in fact we move it up to
+         per-resource meta_attributes, as if it was specified in per-op
+         meta_attributes already), just use a dedicated "where-case" other
+         than "meta_attributes" reserved for proper local move as mentioned;
+         otherwise keep it in sync with said table -->
+    <cibtr:replace what="requires"
+                   with=""
+                   msg-extra="only start/promote operation taken into account"/>
+    <cibtr:replace what="requires"
+                   with="requires"
+                   in-case-of="start|promote"
+                   where="per-resource-meta_attributes"/>
+
+    <!-- these must have been, due to the value sourcing predence arrangement,
+         shadowed by immediate op's attributes, so simply preserve their
+         non-meta meaning -->
+    <!--
+    <cibtr:replace what="name"
+                   with="name"
+                   where="meta_attributes"/>
+    <cibtr:replace what="interval"
+                   with="interval"
+                   where="meta_attributes"/>
+    -->
+
+    <cibtr:replace what="interval-origin"
+                   with="interval-origin"
+                   where="meta_attributes"/>
+    <cibtr:replace what="start-delay"
+                   with="start-delay"
+                   where="meta_attributes"/>
+
+    <cibtr:replace what="enabled"
+                   with="enabled"
+                   where="meta_attributes"/>
+    <cibtr:replace what="on-fail"
+                   with="on-fail"
+                   where="meta_attributes"/>
+    <cibtr:replace what="record-pending"
+                   with="record-pending"
+                   where="meta_attributes"/>
+    <cibtr:replace what="role"
+                   with="role"
+                   where="meta_attributes"/>
+    <cibtr:replace what="timeout"
+                   with="timeout"
+                   where="meta_attributes"/>
+  </cibtr:table>
+
+  <!--
+   Target tag:     rsc_colocation
+   Object:         ./@*
+   Selector ctxt:  N/A
+   Move ctxt:      N/A
+   Related commit: 96d7ffedf
+   -->
+  <cibtr:table for="constraints-colocation" msg-prefix="Constraints-colocation">
+    <cibtr:replace what="score-attribute"
+                   with=""
+                   msg-extra="was actually never in effect"/>
+    <cibtr:replace what="score-attribute-mangle"
+                   with=""
+                   msg-extra="was actually never in effect"/>
+  </cibtr:table>
+
+</cibtr:map>
+
+<xsl:variable name="cibtr:MapClusterProperties"
+              select="document('')/xsl:stylesheet
+                        /cibtr:map/cibtr:table[
+                          @for = 'cluster-properties'
+                        ]"/>
+
+<xsl:variable name="cibtr:MapClusterNode"
+              select="document('')/xsl:stylesheet
+                        /cibtr:map/cibtr:table[
+                          @for = 'cluster-node'
+                        ]"/>
+
+<xsl:variable name="cibtr:MapResourceInstanceAttributes"
+              select="document('')/xsl:stylesheet
+                        /cibtr:map/cibtr:table[
+                          @for = 'resource-instance-attributes'
+                        ]"/>
+
+<xsl:variable name="cibtr:MapResourceMetaAttributes"
+              select="document('')/xsl:stylesheet
+                        /cibtr:map/cibtr:table[
+                          @for = 'resource-meta-attributes'
+                        ]"/>
+
+<xsl:variable name="cibtr:MapResourcesOperation"
+              select="document('')/xsl:stylesheet
+                        /cibtr:map/cibtr:table[
+                          @for = 'resources-operation'
+                        ]"/>
+
+<xsl:variable name="cibtr:MapResourcesOperationInstanceAttributes"
+              select="document('')/xsl:stylesheet
+                        /cibtr:map/cibtr:table[
+                          @for = 'resource-operation-instance-attributes'
+                        ]"/>
+
+<xsl:variable name="cibtr:MapConstraintsColocation"
+              select="document('')/xsl:stylesheet
+                        /cibtr:map/cibtr:table[
+                          @for = 'constraints-colocation'
+                        ]"/>
+
+<!--
+
+ GENERIC UTILITIES
+
+ -->
+
+<!--
+ Plain identity template
+
+ Merely implicit-context-driven, no arguments.
+ -->
+<xsl:template name="cibtr:HelperIdentity">
+  <xsl:copy>
+    <xsl:apply-templates select="@*|node()"
+                         mode="cibtr:main"/>
+  </xsl:copy>
+</xsl:template>
+
+<!--
+ Emit an message about the replacement, sanity checking the source definitions
+
+ Merely parameter driven, no implicit context taken into account:
+ - Context: optional message prefix
+ - Replacement: selected subset of cibtr:map's leaves
+                (it's considered a hard error if consists of more than 1 item)
+
+ Explanation wrt. how target severity gets selected, ordered by priority:
+ - $Replacement/@msg-severity (WARNING/INFO/DEBUG)
+ - $Replacement/@msg-extra defined -> INFO
+ - otherwise -> DEBUG
+ -->
+<xsl:template name="cibtr:MapMsg">
+  <xsl:param name="Context" select="''"/>
+  <xsl:param name="Replacement"/>
+  <xsl:choose>
+    <xsl:when test="not($Replacement)"/>
+    <xsl:when test="count($Replacement) != 1">
+      <xsl:message terminate="yes">
+        <xsl:value-of select="concat('INTERNAL ERROR: ',
+                                     $Replacement/../@msg-prefix,
+                                     ': count($Replacement) != 1',
+                                     ' does not hold (',
+                                     count($Replacement), ')')"/>
+      </xsl:message>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:variable name="MsgPrefix" select="concat(
+                                               ($Replacement|$Replacement/..)
+                                                 /@msg-prefix, ': '
+                                             )"/>
+      <xsl:variable name="MsgSeverity">
+        <xsl:choose>
+          <xsl:when test="$Replacement/@msg-severity">
+            <xsl:value-of select="$Replacement/@msg-severity"/>
+          </xsl:when>
+          <xsl:when test="$Replacement/@msg-extra">
+            <xsl:value-of select="'INFO'"/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="'DEBUG'"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:variable>
+      <xsl:variable name="MsgSeverityLabel">
+        <xsl:choose>
+          <xsl:when test="$MsgSeverity = 'WARNING'">
+            <xsl:value-of select="$cibtr:label-warning"/>
+          </xsl:when>
+          <xsl:when test="$MsgSeverity = 'INFO'">
+            <xsl:value-of select="$cibtr:label-info"/>
+          </xsl:when>
+          <xsl:when test="$MsgSeverity = 'DEBUG'">
+            <xsl:value-of select="$cibtr:label-debug"/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:message terminate="yes">
+              <xsl:value-of select="concat('INTERNAL ERROR: not a valid',
+                                           ' severity specification: ',
+                                           $MsgSeverity)"/>
+            </xsl:message>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:variable>
+      <xsl:if test="string($MsgSeverityLabel) != string(false())">
+        <xsl:message>
+          <xsl:value-of select="concat($MsgSeverityLabel, $MsgPrefix)"/>
+          <xsl:if test="$Context">
+            <xsl:value-of select="concat($Context, ': ')"/>
+          </xsl:if>
+          <xsl:choose>
+            <xsl:when test="string($Replacement/@with)">
+              <xsl:choose>
+                <xsl:when test="string($Replacement/@where)">
+                  <xsl:if test="not(
+                                  contains(
+                                    concat('|', $Replacement/../@where-cases, '|'),
+                                    concat('|', $Replacement/@where, '|')
+                                  )
+                                )">
+                    <xsl:message terminate="yes">
+                      <xsl:value-of select="concat('INTERNAL ERROR:',
+                                                   $Replacement/../@msg-prefix,
+                                                   ': $Replacement/@where (',
+                                                   $Replacement/@where, ') not in ',
+                                                   concat('|',
+                                                   $Replacement/../@where-cases,
+                                                   '|'))"/>
+                    </xsl:message>
+                  </xsl:if>
+                  <xsl:value-of select="concat('moving ', $Replacement/@what,
+                                               ' under ', $Replacement/@where)"/>
+                </xsl:when>
+                <xsl:when test="$Replacement/@with = $Replacement/@what">
+                  <xsl:value-of select="concat('keeping ', $Replacement/@what)"/>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:value-of select="concat('renaming ', $Replacement/@what)"/>
+                </xsl:otherwise>
+              </xsl:choose>
+              <xsl:value-of select="concat(' as ', $Replacement/@with)"/>
+              <xsl:if test="$Replacement/@where">
+                <xsl:value-of select="' unless already defined there'"/>
+              </xsl:if>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="concat('dropping ', $Replacement/@what)"/>
+            </xsl:otherwise>
+          </xsl:choose>
+          <xsl:if test="string($Replacement/@redefined-as)">
+            <xsl:value-of select="concat(', redefined as ',
+                                         $Replacement/@redefined-as)"/>
+            <xsl:if test="$Replacement/@in-case-of">
+              <xsl:value-of select="','"/>
+            </xsl:if>
+          </xsl:if>
+          <xsl:choose>
+            <xsl:when test="string($Replacement/@in-case-of)">
+              <xsl:value-of select="concat(' for matching ',
+                                           $Replacement/@in-case-of)"/>
+            </xsl:when>
+            <xsl:when test="$Replacement/@in-case-of">
+              <xsl:value-of select="' for matching &quot;empty string&quot;'"/>
+            </xsl:when>
+            <xsl:when test="$Replacement/@in-case-of-droppable-prefix">
+              <xsl:value-of select="concat(' for matching ',
+                                      $Replacement/@in-case-of-droppable-prefix,
+                                      ' prefix that will, meanwhile, get dropped'
+                                    )"/>
+            </xsl:when>
+          </xsl:choose>
+        </xsl:message>
+        <xsl:if test="$Replacement/@msg-extra">
+          <xsl:message>
+            <xsl:value-of select="concat($MsgSeverityLabel, $MsgPrefix, '... ',
+                                         $Replacement/@msg-extra)"/>
+          </xsl:message>
+        </xsl:if>
+      </xsl:if>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<!--
+ Produce a denormalized space if not present in the input (cf. trick A.)
+
+ Merely parameter driven, no implicit context taken into account:
+ - Source: input selection or result tree fragment to evaluate
+ - ResultTreeFragment: optional self-explanatory flag related to Source
+ -->
+<xsl:template name="cibtr:HelperDenormalizedSpace">
+  <xsl:param name="Source"/>
+  <xsl:param name="ResultTreeFragment" select="false()"/>
+  <xsl:param name="InnerSimulation" select="false()"/>
+  <xsl:choose>
+    <xsl:when test="not($ResultTreeFragment)">
+      <!-- intention here is that immediately surrounding text (mostly expected
+           to be just indenting whitespace) and comments will be preserved;
+           in case no denormalized space is present, " " is injected -->
+      <xsl:variable name="ExistingSpace"
+                    select="$Source/preceding-sibling::node()[
+                              (
+                                self::comment()
+                                or
+                                self::text()
+                              )
+                              and
+                              generate-id(following-sibling::*[1])
+                              = generate-id($Source)
+                            ]"/>
+      <xsl:copy-of select="$ExistingSpace"/>
+      <xsl:if test="not(
+                      $ExistingSpace/self::text()[
+                        normalize-space(.) != string(.)
+                      ]
+                    ) and $InnerSimulation">
+        <xsl:text> </xsl:text>
+      </xsl:if>
+    </xsl:when>
+    <xsl:when test="normalize-space($Source)
+                    != string($Source)">
+      <xsl:text> </xsl:text>
+    </xsl:when>
+  </xsl:choose>
+</xsl:template>
+
+<!--
+
+ TRANSFORMATION HELPERS
+
+ considerations, limitations, etc.:
+ 1. the transformations tries to preserve as much of the original XML
+    as possible, incl. whitespace text/indentation and comments, but
+    at times (corner cases of tricks A. + B. below), this needs to be
+    sacrificed, e.g., distorting nice indentation, hence if the
+    perfection is the goal:
+    - user of the transformation can feed the minimized version of
+      the XML (no denormalized/any white-space present)
+    - user of the transformation can (re-)pretty-print the outcome
+      afterwards
+
+ tricks and conventions used:
+ A. callable templates only return Result Tree Fragments, which means
+    the only operations allowed are those looking at the underlying,
+    virtual node-set, and since we need to discern their non-void
+    production (i.e. on successful match/es), we use this trick:
+    - ensure the template will not propagate any denormalized whitespace
+    - inject denormalized whitespace (superfluous space) artificially
+      to mark successful production (but see B. below)
+    - with the template production, here stored as Var variable,
+      we test "normalize-space($Var) != $Var" condition to detect
+      non-void production, mainly intended to see whether to emit
+      the enclosing element at all (with the goal of not leaving
+      superfluous elements behind needlessly)
+ B. [extension over A.] to eliminate distorted indentation
+    (cf. consideration 1.), additional reuse of these callable
+    templates is introduced: the template can recursively call
+    itself with a special flag (InnerSimulation) as an oracle to
+    see to whether non-void production will ensue (all pre-existing
+    denormalized whitespace is forcefully removed in this mode),
+    and if positive, all such inner pre-existing whitespace is
+    then preserved in this outer=main invocation
+ C. [extension over B.] when checking the non-void production
+    (via InnerSimulation), beside the injected denormalized whitespace,
+    we can also inject particular strings, which the callsite of such
+    simulation can, in addition, inspect for paricular string
+    occurrences, e.g. to prevent clashes on the production coming
+    from multiple sources
+ D. not only to honour DRY principle and to avoid inner entropy, it's
+    often useful to make callable template bimodal, e.g., when the
+    production is generated in the "what's to stay in place" vs.
+    "what's to be propagated (combined with previous, effectively
+    moved) at this other part of the tree" contexts; for such cases,
+    there's usually InverseMode parameter to be assigned true()
+    (implicit default) and false(), respectively
+ E. the common idiom that emerges is: evaluate simulation value,
+    depending on the presence of the "success mark" (cf. A.),
+    possibly emit non-simulation value; since it would (likely)
+    re-evaluate the simulation anew (wastefully) or perhaps
+    this sort of dependency injection can just come handy,
+    common transformation helpers below offer InnerPass
+    parameter to be optionally passed, either as a string (when
+    no-denormalized-space is an internal criterium for the template)
+    or, conventionally, the result tree fragment representing the
+    output of the template at hand called with a simulation flag
+    * established signaling strings accompanying InnerSimulation=true:
+      - TRIGGER-MSG ... make the template execution emit messages
+                        describing changes being performed
+      - TRIGGER-RECURSION
+                    ... currently used in the oracle-like evaluation
+                        of what's the situation with the sibling
+                        elements as a recursion guard so that such
+                        nested runs won't revisit the new set of
+                        siblings per the respective nested context
+
+ -->
+
+<!--
+ Source ctxt:    cluster_property_set
+ Target ctxt:    cluster_property_set
+ Target-inv ctxt:/cib/configuration/(op_defaults|rsc_defaults)
+                 [cluster_property_set -> meta_attributes]
+ Dependencies:   N/A
+ -->
+<xsl:template name="cibtr:ProcessClusterProperties">
+  <xsl:param name="Source"/>
+  <xsl:param name="InverseMode" select="false()"/>
+  <xsl:param name="InnerSimulation" select="false()"/>
+  <xsl:param name="InnerPass">
+    <xsl:choose>
+      <xsl:when test="$InnerSimulation">
+        <xsl:value-of select="''"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:ProcessClusterProperties">
+          <xsl:with-param name="Source" select="$Source"/>
+          <xsl:with-param name="InverseMode" select="$InverseMode"/>
+          <xsl:with-param name="InnerSimulation" select="true()"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:param>
+
+  <xsl:for-each select="$Source/node()">
+    <xsl:choose>
+      <xsl:when test="self::text()">
+        <!-- cf. trick A. (consideration 1.) -->
+        <xsl:choose>
+          <xsl:when test="normalize-space($InnerPass)
+                          != $InnerPass
+                          and
+                          (
+                            not(following-sibling::nvpair)
+                            or
+                            generate-id(following-sibling::nvpair[1])
+                            != generate-id(following-sibling::*[1])
+                          )">
+            <xsl:value-of select="."/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="normalize-space(.)"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:when test="self::nvpair">
+        <xsl:variable name="Replacement"
+                      select="$cibtr:MapClusterProperties/cibtr:replace[
+                                @what = current()/@name
+                                and
+                                (
+                                  (
+                                    @in-case-of
+                                    and
+                                    contains(concat('|', @in-case-of, '|'),
+                                             concat('|', current()/@value, '|'))
+                                  )
+                                  or
+                                  (
+                                    not(@in-case-of)
+                                    and
+                                    not(
+                                      $cibtr:MapClusterProperties/cibtr:replace[
+                                        @what = current()/@name
+                                        and
+                                        @in-case-of
+                                        and
+                                        contains(concat('|', @in-case-of, '|'),
+                                                 concat('|', current()/@value, '|'))
+                                      ]
+                                    )
+                                  )
+                                )
+                              ]"/>
+        <xsl:if test="$InnerPass = 'TRIGGER-MSG'">
+          <xsl:call-template name="cibtr:MapMsg">
+            <xsl:with-param name="Context" select="@id"/>
+            <xsl:with-param name="Replacement" select="$Replacement"/>
+          </xsl:call-template>
+        </xsl:if>
+        <xsl:choose>
+          <xsl:when test="$Replacement
+                          and
+                          (
+                            not(string($Replacement/@with))
+                            or
+                            $Replacement/@where
+                          )">
+            <!-- drop (possibly just move over) -->
+            <xsl:if test="$Replacement/@where
+                          and
+                          (
+                            (
+                              normalize-space($InverseMode)
+                              and
+                              $Replacement/@where = $InverseMode
+                            )
+                            or
+                            (
+                              not(normalize-space($InverseMode))
+                              and
+                              (true() or count($InverseMode))
+                              and
+                              not(
+                                $InverseMode/nvpair[
+                                  @name = $Replacement/@with
+                                ]
+                              )
+                              and
+                              $Replacement/@where = name($InverseMode/..)
+                            )
+                          )">
+              <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+                <xsl:with-param name="Source" select="."/>
+                <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+              </xsl:call-template>
+              <xsl:copy>
+                <xsl:for-each select="@*">
+                  <xsl:choose>
+                    <xsl:when test="name() = 'name'">
+                      <xsl:attribute name="{name()}">
+                        <xsl:value-of select="$Replacement/@with"/>
+                      </xsl:attribute>
+                    </xsl:when>
+                    <xsl:when test="string($Replacement/@redefined-as)
+                                    and
+                                    name() = 'value'">
+                      <xsl:attribute name="{name()}">
+                        <xsl:value-of select="$Replacement/@redefined-as"/>
+                      </xsl:attribute>
+                    </xsl:when>
+                    <xsl:otherwise>
+                      <xsl:copy/>
+                    </xsl:otherwise>
+                  </xsl:choose>
+                </xsl:for-each>
+              </xsl:copy>
+            </xsl:if>
+          </xsl:when>
+          <xsl:when test="$InverseMode"/>
+          <xsl:when test="$Replacement">
+            <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+            </xsl:call-template>
+            <xsl:copy>
+              <xsl:for-each select="@*">
+                <xsl:choose>
+                  <xsl:when test="name() = 'name'">
+                    <xsl:attribute name="{name()}">
+                      <xsl:value-of select="$Replacement/@with"/>
+                    </xsl:attribute>
+                  </xsl:when>
+                  <xsl:when test="string($Replacement/@redefined-as)
+                                  and
+                                  name() = 'value'">
+                    <xsl:attribute name="{name()}">
+                      <xsl:value-of select="$Replacement/@redefined-as"/>
+                    </xsl:attribute>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:copy/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:for-each>
+            </xsl:copy>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+            </xsl:call-template>
+            <xsl:call-template name="cibtr:HelperIdentity"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:when test="$InverseMode
+                      or
+                      self::comment()">
+        <!-- drop -->
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:HelperIdentity"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:for-each>
+</xsl:template>
+
+<!--
+ Source ctxt:    (primitive|template)/instance_attributes
+ Target ctxt:    (primitive|template)/instance_attributes
+ Target-inv ctxt:N/A
+ Dependencies:   N/A
+ -->
+<xsl:template name="cibtr:ProcessRscInstanceAttributes">
+  <xsl:param name="Source"/>
+  <xsl:param name="InnerSimulation" select="false()"/>
+  <xsl:param name="InnerPass">
+    <xsl:choose>
+      <xsl:when test="$InnerSimulation">
+        <xsl:value-of select="''"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:ProcessRscInstanceAttributes">
+          <xsl:with-param name="Source" select="$Source"/>
+          <xsl:with-param name="InnerSimulation" select="true()"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:param>
+
+  <!-- B: special-casing nvpair -->
+  <xsl:for-each select="$Source/node()">
+    <xsl:choose>
+      <xsl:when test="self::text()">
+        <!-- cf. trick A. (consideration 1.) -->
+        <xsl:choose>
+          <xsl:when test="normalize-space($InnerPass)
+                          != $InnerPass
+                          and
+                          (
+                            not(following-sibling::nvpair)
+                            or
+                            generate-id(following-sibling::nvpair[1])
+                            != generate-id(following-sibling::*[1])
+                          )">
+            <xsl:value-of select="."/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="normalize-space(.)"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:when test="self::nvpair">
+        <xsl:variable name="Replacement"
+                      select="$cibtr:MapResourceInstanceAttributes/cibtr:replace[
+                                @what = current()/@name
+                                and
+                                (
+                                  (
+                                    @in-case-of
+                                    and
+                                    contains(concat('|', @in-case-of, '|'),
+                                             concat('|', current()/@value, '|'))
+                                  )
+                                  or
+                                  (
+                                    @in-case-of-droppable-prefix
+                                    and
+                                    starts-with(current()/@value,
+                                                @in-case-of-droppable-prefix)
+                                    and
+                                    not(
+                                      contains(current()/@value, ',')
+                                    )
+                                  )
+                                  or
+                                  (
+                                    not(@in-case-of)
+                                    and
+                                    not(@in-case-of-droppable-prefix)
+                                    and
+                                    not(
+                                      $cibtr:MapResourceInstanceAttributes/cibtr:replace[
+                                        @what = current()/@name
+                                        and
+                                        (
+                                          (
+                                            @in-case-of
+                                            and
+                                            contains(concat('|', @in-case-of, '|'),
+                                                     concat('|', current()/@value, '|'))
+                                          )
+                                          or
+                                          (
+                                            @in-case-of-droppable-prefix
+                                            and
+                                            starts-with(current()/@value,
+                                                        @in-case-of-droppable-prefix)
+                                            and
+                                            not(
+                                              contains(current()/@value, ',')
+                                            )
+                                          )
+                                        )
+                                      ]
+                                    )
+                                  )
+                                )
+                              ]"/>
+        <xsl:if test="$InnerPass = 'TRIGGER-MSG'">
+          <xsl:call-template name="cibtr:MapMsg">
+            <xsl:with-param name="Context" select="@id"/>
+            <xsl:with-param name="Replacement" select="$Replacement"/>
+          </xsl:call-template>
+        </xsl:if>
+        <xsl:choose>
+          <xsl:when test="$Replacement
+                          and
+                          not(string($Replacement/@with))">
+            <!-- drop (move-over code missing) -->
+          </xsl:when>
+          <xsl:when test="$Replacement">
+            <!-- plain rename -->
+            <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+            </xsl:call-template>
+            <xsl:copy>
+              <xsl:for-each select="@*">
+                <xsl:choose>
+                  <xsl:when test="name() = 'name'">
+                    <xsl:attribute name="{name()}">
+                      <xsl:value-of select="$Replacement/@with"/>
+                    </xsl:attribute>
+                  </xsl:when>
+                  <xsl:when test="string($Replacement/@redefined-as)
+                                  and
+                                  name() = 'value'">
+                    <xsl:attribute name="{name()}">
+                      <xsl:value-of select="$Replacement/@redefined-as"/>
+                    </xsl:attribute>
+                  </xsl:when>
+                  <xsl:when test="string($Replacement/@in-case-of-droppable-prefix)
+                                  and
+                                  name() = 'value'">
+                    <xsl:attribute name="{name()}">
+                      <xsl:value-of select="substring-after(
+                                              ., $Replacement/@in-case-of-droppable-prefix
+                                            )"/>
+                    </xsl:attribute>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:copy/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:for-each>
+            </xsl:copy>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+            </xsl:call-template>
+            <xsl:call-template name="cibtr:HelperIdentity"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:HelperIdentity"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:for-each>
+  <!-- E: special-casing nvpair -->
+</xsl:template>
+
+<!--
+ Source ctxt:    (primitive|template)/meta_attributes
+ Target ctxt:    (primitive|template)/meta_attributes
+ Target-inv ctxt:N/A
+ Dependencies:   N/A
+ -->
+<xsl:template name="cibtr:ProcessRscMetaAttributes">
+  <xsl:param name="Source"/>
+  <xsl:param name="InnerSimulation" select="false()"/>
+  <xsl:param name="InnerPass">
+    <xsl:choose>
+      <xsl:when test="$InnerSimulation">
+        <xsl:value-of select="''"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:ProcessRscMetaAttributes">
+          <xsl:with-param name="Source" select="$Source"/>
+          <xsl:with-param name="InnerSimulation" select="true()"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:param>
+
+  <!-- B: special-casing nvpair -->
+  <xsl:for-each select="$Source/node()">
+    <xsl:choose>
+      <xsl:when test="self::text()">
+        <!-- cf. trick A. (consideration 1.) -->
+        <xsl:choose>
+          <xsl:when test="normalize-space($InnerPass)
+                          != $InnerPass
+                          and
+                          (
+                            not(following-sibling::nvpair)
+                            or
+                            generate-id(following-sibling::nvpair[1])
+                            != generate-id(following-sibling::*[1])
+                          )">
+            <xsl:value-of select="."/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="normalize-space(.)"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:when test="self::nvpair">
+        <xsl:variable name="Replacement"
+                      select="$cibtr:MapResourceMetaAttributes/cibtr:replace[
+                                @what = current()/@name
+                                and
+                                (
+                                  (
+                                    @in-case-of
+                                    and
+                                    contains(concat('|', @in-case-of, '|'),
+                                             concat('|', current()/@value, '|'))
+                                  )
+                                  or
+                                  (
+                                    not(@in-case-of)
+                                    and
+                                    not(
+                                      $cibtr:MapResourceMetaAttributes/cibtr:replace[
+                                        @what = current()/@name
+                                        and
+                                        (
+                                          @in-case-of
+                                          and
+                                          contains(concat('|', @in-case-of, '|'),
+                                                   concat('|', current()/@value, '|'))
+                                        )
+                                      ]
+                                    )
+                                  )
+                                )
+                              ]"/>
+        <xsl:if test="$InnerPass = 'TRIGGER-MSG'">
+          <xsl:call-template name="cibtr:MapMsg">
+            <xsl:with-param name="Context"
+                            select="concat(../../@id,
+                                           ' (meta=', ../@id,
+                                           ')')"/>
+            <xsl:with-param name="Replacement" select="$Replacement"/>
+          </xsl:call-template>
+        </xsl:if>
+        <xsl:choose>
+          <xsl:when test="$Replacement
+                          and
+                          not(string($Replacement/@with))">
+            <!-- drop (move-over code missing) -->
+          </xsl:when>
+          <xsl:when test="$Replacement">
+            <!-- plain rename -->
+            <xsl:variable name="SimulateFollowingSiblings">
+              <!-- prevent generating redundant name-value pairs -->
+              <xsl:for-each select="(..|../following-sibling::meta_attributes)[
+                                      not(rule)
+                                    ]">
+                <xsl:if test="$InnerPass != 'TRIGGER-RECURSION'">
+                  <xsl:call-template name="cibtr:ProcessRscMetaAttributes">
+                    <xsl:with-param name="Source" select="."/>
+                    <xsl:with-param name="InnerSimulation" select="true()"/>
+                    <xsl:with-param name="InnerPass" select="'TRIGGER-RECURSION'"/>
+                  </xsl:call-template>
+                </xsl:if>
+              </xsl:for-each>
+            </xsl:variable>
+            <xsl:choose>
+              <!-- instead of HelperDenormalizedSpace -->
+              <xsl:when test="$InnerSimulation">
+                <xsl:value-of select="concat(generate-id(), '@', $Replacement/@with, ' ')"/>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:if test="not(
+                                contains($SimulateFollowingSiblings,
+                                         concat($Replacement/@with, ' '))
+                              )
+                              or
+                              generate-id()
+                              =
+                              substring-before($SimulateFollowingSiblings,
+                                               concat('@', $Replacement/@with))">
+                  <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+                    <xsl:with-param name="Source" select="."/>
+                    <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+                  </xsl:call-template>
+                  <xsl:copy>
+                    <xsl:for-each select="@*">
+                      <xsl:choose>
+                        <xsl:when test="name() = 'name'">
+                          <xsl:attribute name="{name()}">
+                            <xsl:value-of select="$Replacement/@with"/>
+                          </xsl:attribute>
+                        </xsl:when>
+                        <xsl:when test="string($Replacement/@redefined-as)
+                                        and
+                                        name() = 'value'">
+                          <xsl:attribute name="{name()}">
+                            <xsl:value-of select="$Replacement/@redefined-as"/>
+                          </xsl:attribute>
+                        </xsl:when>
+                        <xsl:otherwise>
+                          <xsl:copy/>
+                        </xsl:otherwise>
+                      </xsl:choose>
+                    </xsl:for-each>
+                  </xsl:copy>
+                </xsl:if>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+            </xsl:call-template>
+            <xsl:call-template name="cibtr:HelperIdentity"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:HelperIdentity"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:for-each>
+  <!-- E: special-casing nvpair -->
+</xsl:template>
+
+<!--
+ Source ctxt:    (primitive|template)/operations/op/instance_attributes
+ Target ctxt:    (primitive|template)/operations/op/instance_attributes
+ Target-inv ctxt:(primitive|template)/operations/op/meta_attributes
+ Dependencies:   ProcessNonattrOpMetaAttributes [inverse only]
+ -->
+<xsl:template name="cibtr:ProcessOpInstanceAttributes">
+  <xsl:param name="Source"/>
+  <xsl:param name="InverseMode" select="false()"/>
+  <xsl:param name="InnerSimulation" select="false()"/>
+  <xsl:param name="InnerPass">
+    <xsl:choose>
+      <xsl:when test="$InnerSimulation">
+        <xsl:value-of select="''"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:ProcessOpInstanceAttributes">
+          <xsl:with-param name="Source" select="$Source"/>
+          <xsl:with-param name="InnerSimulation" select="true()"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:param>
+
+  <xsl:variable name="EnclosingTag" select="../../.."/>
+
+  <!-- B: special-casing nvpair -->
+  <xsl:for-each select="$Source/node()">
+    <xsl:choose>
+      <xsl:when test="self::text()">
+        <!-- cf. trick A. (consideration 1.) -->
+        <xsl:choose>
+          <xsl:when test="normalize-space($InnerPass)
+                          != $InnerPass
+                          and
+                          (
+                            not(following-sibling::nvpair)
+                            or
+                            generate-id(following-sibling::nvpair[1])
+                            != generate-id(following-sibling::*[1])
+                          )">
+            <xsl:value-of select="."/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="normalize-space(.)"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:when test="self::nvpair">
+        <xsl:variable name="Replacement"
+                      select="$cibtr:MapResourcesOperationInstanceAttributes/cibtr:replace[
+                                @what = current()/@name
+                                and
+                                (
+                                  (
+                                    @in-case-of
+                                    and
+                                    contains(concat('|', @in-case-of, '|'),
+                                             concat('|', current()/../../@name, '|'))
+                                  )
+                                  or
+                                  (
+                                    not(@in-case-of)
+                                    and
+                                    not(
+                                      $cibtr:MapResourcesOperationInstanceAttributes/cibtr:replace[
+                                        @what = current()/@name
+                                        and
+                                        @in-case-of
+                                        and
+                                        contains(concat('|', @in-case-of, '|'),
+                                                 concat('|', current()/../../@name, '|'))
+                                      ]
+                                    )
+                                  )
+                                )
+                              ]"/>
+        <xsl:if test="$InnerPass = 'TRIGGER-MSG'">
+          <xsl:call-template name="cibtr:MapMsg">
+            <xsl:with-param name="Context"
+                            select="concat(../../@id,
+                                           ' (rsc=', $EnclosingTag/@id,
+                                           ', meta=', ../@id,
+                                           ')')"/>
+            <xsl:with-param name="Replacement" select="$Replacement"/>
+          </xsl:call-template>
+        </xsl:if>
+        <xsl:choose>
+          <xsl:when test="$Replacement
+                          and
+                          (
+                            not(string($Replacement/@with))
+                            or
+                            $Replacement/@where
+                          )">
+            <!-- drop (possibly just move over) -->
+            <xsl:variable name="SimulateAttrOverrides">
+              <xsl:for-each select="../../../op">
+                <xsl:call-template name="cibtr:ProcessAttrOpMetaAttributes">
+                  <xsl:with-param name="Source" select="."/>
+                  <xsl:with-param name="InverseMode" select="true()"/>
+                  <xsl:with-param name="InnerSimulation" select="true()"/>
+                </xsl:call-template>
+              </xsl:for-each>
+            </xsl:variable>
+            <xsl:if test="$InverseMode
+                          and
+                          not(
+                            contains($SimulateAttrOverrides,
+                                     concat(@name, ' '))
+                          )">
+              <!-- do not override; do not collide with:
+                   - newly added from op/@* (see last condition above)
+                   - existing - actually subsumed with the previous point
+                   - successors sourced like this (see below) -->
+              <xsl:variable name="SimulateFollowingSiblingsMeta">
+                <!-- cf. similar handling in ProcessAttrOpMetaAttributes,
+                     but this is more convoluted -->
+                <xsl:for-each select="(../following-sibling::meta_attributes
+                                       |../../following-sibling::op/meta_attributes)[
+                                        not(rule)
+                                      ]">
+                  <xsl:call-template name="cibtr:ProcessNonattrOpMetaAttributes">
+                    <xsl:with-param name="Source" select="."/>
+                    <xsl:with-param name="InverseMode" select="true()"/>
+                    <xsl:with-param name="InnerSimulation" select="true()"/>
+                  </xsl:call-template>
+                </xsl:for-each>
+              </xsl:variable>
+              <xsl:variable name="SimulateFollowingSiblingsInstance">
+                <xsl:for-each select="../following-sibling::instance_attributes[
+                                        not(rule)
+                                      ]">
+                  <xsl:call-template name="cibtr:ProcessOpInstanceAttributes">
+                    <xsl:with-param name="Source" select="."/>
+                    <xsl:with-param name="InverseMode" select="true()"/>
+                    <xsl:with-param name="InnerSimulation" select="true()"/>
+                  </xsl:call-template>
+                </xsl:for-each>
+              </xsl:variable>
+              <xsl:if test="$Replacement/@where = 'meta_attributes'
+                            and
+                            not(
+                              $EnclosingTag/meta_attributes[
+                                not(rule)
+                                and
+                                nvpair/@name = $Replacement/@with
+                              ]
+                            )
+                            and
+                            not(
+                              contains($SimulateFollowingSiblingsInstance,
+                                       concat(@name, ' '))
+                            )">
+                <!-- cf. trick C. (indicate for inverse mode) -->
+                <xsl:choose>
+                  <xsl:when test="$InnerSimulation">
+                    <!-- instead of HelperDenormalizedSpace -->
+                    <xsl:value-of select="concat(@name, ' ')"/>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+                      <xsl:with-param name="Source" select="."/>
+                      <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+                    </xsl:call-template>
+                    <xsl:copy>
+                      <xsl:apply-templates select="@*"
+                                           mode="cibtr:main"/>
+                    </xsl:copy>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:if>
+            </xsl:if>
+          </xsl:when>
+          <xsl:when test="$Replacement">
+            <xsl:message terminate="yes">
+              <xsl:value-of select="concat('INTERNAL ERROR: ',
+                                           $Replacement/../@msg-prefix,
+                                           ': no in-situ rename',
+                                           ' does not hold (',
+                                           not(($InverseMode)), ')')"/>
+            </xsl:message>
+          </xsl:when>
+          <xsl:when test="$InverseMode"/>
+          <xsl:otherwise>
+            <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+            </xsl:call-template>
+            <xsl:call-template name="cibtr:HelperIdentity"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:when test="$InverseMode
+                      or
+                      self::comment()">
+        <!-- drop -->
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:HelperIdentity"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:for-each>
+  <!-- E: special-casing nvpair -->
+</xsl:template>
+
+<!--
+ Source ctxt:    (primitive|template)/operations/op/meta_attributes
+                 (primitive|template)/operations/op/instance_attributes (inverse only)
+ Target ctxt:    (primitive|template)/operations/op/meta_attributes
+ Target-inv ctxt:(primitive|template)/meta_attributes
+ Dependencies:   ProcessAttrOpMetaAttributes
+                 ProcessNonattrOpMetaAttributes
+ -->
+<xsl:template name="cibtr:ProcessNonattrOpMetaAttributes">
+  <xsl:param name="Source"/>
+  <xsl:param name="InverseMode" select="false()"/>
+  <xsl:param name="InnerSimulation" select="false()"/>
+  <xsl:param name="InnerPass">
+    <xsl:choose>
+      <xsl:when test="$InnerSimulation">
+        <xsl:value-of select="''"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:ProcessNonattrOpMetaAttributes">
+          <xsl:with-param name="Source" select="$Source"/>
+          <xsl:with-param name="InnerSimulation" select="true()"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:param>
+
+  <xsl:variable name="EnclosingTag" select="../../.."/>
+
+  <xsl:for-each select="$Source/node()">
+    <xsl:choose>
+      <xsl:when test="self::text()
+                      and
+                      not($InverseMode)">
+        <!-- cf. trick A. (consideration 1.) -->
+        <xsl:choose>
+          <xsl:when test="normalize-space($InnerPass)
+                          != $InnerPass
+                          and
+                          (
+                            not(following-sibling::nvpair)
+                            or
+                            generate-id(following-sibling::nvpair[1])
+                            != generate-id(following-sibling::*[1])
+                          )">
+            <xsl:value-of select="."/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="normalize-space(.)"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:when test="self::nvpair">
+        <xsl:variable name="Replacement"
+                      select="$cibtr:MapResourcesOperation/cibtr:replace[
+                                @what = current()/@name
+                                and
+                                (
+                                  (
+                                    @in-case-of
+                                    and
+                                    contains(concat('|', @in-case-of, '|'),
+                                             concat('|', current()/../../@name, '|'))
+                                  )
+                                  or
+                                  (
+                                    not(@in-case-of)
+                                    and
+                                    not(
+                                      $cibtr:MapResourcesOperation/cibtr:replace[
+                                        @what = current()/@name
+                                        and
+                                        @in-case-of
+                                        and
+                                        contains(concat('|', @in-case-of, '|'),
+                                                 concat('|', current()/../../@name, '|'))
+                                      ]
+                                    )
+                                  )
+                                )
+                              ]"/>
+        <xsl:if test="$InnerPass = 'TRIGGER-MSG'">
+          <xsl:call-template name="cibtr:MapMsg">
+            <xsl:with-param name="Context"
+                            select="concat(../../@id,
+                                           ' (rsc=', $EnclosingTag/@id,
+                                           ', meta=', ../@id,
+                                           ')')"/>
+            <xsl:with-param name="Replacement" select="$Replacement"/>
+          </xsl:call-template>
+        </xsl:if>
+        <xsl:choose>
+          <xsl:when test="$Replacement
+                          and
+                          (
+                            not(string($Replacement/@with))
+                            or
+                            $Replacement/@where
+                          )">
+            <!-- drop (possibly just move over) -->
+            <xsl:if test="$InverseMode">
+              <xsl:variable name="SimulateAttrOverrides">
+                <xsl:for-each select="../../../op">
+                  <xsl:call-template name="cibtr:ProcessAttrOpMetaAttributes">
+                    <xsl:with-param name="Source" select="."/>
+                    <xsl:with-param name="InverseMode" select="true()"/>
+                    <xsl:with-param name="InnerSimulation" select="true()"/>
+                  </xsl:call-template>
+                </xsl:for-each>
+              </xsl:variable>
+              <xsl:if test="not(
+                              contains($SimulateAttrOverrides,
+                                       concat(@name, ' '))
+                            )">
+                <!-- do not override; do not collide with:
+                     - newly added from op/@* (see last condition above)
+                     - existing - actually subsumed with the previous point
+                     - successors sourced like this (see below)
+                     and if coming from op/instance_attributes, add also
+                     - any meta_attributes sourced like this -->
+                <xsl:variable name="SimulateFollowingSiblings">
+                  <!-- cf. similar handling in ProcessAttrOpMetaAttributes,
+                       but this is more convoluted -->
+                  <xsl:if test="name(..) = 'meta_attributes'">
+                    <xsl:for-each select="(../following-sibling::meta_attributes
+                                           |../../following-sibling::op/meta_attributes)[
+                                            not(rule)
+                                          ]">
+                      <xsl:call-template name="cibtr:ProcessNonattrOpMetaAttributes">
+                        <xsl:with-param name="Source" select="."/>
+                        <xsl:with-param name="InverseMode" select="true()"/>
+                        <xsl:with-param name="InnerSimulation" select="true()"/>
+                      </xsl:call-template>
+                    </xsl:for-each>
+                  </xsl:if>
+                  <xsl:if test="name(..) = 'instance_attributes'">
+                    <xsl:for-each select="(../following-sibling::instance_attributes
+                                           |../../following-sibling::op/instance_attributes
+                                           |../../meta_attributes
+                                           |../../../op/meta_attributes)[
+                                            not(rule)
+                                          ]">
+                      <xsl:call-template name="cibtr:ProcessNonattrOpMetaAttributes">
+                        <xsl:with-param name="Source" select="."/>
+                        <xsl:with-param name="InverseMode" select="true()"/>
+                        <xsl:with-param name="InnerSimulation" select="true()"/>
+                      </xsl:call-template>
+                    </xsl:for-each>
+                  </xsl:if>
+                </xsl:variable>
+                <xsl:if test="$Replacement/@where = 'meta_attributes'
+                              and
+                              not(
+                                $EnclosingTag/meta_attributes[
+                                  not(rule)
+                                  and
+                                  nvpair/@name = $Replacement/@with
+                                ]
+                              )
+                              and
+                              not(
+                                contains($SimulateFollowingSiblings,
+                                         concat(@name, ' '))
+                              )">
+                  <!-- cf. trick C. (indicate for inverse mode) -->
+                  <xsl:choose>
+                    <!-- instead of HelperDenormalizedSpace -->
+                    <xsl:when test="$InnerSimulation">
+                      <xsl:value-of select="concat(@name, ' ')"/>
+                    </xsl:when>
+                    <xsl:otherwise>
+                      <xsl:copy>
+                        <xsl:apply-templates select="@*"
+                                             mode="cibtr:main"/>
+                      </xsl:copy>
+                    </xsl:otherwise>
+                  </xsl:choose>
+                </xsl:if>
+              </xsl:if>
+            </xsl:if>
+          </xsl:when>
+          <xsl:when test="$Replacement">
+            <xsl:message terminate="yes">
+              <xsl:value-of select="concat('INTERNAL ERROR: ',
+                                           $Replacement/../@msg-prefix,
+                                           ': no in-situ rename',
+                                           ' does not hold (',
+                                           not(($InverseMode)), ')')"/>
+            </xsl:message>
+          </xsl:when>
+          <xsl:when test="$InverseMode"/>
+          <xsl:otherwise>
+            <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+            </xsl:call-template>
+            <xsl:call-template name="cibtr:HelperIdentity"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:when test="$InverseMode
+                      or
+                      self::comment()">
+        <!-- drop -->
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:HelperIdentity"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:for-each>
+</xsl:template>
+
+<!--
+ Source ctxt:    (primitive|template)/operations/op
+ Target ctxt:    (primitive|template)/operations/op/meta_attributes
+ Target-inv ctxt:(primitive|template)/meta_attributes
+ Dependencies:   ProcessNonattrOpMetaAttributes [non-inverse only]
+                 ProcessOpInstanceAttributes [non-inverse only]
+ -->
+<xsl:template name="cibtr:ProcessAttrOpMetaAttributes">
+  <xsl:param name="Source"/>
+  <xsl:param name="InverseMode" select="false()"/>
+  <xsl:param name="InnerSimulation" select="false()"/>
+  <xsl:param name="InnerPass">
+    <xsl:choose>
+      <xsl:when test="$InnerSimulation">
+        <xsl:value-of select="''"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:ProcessAttrOpMetaAttributes">
+          <xsl:with-param name="Source" select="$Source"/>
+          <xsl:with-param name="InverseMode" select="$InverseMode"/>
+          <xsl:with-param name="InnerSimulation" select="true()"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:param>
+
+  <xsl:variable name="EnclosingTag" select="../.."/>
+
+  <xsl:if test="(
+                  $InverseMode
+                  and
+                  (
+                    $InnerSimulation
+                    or
+                    normalize-space($InnerPass)
+                    != string($InnerPass)
+                  )
+                )
+                or
+                not($InverseMode)">
+    <xsl:if test="$InverseMode
+                  and
+                  $InnerSimulation">
+      <xsl:call-template name="cibtr:HelperDenormalizedSpace">
+        <xsl:with-param name="Source" select="$InnerPass"/>
+        <xsl:with-param name="ResultTreeFragment" select="true()"/>
+      </xsl:call-template>
+    </xsl:if>
+
+    <!-- cannot combine "copy" with creating a new element, hence we mimic
+         "copy" with recreating the element anew, while still using just
+         a single for-each loop -->
+    <xsl:variable name="ParentName">
+      <xsl:choose>
+        <xsl:when test="not($InverseMode)">
+          <xsl:value-of select="name()"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="'nvpair'"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:element name="{$ParentName}">
+    <!-- B: special-casing @* -->
+    <xsl:for-each select="@*">
+      <xsl:variable name="Replacement"
+                    select="$cibtr:MapResourcesOperation/cibtr:replace[
+                              @what = name(current())
+                              and
+                              (
+                                (
+                                  @in-case-of
+                                  and
+                                  contains(concat('|', @in-case-of, '|'),
+                                           concat('|', current()/../@name, '|'))
+                                )
+                                or
+                                (
+                                  not(@in-case-of)
+                                  and
+                                  not(
+                                    $cibtr:MapResourcesOperation/cibtr:replace[
+                                      @what = name(current())
+                                      and
+                                      @in-case-of
+                                      and
+                                      contains(concat('|', @in-case-of, '|'),
+                                               concat('|', current()/../@name, '|'))
+                                    ]
+                                  )
+                                )
+                              )
+                            ]"/>
+      <xsl:if test="$InnerPass = 'TRIGGER-MSG'">
+        <xsl:call-template name="cibtr:MapMsg">
+          <xsl:with-param name="Context"
+                                select="concat(../@id,
+                                               ' (rsc=', $EnclosingTag/@id,
+                                               ')')"/>
+          <xsl:with-param name="Replacement" select="$Replacement"/>
+        </xsl:call-template>
+      </xsl:if>
+      <xsl:choose>
+        <!-- use inner simulation to find out if success,
+             then emit also extra denormalized space -->
+        <xsl:when test="$InverseMode
+                        and
+                        $Replacement/@where = 'meta_attributes'
+                        and
+                        not(
+                          $EnclosingTag/meta_attributes[
+                            not(rule)
+                            and
+                            nvpair/@name = $Replacement/@with
+                          ]
+                        )">
+          <!-- do not override; do not collide with:
+               - existing (see last condition above)
+               - successors sourced like this (see below) -->
+          <xsl:variable name="SimulateFollowingSiblings">
+            <xsl:for-each select="../following-sibling::op">
+              <xsl:call-template name="cibtr:ProcessAttrOpMetaAttributes">
+                <xsl:with-param name="Source" select="."/>
+                <xsl:with-param name="InverseMode" select="true()"/>
+                <xsl:with-param name="InnerSimulation" select="true()"/>
+              </xsl:call-template>
+            </xsl:for-each>
+          </xsl:variable>
+          <xsl:if test="not(contains($SimulateFollowingSiblings,
+                                     concat(name(), ' ')))">
+            <!-- fix concurrent op/@* sources (these themselves are winning
+                 over sources from meta_attributes -->
+            <xsl:choose>
+              <xsl:when test="$InnerSimulation">
+                <!-- cf. trick C. (indicate for inverse mode) -->
+                <xsl:value-of select="concat(name(), ' ')"/>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:attribute name="id">
+                  <xsl:value-of select="concat('_2TO3_', ../@id, '-meta-',
+                                               $Replacement/@with)"/>
+                </xsl:attribute>
+                <xsl:attribute name="name">
+                  <xsl:value-of select="$Replacement/@with"/>
+                </xsl:attribute>
+                <xsl:attribute name="value">
+                  <xsl:value-of select="."/>
+                </xsl:attribute>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:if>
+        </xsl:when>
+        <xsl:when test="$InverseMode"/>
+        <xsl:when test="$Replacement
+                        and
+                        (
+                          not(string($Replacement/@with))
+                          or
+                          $Replacement/@where
+                        )">
+          <!-- drop (possibly just move over) -->
+        </xsl:when>
+        <xsl:when test="$Replacement">
+          <xsl:message terminate="yes">
+            <xsl:value-of select="concat('INTERNAL ERROR: ',
+                                         $Replacement/../@msg-prefix,
+                                         ': no in-situ rename',
+                                         ' does not hold')"/>
+          </xsl:message>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:copy/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:for-each>
+    <!-- E: special-casing @* -->
+
+    <xsl:if test="not($InverseMode)">
+      <!-- Look ahead if there are any meta-like instance_attibutes to
+           be propagated next door, into existing/new meta_attributes -->
+      <xsl:variable name="ProcessedInverseNonruleOpInstanceAttributes">
+        <xsl:for-each select="instance_attributes[not(rule)]">
+          <xsl:call-template name="cibtr:ProcessOpInstanceAttributes">
+            <xsl:with-param name="Source" select="."/>
+            <xsl:with-param name="InnerSimulation" select="true()"/>
+            <xsl:with-param name="InverseMode" select="true()"/>
+            <xsl:with-param name="InnerPass"
+                            select="substring-after(
+                                      concat(
+                                        string($InnerSimulation),
+                                        'TRIGGER-MSG'
+                                      ),
+                                     'true'
+                                    )"/>
+          </xsl:call-template>
+        </xsl:for-each>
+      </xsl:variable>
+      <!-- B: special-casing instance_attributes|meta_attributes -->
+      <xsl:for-each select="$Source/node()">
+        <xsl:choose>
+          <xsl:when test="self::text()">
+            <!-- cf. trick A. (consideration 1.) -->
+            <xsl:choose>
+              <xsl:when test="normalize-space($InnerPass)
+                              != $InnerPass
+                              and
+                              (
+                                not(following-sibling::nvpair)
+                                or
+                                generate-id(following-sibling::nvpair[1])
+                                != generate-id(following-sibling::*[1])
+                              )">
+                <xsl:value-of select="."/>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:value-of select="normalize-space(.)"/>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="self::instance_attributes">
+            <xsl:variable name="ProcessedOpInstanceAttributes">
+              <xsl:call-template name="cibtr:ProcessOpInstanceAttributes">
+                <xsl:with-param name="Source" select="."/>
+                <xsl:with-param name="InnerSimulation" select="true()"/>
+              </xsl:call-template>
+            </xsl:variable>
+            <!-- cf. trick A. -->
+            <xsl:if test="normalize-space($ProcessedOpInstanceAttributes)
+                          != $ProcessedOpInstanceAttributes">
+              <xsl:copy>
+                <xsl:apply-templates select="@*"
+                                     mode="cibtr:main"/>
+                <xsl:call-template name="cibtr:ProcessOpInstanceAttributes">
+                  <xsl:with-param name="Source" select="."/>
+                  <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+                  <!-- cf. trick E. -->
+                  <xsl:with-param name="InnerPass" select="$ProcessedOpInstanceAttributes"/>
+                </xsl:call-template>
+              </xsl:copy>
+            </xsl:if>
+          </xsl:when>
+          <xsl:when test="self::meta_attributes">
+            <xsl:variable name="ProcessedOpMetaAttributes">
+              <xsl:call-template name="cibtr:ProcessNonattrOpMetaAttributes">
+                <xsl:with-param name="Source" select="."/>
+                <xsl:with-param name="InnerSimulation" select="true()"/>
+                <xsl:with-param name="InnerPass"
+                                select="substring-after(
+                                          concat(
+                                            string($InnerSimulation),
+                                            'TRIGGER-MSG'
+                                          ),
+                                         'true'
+                                        )"/>
+              </xsl:call-template>
+            </xsl:variable>
+            <!-- cf. trick A.;
+                 possibly piggy-back instance_attributes (if any per
+                 above look ahead) to first suitable (not rules-driven)
+                 meta_attributes set... -->
+            <xsl:if test="normalize-space($ProcessedOpMetaAttributes)
+                          != $ProcessedOpMetaAttributes
+                          or
+                          (
+                            not(rule)
+                            and
+                            not(preceding-sibling::meta_attributes[not(rule)])
+                            and
+                            normalize-space($ProcessedInverseNonruleOpInstanceAttributes)
+                            != $ProcessedInverseNonruleOpInstanceAttributes
+                          )">
+              <xsl:copy>
+                <xsl:apply-templates select="@*"
+                                     mode="cibtr:main"/>
+                <xsl:if test="normalize-space($ProcessedOpMetaAttributes)
+                              != $ProcessedOpMetaAttributes">
+                  <xsl:call-template name="cibtr:ProcessNonattrOpMetaAttributes">
+                    <xsl:with-param name="Source" select="."/>
+                    <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+                    <!-- cf. trick E. -->
+                    <xsl:with-param name="InnerPass" select="$ProcessedOpMetaAttributes"/>
+                  </xsl:call-template>
+                </xsl:if>
+                <xsl:if test="not(rule)
+                              and
+                              not(preceding-sibling::meta_attributes[not(rule)])
+                              and
+                              normalize-space($ProcessedInverseNonruleOpInstanceAttributes)
+                              != $ProcessedInverseNonruleOpInstanceAttributes">
+                  <xsl:for-each select="../instance_attributes[not(rule)]">
+                    <xsl:call-template name="cibtr:ProcessOpInstanceAttributes">
+                      <xsl:with-param name="Source" select="."/>
+                      <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+                      <xsl:with-param name="InverseMode" select="true()"/>
+                    </xsl:call-template>
+                  </xsl:for-each>
+                </xsl:if>
+              </xsl:copy>
+            </xsl:if>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:call-template name="cibtr:HelperIdentity"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:for-each>
+      <!-- E: special-casing instance_attributes|meta_attributes -->
+
+      <!-- ...or roll out brand new meta_attributes, first collectively
+           for no-rules instances... -->
+      <xsl:if test="not(meta_attributes[not(rule)])
+                    and
+                    normalize-space($ProcessedInverseNonruleOpInstanceAttributes)
+                    != $ProcessedInverseNonruleOpInstanceAttributes">
+        <meta_attributes id="{concat('_2TO3_', @id, '-meta')}">
+          <xsl:for-each select="instance_attributes[not(rule)]">
+            <xsl:call-template name="cibtr:ProcessOpInstanceAttributes">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+              <xsl:with-param name="InverseMode" select="true()"/>
+            </xsl:call-template>
+          </xsl:for-each>
+          <xsl:apply-templates select="text()[position() = last()]"
+                               mode="cibtr:main"/>
+        </meta_attributes>
+        <xsl:apply-templates select="text()[position() = last()]"
+                             mode="cibtr:main"/>
+      </xsl:if>
+
+      <!-- ...then individually for rules-driven ones -->
+      <xsl:for-each select="instance_attributes[rule]">
+        <xsl:variable name="ProcessedInverseRuleOpInstanceAttributes">
+          <xsl:call-template name="cibtr:ProcessOpInstanceAttributes">
+            <xsl:with-param name="Source" select="."/>
+            <xsl:with-param name="InnerSimulation" select="true()"/>
+            <xsl:with-param name="InverseMode" select="true()"/>
+            <xsl:with-param name="InnerPass"
+                            select="substring-after(
+                                      concat(
+                                        string($InnerSimulation),
+                                        'TRIGGER-MSG'
+                                      ),
+                                     'true'
+                                    )"/>
+          </xsl:call-template>
+        </xsl:variable>
+        <!-- cf. trick A. -->
+        <xsl:if test="normalize-space($ProcessedInverseRuleOpInstanceAttributes)
+                      != $ProcessedInverseRuleOpInstanceAttributes">
+          <meta_attributes>
+            <xsl:apply-templates select="@*[
+                                           name() != 'id'
+                                         ]"
+                                 mode="cibtr:main"/>
+            <xsl:attribute name='id'>
+              <xsl:value-of select="concat('_2TO3_', @id)"/>
+            </xsl:attribute>
+            <xsl:apply-templates select="node()[
+                                           name() != 'nvpair'
+                                         ]"
+                                 mode="cibtr:main"/>
+            <xsl:call-template name="cibtr:ProcessOpInstanceAttributes">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InverseMode" select="true()"/>
+              <!-- cf. trick E. -->
+              <xsl:with-param name="InnerPass" select="$ProcessedInverseRuleOpInstanceAttributes"/>
+            </xsl:call-template>
+            <xsl:apply-templates select="text()[position() = last()]"
+                                 mode="cibtr:main"/>
+          </meta_attributes>
+        </xsl:if>
+      </xsl:for-each>
+    </xsl:if>
+    </xsl:element>
+  </xsl:if>
+</xsl:template>
+
+<!--
+ Source ctxt:    configuration
+ Target ctxt:    {op,rsc}_defaults/meta_attributes [per $Variant, see below]
+ Target-inv ctxt:N/A
+ Dependencies:   ProcessClusterProperties
+
+ Variant:        'op_defaults' | 'rsc_defaults'
+ -->
+<xsl:template name="cibtr:ProcessDefaultsNonruleClusterProperties">
+  <xsl:param name="Source"/>
+  <xsl:param name="Variant"/>
+  <xsl:param name="InnerSimulation" select="false()"/>
+  <xsl:param name="InnerPass">
+    <xsl:choose>
+      <xsl:when test="$InnerSimulation">
+        <xsl:value-of select="''"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:ProcessDefaultsNonruleClusterProperties">
+          <xsl:with-param name="Source" select="$Source"/>
+          <xsl:with-param name="Variant" select="$Variant"/>
+          <xsl:with-param name="InnerSimulation" select="true()"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:param>
+
+  <xsl:choose>
+    <xsl:when test="$Source/*[name() = $Variant]/meta_attributes[
+                      not(rule)
+                    ]">
+      <xsl:call-template name="cibtr:ProcessClusterProperties">
+        <xsl:with-param name="Source"
+                        select="$Source/crm_config/cluster_property_set[
+                                  not(rule)
+                                ]"/>
+        <xsl:with-param name="InverseMode"
+                        select="$Source/*[name() = $Variant]/meta_attributes[
+                                  not(rule)
+                                ]"/>
+        <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+      </xsl:call-template>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:call-template name="cibtr:ProcessClusterProperties">
+        <xsl:with-param name="Source"
+                      select="$Source/crm_config/cluster_property_set[
+                                  not(rule)
+                                ]"/>
+        <xsl:with-param name="InverseMode"
+                        select="$Variant"/>
+        <xsl:with-param name="InnerSimulation" select="$InnerSimulation"/>
+      </xsl:call-template>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<!--
+ Source ctxt:    configuration
+ Target ctxt:    {op,rsc}_defaults/meta_attributes [per $Variant, see below]
+ Target-inv ctxt:N/A
+ Dependencies:   ProcessClusterProperties
+
+ Variant:        'op_defaults' | 'rsc_defaults'
+ -->
+<xsl:template name="cibtr:ProcessDefaultsRuleClusterProperties">
+  <xsl:param name="Source"/>
+  <xsl:param name="Variant"/>
+  <xsl:param name="InnerSimulation" select="false()"/>
+  <xsl:param name="InnerPass">
+    <xsl:choose>
+      <xsl:when test="$InnerSimulation">
+        <xsl:value-of select="''"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="cibtr:ProcessDefaultsRuleClusterProperties">
+          <xsl:with-param name="Source" select="$Source"/>
+          <xsl:with-param name="Variant" select="$Variant"/>
+          <xsl:with-param name="InnerSimulation" select="true()"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:param>
+
+  <xsl:for-each select="crm_config/cluster_property_set[
+                          rule
+                        ]">
+    <xsl:variable name="ProcessedPartial">
+      <xsl:call-template name="cibtr:ProcessClusterProperties">
+        <xsl:with-param name="Source" select="$Source"/>
+        <xsl:with-param name="InverseMode" select="$Variant"/>
+        <xsl:with-param name="InnerSimulation" select="true()"/>
+        <xsl:with-param name="InnerPass" select="'TRIGGER-MSG'"/>
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:if test="normalize-space($ProcessedPartial)
+                  != $ProcessedPartial">
+      <meta_attributes id="{concat('_2TO3_', @id)}">
+        <xsl-copy-of select="rule"/>
+        <xsl:call-template name="cibtr:ProcessClusterProperties">
+          <xsl:with-param name="Source" select="$Source"/>
+          <xsl:with-param name="InverseMode" select="$Variant"/>
+        </xsl:call-template>
+      </meta_attributes>
+    </xsl:if>
+  </xsl:for-each>
+</xsl:template>
+
+<!--
+
+ ACTUAL TRANSFORMATION
+
+ -->
+
+<xsl:template match="cib" mode="cibtr:main">
+  <xsl:copy>
+    <xsl:apply-templates select="@*"
+                         mode="cibtr:main"/>
+    <xsl:attribute name="validate-with">
+      <xsl:value-of select="concat('pacemaker-', $cibtr:cib-min-ver)"/>
+    </xsl:attribute>
+    <xsl:apply-templates select="node()"
+                         mode="cibtr:main"/>
+  </xsl:copy>
+</xsl:template>
+
+<xsl:template match="cluster_property_set" mode="cibtr:main">
+  <xsl:variable name="ProcessedClusterProperties">
+    <xsl:call-template name="cibtr:ProcessClusterProperties">
+      <xsl:with-param name="Source" select="."/>
+      <xsl:with-param name="InnerSimulation" select="true()"/>
+      <xsl:with-param name="InnerPass" select="'TRIGGER-MSG'"/>
+    </xsl:call-template>
+  </xsl:variable>
+  <xsl:if test="normalize-space($ProcessedClusterProperties)
+                != $ProcessedClusterProperties">
+    <xsl:copy>
+      <xsl:apply-templates select="@*"
+                           mode="cibtr:main"/>
+      <xsl:call-template name="cibtr:ProcessClusterProperties">
+        <xsl:with-param name="Source" select="."/>
+        <!-- cf. trick E. -->
+        <xsl:with-param name="InnerPass" select="$ProcessedClusterProperties"/>
+      </xsl:call-template>
+    </xsl:copy>
+  </xsl:if>
+</xsl:template>
+
+<xsl:template match="rsc_colocation" mode="cibtr:main">
+  <xsl:copy>
+    <xsl:for-each select="@*">
+      <xsl:variable name="Replacement"
+                    select="$cibtr:MapConstraintsColocation/cibtr:replace[
+                              @what = name(current())
+                            ]"/>
+      <xsl:call-template name="cibtr:MapMsg">
+        <xsl:with-param name="Context" select="../@id"/>
+        <xsl:with-param name="Replacement" select="$Replacement"/>
+      </xsl:call-template>
+      <xsl:choose>
+        <xsl:when test="$Replacement
+                        and
+                        not(string($Replacement/@with))">
+          <!-- drop -->
+        </xsl:when>
+        <xsl:when test="$Replacement">
+          <!-- rename -->
+          <xsl:attribute name="{name()}">
+            <xsl:value-of select="$Replacement/@with"/>
+          </xsl:attribute>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:copy/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:for-each>
+    <xsl:apply-templates select="node()"
+                         mode="cibtr:main"/>
+  </xsl:copy>
+</xsl:template>
+
+<xsl:template match="node" mode="cibtr:main">
+  <xsl:copy>
+    <xsl:for-each select="@*">
+      <xsl:variable name="Replacement"
+                    select="$cibtr:MapClusterNode/cibtr:replace[
+                              @what = name(current())
+                              and
+                              (
+                                (
+                                  @in-case-of
+                                  and
+                                  contains(concat('|', @in-case-of, '|'),
+                                           concat('|', current(), '|'))
+                                )
+                                or
+                                (
+                                  not(@in-case-of)
+                                  and
+                                  not(
+                                    $cibtr:MapClusterNode/cibtr:replace[
+                                      @what = name(current())
+                                      and
+                                      @in-case-of
+                                      and
+                                      contains(concat('|', @in-case-of, '|'),
+                                               concat('|', current(), '|'))
+                                    ]
+                                  )
+                                )
+                              )
+                            ]"/>
+      <xsl:call-template name="cibtr:MapMsg">
+        <xsl:with-param name="Context" select="concat(../@uname, ' (id=', ../@id, ')')"/>
+        <xsl:with-param name="Replacement" select="$Replacement"/>
+      </xsl:call-template>
+      <xsl:choose>
+        <xsl:when test="$Replacement
+                        and
+                        not(string($Replacement/@with))">
+          <!-- drop -->
+        </xsl:when>
+        <xsl:when test="$Replacement">
+          <!-- rename -->
+          <xsl:attribute name="{$Replacement/@with}">
+            <xsl:choose>
+              <xsl:when test="$Replacement/@redefined-as">
+                <xsl:value-of select="$Replacement/@redefined-as"/>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:value-of select="."/>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:attribute>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:copy/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:for-each>
+    <xsl:apply-templates select="node()"
+                         mode="cibtr:main"/>
+  </xsl:copy>
+</xsl:template>
+
+<!--
+ 1a. propagate (primitive|template)/operations/
+       op[name() = 'start' or name() = 'promote']/@requires
+     under new ./meta_attributes/nvpair
+
+ 1b. "move" (primitive|template)/operations/
+       op[name() = 'start' or name() = 'promote']/
+       meta_attributes/nvpair[@requires]
+     under ./meta_attributes
+
+  otherwise, just
+
+ 2a.  drop (primitive|template)/operations/
+        op/@requires
+
+ 2b.  drop (primitive|template)/operations/
+        op/meta_attributes/nvpair[@requires]
+ -->
+<xsl:template match="primitive|template" mode="cibtr:main">
+  <xsl:copy>
+    <xsl:apply-templates select="@*"
+                         mode="cibtr:main"/>
+    <!-- B: special-casing operations|instance_attributes|meta_attributes -->
+    <xsl:for-each select="node()">
+      <xsl:choose>
+        <xsl:when test="self::operations">
+          <xsl:copy>
+            <xsl:apply-templates select="@*"
+                                 mode="cibtr:main"/>
+            <!-- B: special-casing op -->
+            <xsl:for-each select="node()">
+              <xsl:choose>
+                <xsl:when test="self::op">
+                  <!-- process @*|meta_attributes/nvpair
+                       (keep/drop/move elsewhere) -->
+                  <xsl:call-template name="cibtr:ProcessAttrOpMetaAttributes">
+                    <xsl:with-param name="Source" select="."/>
+                  </xsl:call-template>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:call-template name="cibtr:HelperIdentity"/>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:for-each>
+            <!-- E: special-casing op -->
+          </xsl:copy>
+        </xsl:when>
+        <xsl:when test="self::instance_attributes">
+          <xsl:variable name="ProcessedRscInstanceAttributes">
+            <xsl:call-template name="cibtr:ProcessRscInstanceAttributes">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InnerSimulation" select="true()"/>
+              <xsl:with-param name="InnerPass" select="'TRIGGER-MSG'"/>
+            </xsl:call-template>
+          </xsl:variable>
+          <!-- cf. trick A. -->
+          <xsl:if test="normalize-space($ProcessedRscInstanceAttributes)
+                        != $ProcessedRscInstanceAttributes">
+            <xsl:copy>
+              <xsl:apply-templates select="@*"
+                                   mode="cibtr:main"/>
+              <xsl:call-template name="cibtr:ProcessRscInstanceAttributes">
+                <xsl:with-param name="Source" select="."/>
+                <!-- cf. trick E. -->
+                <xsl:with-param name="InnerPass" select="$ProcessedRscInstanceAttributes"/>
+              </xsl:call-template>
+            </xsl:copy>
+          </xsl:if>
+        </xsl:when>
+        <xsl:when test="self::meta_attributes">
+          <xsl:variable name="ProcessedRscMetaAttributes">
+            <xsl:call-template name="cibtr:ProcessRscMetaAttributes">
+              <xsl:with-param name="Source" select="."/>
+              <xsl:with-param name="InnerSimulation" select="true()"/>
+              <xsl:with-param name="InnerPass" select="'TRIGGER-MSG'"/>
+            </xsl:call-template>
+          </xsl:variable>
+          <!-- cf. trick A. -->
+          <xsl:if test="normalize-space($ProcessedRscMetaAttributes)
+                        != $ProcessedRscMetaAttributes">
+            <xsl:copy>
+              <xsl:apply-templates select="@*"
+                                   mode="cibtr:main"/>
+              <xsl:call-template name="cibtr:ProcessRscMetaAttributes">
+                <xsl:with-param name="Source" select="."/>
+                <!-- cf. trick E. -->
+                <xsl:with-param name="InnerPass" select="$ProcessedRscMetaAttributes"/>
+              </xsl:call-template>
+            </xsl:copy>
+          </xsl:if>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="cibtr:HelperIdentity"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:for-each>
+    <!-- E: special-casing operations|instance_attributes|meta_attributes -->
+
+    <!-- add as last meta_attributes block... -->
+
+    <!-- ...indirectly from op attributes -->
+    <xsl:variable name="ToPropagateFromOp">
+      <xsl:for-each select="operations/op">
+        <xsl:call-template name="cibtr:ProcessAttrOpMetaAttributes">
+          <xsl:with-param name="Source" select="."/>
+          <xsl:with-param name="InverseMode" select="true()"/>
+          <xsl:with-param name="InnerSimulation" select="true()"/>
+          <xsl:with-param name="InnerPass" select="'TRIGGER-MSG'"/>
+        </xsl:call-template>
+      </xsl:for-each>
+    </xsl:variable>
+    <!-- cf. trick A. -->
+    <xsl:if test="normalize-space($ToPropagateFromOp)
+                  != $ToPropagateFromOp">
+      <meta_attributes id="{concat('_2TO3_', @id, '-meta')}">
+        <xsl:for-each select="operations/op">
+          <xsl:call-template name="cibtr:ProcessAttrOpMetaAttributes">
+            <xsl:with-param name="Source" select="."/>
+            <xsl:with-param name="InverseMode" select="true()"/>
+          </xsl:call-template>
+        </xsl:for-each>
+        <xsl:apply-templates select="text()[position() = last()]"
+                             mode="cibtr:main"/>
+      </meta_attributes>
+      <xsl:apply-templates select="text()[position() = last()]"
+                           mode="cibtr:main"/>
+    </xsl:if>
+
+    <!-- ...directly by picking existing nvpairs of
+         meta_attributes|instance_attributes -->
+    <xsl:for-each select="operations/op/meta_attributes
+                          |operations/op/instance_attributes">
+      <xsl:variable name="ProcessedOpMetaAttributes">
+        <xsl:call-template name="cibtr:ProcessNonattrOpMetaAttributes">
+          <xsl:with-param name="Source" select="."/>
+          <xsl:with-param name="InverseMode" select="true()"/>
+          <xsl:with-param name="InnerSimulation" select="true()"/>
+        </xsl:call-template>
+      </xsl:variable>
+      <!-- cf. trick A. -->
+      <xsl:if test="normalize-space($ProcessedOpMetaAttributes)
+                    != $ProcessedOpMetaAttributes">
+        <!-- cannot xsl:copy, need to settle on meta_attributes -->
+        <meta_attributes>
+          <xsl:apply-templates select="@*[
+                                         name() != 'id'
+                                       ]"
+                               mode="cibtr:main"/>
+          <xsl:attribute name='id'>
+            <xsl:value-of select="concat('_2TO3_', @id)"/>
+          </xsl:attribute>
+          <xsl:apply-templates select="node()[
+                                         name() != 'nvpair'
+                                       ]"
+                               mode="cibtr:main"/>
+          <xsl:call-template name="cibtr:ProcessNonattrOpMetaAttributes">
+            <xsl:with-param name="Source" select="."/>
+            <xsl:with-param name="InverseMode" select="true()"/>
+            <!-- cf. trick E. -->
+            <xsl:with-param name="InnerPass" select="$ProcessedOpMetaAttributes"/>
+          </xsl:call-template>
+          <xsl:apply-templates select="text()[position() = last()]"
+                               mode="cibtr:main"/>
+        </meta_attributes>
+        <xsl:apply-templates select="text()[position() = last()]"
+                             mode="cibtr:main"/>
+      </xsl:if>
+    </xsl:for-each>
+  </xsl:copy>
+</xsl:template>
+
+<xsl:template match="configuration" mode="cibtr:main">
+  <xsl:variable name="Configuration" select="."/>
+  <xsl:variable name="ProcessedOpDefaultsNonruleClusterProperties">
+    <xsl:call-template name="cibtr:ProcessDefaultsNonruleClusterProperties">
+      <xsl:with-param name="Source" select="$Configuration"/>
+      <xsl:with-param name="Variant" select="'op_defaults'"/>
+      <xsl:with-param name="InnerSimulation" select="true()"/>
+    </xsl:call-template>
+  </xsl:variable>
+  <xsl:variable name="ProcessedRscDefaultsNonruleClusterProperties">
+    <xsl:call-template name="cibtr:ProcessDefaultsNonruleClusterProperties">
+      <xsl:with-param name="Source" select="$Configuration"/>
+      <xsl:with-param name="Variant" select="'rsc_defaults'"/>
+      <xsl:with-param name="InnerSimulation" select="true()"/>
+    </xsl:call-template>
+  </xsl:variable>
+  <xsl:variable name="ProcessedOpDefaultsRuleClusterProperties">
+    <xsl:call-template name="cibtr:ProcessDefaultsNonruleClusterProperties">
+      <xsl:with-param name="Source" select="$Configuration"/>
+      <xsl:with-param name="Variant" select="'op_defaults'"/>
+      <xsl:with-param name="InnerSimulation" select="true()"/>
+    </xsl:call-template>
+  </xsl:variable>
+  <xsl:variable name="ProcessedRscDefaultsRuleClusterProperties">
+    <xsl:call-template name="cibtr:ProcessDefaultsNonruleClusterProperties">
+      <xsl:with-param name="Source" select="$Configuration"/>
+      <xsl:with-param name="Variant" select="'rsc_defaults'"/>
+      <xsl:with-param name="InnerSimulation" select="true()"/>
+    </xsl:call-template>
+  </xsl:variable>
+
+  <xsl:copy>
+    <xsl:apply-templates select="@*"
+                         mode="cibtr:main"/>
+    <!-- B: special-casing {op,rsc}_defaults -->
+    <xsl:for-each select="node()">
+      <xsl:choose>
+        <xsl:when test="self::op_defaults|self::rsc_defaults">
+          <xsl:variable name="WhichDefaults" select="name()"/>
+          <xsl:copy>
+            <xsl:apply-templates select="@*"
+                                 mode="cibtr:main"/>
+            <!-- B: special-casing meta_attributes -->
+            <xsl:for-each select="node()">
+              <xsl:copy>
+                <xsl:choose>
+                  <xsl:when test="self::meta_attributes[
+                                    not(rule)
+                                    and
+                                    not(
+                                      preceding-sibling::meta_attributes[
+                                        not(rule)
+                                      ]
+                                    )
+                                  ]">
+                  <xsl:apply-templates select="@*|node()"
+                                       mode="cibtr:main"/>
+                    <xsl:if test="$WhichDefaults = 'op_defaults'
+                                  or
+                                  $WhichDefaults = 'rsc_defaults'">
+                      <xsl:call-template name="cibtr:ProcessDefaultsNonruleClusterProperties">
+                        <xsl:with-param name="Source" select="$Configuration"/>
+                        <xsl:with-param name="Variant" select="$WhichDefaults"/>
+                      </xsl:call-template>
+                    </xsl:if>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:apply-templates select="@*|node()"
+                                         mode="cibtr:main"/>
+                  </xsl:otherwise>
+                </xsl:choose>
+                <xsl:if test="(
+                                $WhichDefaults = 'op_defaults'
+                                and
+                                normalize-space($ProcessedOpDefaultsRuleClusterProperties)
+                                != $ProcessedOpDefaultsRuleClusterProperties
+                              )
+                              or
+                              (
+                                $WhichDefaults = 'rsc_defaults'
+                                and
+                                normalize-space($ProcessedRscDefaultsRuleClusterProperties)
+                                != $ProcessedRscDefaultsRuleClusterProperties
+                              )">
+                  <xsl:call-template name="cibtr:ProcessDefaultsRuleClusterProperties">
+                    <xsl:with-param name="Source" select="$Configuration"/>
+                    <xsl:with-param name="Variant" select="$WhichDefaults"/>
+                  </xsl:call-template>
+                </xsl:if>
+              </xsl:copy>
+            </xsl:for-each>
+            <!-- E: special-casing meta_attributes -->
+          </xsl:copy>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="cibtr:HelperIdentity"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:for-each>
+    <!-- E: special-casing {op,rsc}_defaults -->
+    <xsl:if test="not(op_defaults)
+                  and
+                  (
+                    normalize-space($ProcessedOpDefaultsNonruleClusterProperties)
+                    != $ProcessedOpDefaultsNonruleClusterProperties
+                    or
+                    normalize-space($ProcessedOpDefaultsRuleClusterProperties)
+                    != $ProcessedOpDefaultsRuleClusterProperties
+                  )">
+      <op_defaults>
+        <xsl:if test="normalize-space($ProcessedOpDefaultsNonruleClusterProperties)
+                      != $ProcessedOpDefaultsNonruleClusterProperties">
+          <meta_attributes id="{concat('_2TO3_', '-op-defaults')}">
+            <xsl:call-template name="cibtr:ProcessDefaultsNonruleClusterProperties">
+              <xsl:with-param name="Source" select="$Configuration"/>
+              <xsl:with-param name="Variant" select="'op_defaults'"/>
+            </xsl:call-template>
+          </meta_attributes>
+        </xsl:if>
+        <xsl:call-template name="cibtr:ProcessDefaultsRuleClusterProperties">
+          <xsl:with-param name="Source" select="$Configuration"/>
+          <xsl:with-param name="Variant" select="'op_defaults'"/>
+        </xsl:call-template>
+        <xsl:apply-templates select="text()[position() = last()]"
+                             mode="cibtr:main"/>
+      </op_defaults>
+    </xsl:if>
+    <xsl:if test="not(rsc_defaults)
+                  and
+                  (
+                    normalize-space($ProcessedRscDefaultsNonruleClusterProperties)
+                    != $ProcessedRscDefaultsNonruleClusterProperties
+                    or
+                    normalize-space($ProcessedRscDefaultsRuleClusterProperties)
+                    != $ProcessedRscDefaultsRuleClusterProperties
+                  )">
+      <rsc_defaults>
+        <xsl:if test="normalize-space($ProcessedRscDefaultsNonruleClusterProperties)
+                      != $ProcessedRscDefaultsNonruleClusterProperties">
+          <meta_attributes id="{concat('_2TO3_', '-rsc-defaults')}">
+            <xsl:call-template name="cibtr:ProcessDefaultsNonruleClusterProperties">
+              <xsl:with-param name="Source" select="$Configuration"/>
+              <xsl:with-param name="Variant" select="'rsc_defaults'"/>
+            </xsl:call-template>
+          </meta_attributes>
+        </xsl:if>
+        <xsl:call-template name="cibtr:ProcessDefaultsRuleClusterProperties">
+          <xsl:with-param name="Source" select="$Configuration"/>
+          <xsl:with-param name="Variant" select="'rsc_defaults'"/>
+        </xsl:call-template>
+        <xsl:apply-templates select="text()[position() = last()]"
+                             mode="cibtr:main"/>
+      </rsc_defaults>
+    </xsl:if>
+  </xsl:copy>
+</xsl:template>
+
+<!-- used in test files to allow in-browser on-the-fly upgrade reports -->
+<xsl:template match="processing-instruction()[
+                       name() = 'xml-stylesheet'
+                       and
+                       count(..|/) = 1
+                     ]"
+              mode="cibtr:main"/>
+
+<xsl:template match="@*|node()" mode="cibtr:main">
+  <xsl:call-template name="cibtr:HelperIdentity"/>
+</xsl:template>
+
+<!-- mode-less, easy to override kick-off -->
+<xsl:template match="/">
+  <xsl:call-template name="cibtr:HelperIdentity"/>
+</xsl:template>
+
+</xsl:stylesheet>
-- 
cgit v1.2.3