diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 1d00c6fa..0e23cc46 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -41,13 +41,14 @@ jobs:
         uses: lukka/get-cmake@latest
 
       - name: Restore artifacts, or run vcpkg, build and cache artifacts
-        uses: lukka/run-vcpkg@v7
+        uses: lukka/run-vcpkg@v11
         id: runvcpkg
         with:
-          vcpkgArguments: 'boost-variant boost-optional boost-format boost-functional boost-range boost-iterator boost-rational'
-          vcpkgTriplet: '${{ matrix.triplet }}'
           vcpkgDirectory: '${{ runner.workspace }}/b/vcpkg'
-          vcpkgGitCommitId: '7ad236f60f5f7197e93c4d7f0807622f4899076d'
+          vcpkgGitCommitId: 'b46d9050a9d40d54d24cac3ef8d50402d421f598'
+
+      # Setup MSVC environment on windows, otherwise we get minsys2 / gcc
+      - uses: ilammy/msvc-dev-cmd@v1
 
       - name: 'Install ubuntu dependencies'
         if: matrix.os == 'ubuntu-latest'
diff --git a/include/adm/document.hpp b/include/adm/document.hpp
index 3e605782..34d52436 100644
--- a/include/adm/document.hpp
+++ b/include/adm/document.hpp
@@ -20,19 +20,29 @@ namespace adm {
   namespace detail {
     extern template class ADM_EXPORT_TEMPLATE_METHODS
         OptionalParameter<Version>;
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        OptionalParameter<TagList>;
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        OptionalParameter<ProfileList>;
 
-    using DocumentBase = HasParameters<OptionalParameter<Version>>;
+    using DocumentBase =
+        HasParameters<OptionalParameter<Version>, OptionalParameter<TagList>,
+                      OptionalParameter<ProfileList>>;
   }  // namespace detail
 
   /**
    * @brief Class representation of a whole ADM document
    *
    * \rst
-   * +---------------+-----------------+----------------------------+
-   * | ADM Parameter | Parameter Type  | Pattern Type               |
-   * +===============+=================+============================+
-   * | version       | :type:`Version` | :class:`OptionalParameter` |
-   * +---------------+-----------------+----------------------------+
+   * +---------------+---------------------+----------------------------+
+   * | ADM Parameter | Parameter Type      | Pattern Type               |
+   * +===============+=====================+============================+
+   * | version       | :type:`Version`     | :class:`OptionalParameter` |
+   * +---------------+---------------------+----------------------------+
+   * | tagList       | :type:`TagList`     | :class:`OptionalParameter` |
+   * +---------------+---------------------+----------------------------+
+   * | profileList   | :type:`ProfileList` | :class:`OptionalParameter` |
+   * +---------------+---------------------+----------------------------+
    * \endrst
    *
    * Note that:
@@ -86,6 +96,15 @@ namespace adm {
      *
      * References from and to the ADM element will automatically be removed
      * too.
+     *
+     * Additional side effects:
+     * - removing an AudioProgramme, AudioContent, or AudioObject prunes
+     *   TagGroup entries in tagList that reference the removed element
+     * - If the TagList becomes empty due to pruning, the list itself is
+     *   removed as it is only valid when it contains 1 or more TagGroups
+     * - removing an AudioPackFormat or AudioObject also removes matching
+     *   renderer/referenceLayout ID references in nested
+     *   authoringInformation/loudnessMetadata structures.
      */
     ///@{
     /// @brief Remove an AudioProgramme
@@ -236,6 +255,23 @@ namespace adm {
     using detail::AddWrapperMethods<Document>::isDefault;
     using detail::AddWrapperMethods<Document>::unset;
 
+    /**
+     * @brief Set the document's tagList.
+     *
+     * Each TagGroup's audioProgramme/audioContent/audioObject references are
+     * validated against the document:
+     *   * if a referenced element already belongs to a *different* document,
+     *     the document is left unmodified and `false` is returned;
+     *   * if a referenced element is not yet attached to any document, it is
+     *     added to this document (mirroring the auto-add behaviour of
+     *     `Document::add(...)` for nested references);
+     *   * elements already belonging to this document are left untouched.
+     *
+     * @return `true` on success, `false` if any reference belongs to another
+     * document.
+     */
+    ADM_EXPORT bool set(TagList tagList);
+
    private:
     ADM_EXPORT Document();
     ADM_EXPORT Document(const Document &) = default;
@@ -316,5 +352,4 @@ namespace adm {
     typedef typename detail::ParameterTraits<Element>::tag Tag;
     return getElements(Tag());
   }
-
 }  // namespace adm
diff --git a/include/adm/elements.hpp b/include/adm/elements.hpp
index 9fdf9366..87aa24b1 100644
--- a/include/adm/elements.hpp
+++ b/include/adm/elements.hpp
@@ -27,6 +27,7 @@
 #include "adm/elements/audio_stream_format.hpp"
 #include "adm/elements/audio_track_uid.hpp"
 #include "adm/elements/profile_list.hpp"
+#include "adm/elements/tag_list.hpp"
 
 #include "adm/elements/audio_block_format_direct_speakers.hpp"
 #include "adm/elements/audio_block_format_matrix.hpp"
@@ -48,6 +49,8 @@
 
 #include "adm/elements/time.hpp"
 #include "adm/elements/audio_programme_ref_screen.hpp"
+#include "adm/elements/authoring_information.hpp"
+#include "adm/elements/cartesian.hpp"
 #include "adm/elements/channel_lock.hpp"
 #include "adm/elements/dialogue.hpp"
 #include "adm/elements/format_descriptor.hpp"
diff --git a/include/adm/elements/audio_block_format_direct_speakers.hpp b/include/adm/elements/audio_block_format_direct_speakers.hpp
index 59faba92..bfd1618e 100644
--- a/include/adm/elements/audio_block_format_direct_speakers.hpp
+++ b/include/adm/elements/audio_block_format_direct_speakers.hpp
@@ -68,6 +68,8 @@ namespace adm {
    * +---------------------+------------------------------------+----------------------------+
    * | initializeBlock     | :type:`InitializeBlock`            | :class:`OptionalParameter` |
    * +---------------------+------------------------------------+----------------------------+
+  * | cartesian           | :type:`Cartesian`                  | custom, see below          |
+  * +---------------------+------------------------------------+----------------------------+
    * | position            | - :type:`SpeakerPosition`          | :class:`VariantParameter`  |
    * |                     | - :type:`SphericalSpeakerPosition` |                            |
    * |                     | - :type:`CartesianSpeakerPosition` | :class:`RequiredParameter` |
@@ -83,6 +85,11 @@ namespace adm {
    * | speakerLabel        | :type:`SpeakerLabels`              | :class:`VectorParameter`   |
    * +---------------------+------------------------------------+----------------------------+
    * \endrst
+  *
+  * ``cartesian`` and ``position`` attributes are linked; see
+  * :func:`void set(Cartesian)`, :func:`void set(SpeakerPosition)`,
+  * :func:`void set(CartesianSpeakerPosition)` and
+  * :func:`void set(SphericalSpeakerPosition)`.
    *
    * @warning not all methods are implemented for speakerLabel
    */
@@ -138,6 +145,8 @@ namespace adm {
     ADM_EXPORT void set(Rtime rtime);
     /// @brief Duration setter
     ADM_EXPORT void set(Duration duration);
+    /// @brief Cartesian setter
+    ADM_EXPORT void set(Cartesian cartesian);
     /// @brief CartesianSpeakerPosition setter
     ADM_EXPORT void set(CartesianSpeakerPosition speakerPosition);
     /// @brief SphericalSpeakerPosition setter
@@ -174,6 +183,7 @@ namespace adm {
     ADM_EXPORT Duration get(detail::ParameterTraits<Duration>::tag) const;
     ADM_EXPORT SpeakerLabels
         get(detail::ParameterTraits<SpeakerLabels>::tag) const;
+    ADM_EXPORT Cartesian get(detail::ParameterTraits<Cartesian>::tag) const;
     ADM_EXPORT CartesianSpeakerPosition
         get(detail::ParameterTraits<CartesianSpeakerPosition>::tag) const;
     ADM_EXPORT SphericalSpeakerPosition
@@ -183,6 +193,7 @@ namespace adm {
     ADM_EXPORT bool has(detail::ParameterTraits<Rtime>::tag) const;
     ADM_EXPORT bool has(detail::ParameterTraits<Duration>::tag) const;
     ADM_EXPORT bool has(detail::ParameterTraits<SpeakerLabels>::tag) const;
+    ADM_EXPORT bool has(detail::ParameterTraits<Cartesian>::tag) const;
     ADM_EXPORT bool has(
         detail::ParameterTraits<CartesianSpeakerPosition>::tag) const;
     ADM_EXPORT bool has(
@@ -192,15 +203,18 @@ namespace adm {
     bool isDefault(Tag) const {
       return false;
     }
+    ADM_EXPORT bool isDefault(detail::ParameterTraits<Cartesian>::tag) const;
 
     ADM_EXPORT void unset(detail::ParameterTraits<Rtime>::tag);
     ADM_EXPORT void unset(detail::ParameterTraits<Duration>::tag);
     ADM_EXPORT void unset(detail::ParameterTraits<SpeakerLabels>::tag);
+    ADM_EXPORT void unset(detail::ParameterTraits<Cartesian>::tag);
 
     AudioBlockFormatId id_;
     boost::optional<Rtime> rtime_;
     boost::optional<Duration> duration_;
     SpeakerLabels speakerLabels_;
+    boost::optional<Cartesian> cartesian_;
     SpeakerPosition speakerPosition_;
   };
 
diff --git a/include/adm/elements/audio_block_format_objects.hpp b/include/adm/elements/audio_block_format_objects.hpp
index 4c57faeb..afdd4a8e 100644
--- a/include/adm/elements/audio_block_format_objects.hpp
+++ b/include/adm/elements/audio_block_format_objects.hpp
@@ -18,11 +18,6 @@
 namespace adm {
 
   class Document;
-
-  /// @brief Tag for NamedType ::Cartesian
-  struct CartesianTag {};
-  /// @brief NamedType for cartesian parameter
-  using Cartesian = detail::NamedType<bool, CartesianTag>;
   /// @brief Tag for NamedType ::Width
   struct WidthTag {};
   /// @brief NamedType for width parameter
diff --git a/include/adm/elements/audio_channel_format.hpp b/include/adm/elements/audio_channel_format.hpp
index 45df467e..aa474157 100644
--- a/include/adm/elements/audio_channel_format.hpp
+++ b/include/adm/elements/audio_channel_format.hpp
@@ -381,7 +381,7 @@ namespace adm {
       return previous == 0u || current == previous.get() + 1u;
     }
   }
-
+  
   template <typename BlockFormat>
   void AudioChannelFormat::assignId(BlockFormat &blockFormat,
                                     BlockFormat *previousBlock) {
diff --git a/include/adm/elements/audio_programme.hpp b/include/adm/elements/audio_programme.hpp
index a1728aa2..f29dd88f 100644
--- a/include/adm/elements/audio_programme.hpp
+++ b/include/adm/elements/audio_programme.hpp
@@ -9,6 +9,7 @@
 #include "adm/elements/audio_content.hpp"
 #include "adm/elements/audio_programme_id.hpp"
 #include "adm/elements/audio_programme_ref_screen.hpp"
+#include "adm/elements/authoring_information.hpp"
 #include "adm/elements/loudness_metadata.hpp"
 #include "adm/elements_fwd.hpp"
 #include "adm/helper/element_range.hpp"
@@ -158,6 +159,8 @@ namespace adm {
     ADM_EXPORT void set(MaxDuckingDepth depth);
     /// @brief AudioProgrammeReferenceScreen setter
     ADM_EXPORT void set(AudioProgrammeReferenceScreen refScreen);
+    /// @brief AuthoringInformation setter
+    ADM_EXPORT void set(AuthoringInformation authoringInformation);
 
     /**
      * @brief ADM parameter unset template
@@ -237,6 +240,8 @@ namespace adm {
         get(detail::ParameterTraits<MaxDuckingDepth>::tag) const;
     ADM_EXPORT AudioProgrammeReferenceScreen
         get(detail::ParameterTraits<AudioProgrammeReferenceScreen>::tag) const;
+    ADM_EXPORT AuthoringInformation
+        get(detail::ParameterTraits<AuthoringInformation>::tag) const;
 
     ADM_EXPORT bool has(detail::ParameterTraits<AudioProgrammeId>::tag) const;
     ADM_EXPORT bool has(detail::ParameterTraits<AudioProgrammeName>::tag) const;
@@ -247,6 +252,8 @@ namespace adm {
     ADM_EXPORT bool has(detail::ParameterTraits<MaxDuckingDepth>::tag) const;
     ADM_EXPORT bool has(
         detail::ParameterTraits<AudioProgrammeReferenceScreen>::tag) const;
+    ADM_EXPORT bool has(
+        detail::ParameterTraits<AuthoringInformation>::tag) const;
 
     template <typename Tag>
     bool isDefault(Tag) const {
@@ -261,6 +268,7 @@ namespace adm {
     ADM_EXPORT void unset(detail::ParameterTraits<MaxDuckingDepth>::tag);
     ADM_EXPORT void unset(
         detail::ParameterTraits<AudioProgrammeReferenceScreen>::tag);
+    ADM_EXPORT void unset(detail::ParameterTraits<AuthoringInformation>::tag);
 
     ADM_EXPORT ElementRange<const AudioContent> getReferences(
         detail::ParameterTraits<AudioContent>::tag) const;
@@ -283,6 +291,7 @@ namespace adm {
     std::vector<std::shared_ptr<AudioContent>> audioContents_;
     boost::optional<MaxDuckingDepth> maxDuckingDepth_;
     boost::optional<AudioProgrammeReferenceScreen> refScreen_;
+    boost::optional<AuthoringInformation> authoringInformation_;
   };
   ///@}
 
diff --git a/include/adm/elements/audio_programme_ref_screen.hpp b/include/adm/elements/audio_programme_ref_screen.hpp
index 5b44673e..8a0b6bbc 100644
--- a/include/adm/elements/audio_programme_ref_screen.hpp
+++ b/include/adm/elements/audio_programme_ref_screen.hpp
@@ -1,20 +1,51 @@
 #pragma once
 #include <ostream>
+#include "adm/detail/auto_base.hpp"
+#include "adm/detail/named_option_helper.hpp"
+#include "adm/elements/coordinate_mode.hpp"
+#include "adm/export.h"
 
 namespace adm {
 
   struct AudioProgrammeReferenceScreenTag {};
 
-  class AudioProgrammeReferenceScreen {
+  namespace detail {
+    using AudioProgrammeReferenceScreenBase =
+        HasParameters<OptionalParameter<CoordinateMode>>;
+  }  // namespace detail
+
+  class AudioProgrammeReferenceScreen
+      : private detail::AudioProgrammeReferenceScreenBase,
+        private detail::AddWrapperMethods<AudioProgrammeReferenceScreen> {
    public:
-    typedef AudioProgrammeReferenceScreenTag tag;
+    using tag = AudioProgrammeReferenceScreenTag;
+
+    template <typename... Parameters>
+    explicit AudioProgrammeReferenceScreen(Parameters... namedArgs) {
+      detail::setNamedOptionHelper(this, std::move(namedArgs)...);
+    }
+
+    using detail::AudioProgrammeReferenceScreenBase::set;
+    using detail::AddWrapperMethods<AudioProgrammeReferenceScreen>::get;
+    using detail::AddWrapperMethods<AudioProgrammeReferenceScreen>::has;
+    using detail::AddWrapperMethods<AudioProgrammeReferenceScreen>::isDefault;
+    using detail::AddWrapperMethods<AudioProgrammeReferenceScreen>::unset;
+
+    void print(std::ostream &os) const {
+      os << "(";
+      if (has<CoordinateMode>()) {
+        os << "coordinateMode=" << get<CoordinateMode>();
+      }
+      os << ")";
+    }
 
-    AudioProgrammeReferenceScreen() {}
+   private:
+    using detail::AudioProgrammeReferenceScreenBase::get;
+    using detail::AudioProgrammeReferenceScreenBase::has;
+    using detail::AudioProgrammeReferenceScreenBase::isDefault;
+    using detail::AudioProgrammeReferenceScreenBase::unset;
 
-    /**
-     * @brief Print overview to ostream
-     */
-    void print(std::ostream &os) const { os << "()"; };
+    friend class detail::AddWrapperMethods<AudioProgrammeReferenceScreen>;
   };
 
 }  // namespace adm
diff --git a/include/adm/elements/authoring_information.hpp b/include/adm/elements/authoring_information.hpp
new file mode 100644
index 00000000..e274ca71
--- /dev/null
+++ b/include/adm/elements/authoring_information.hpp
@@ -0,0 +1,184 @@
+/// @file authoring_information.hpp
+#pragma once
+
+#include <ostream>
+#include <vector>
+
+#include "adm/detail/auto_base.hpp"
+#include "adm/detail/named_option_helper.hpp"
+#include "adm/detail/named_type.hpp"
+#include "adm/detail/optional_comparison.hpp"
+#include "adm/elements/renderer_common_types.hpp"
+#include "adm/export.h"
+
+namespace adm {
+
+  class LoudnessRenderer;
+
+  /// @brief Tag for ::ReferenceLayout named-type
+  struct ReferenceLayoutTag {};
+  /**
+   * @brief Reference to audioPackFormat used by a referenceLayout
+   * sub-element of authoringInformation (BS.2076-3 Table A1-51).
+   */
+  class ReferenceLayout {
+   public:
+    using tag = ReferenceLayoutTag;
+
+    ReferenceLayout() = default;
+    explicit ReferenceLayout(std::shared_ptr<AudioPackFormat> packFormat)
+        : packFormat_(std::move(packFormat)) {}
+
+    std::shared_ptr<AudioPackFormat> const &get() const { return packFormat_; }
+
+   private:
+    std::shared_ptr<AudioPackFormat> packFormat_;
+  };
+
+  ADD_TRAIT(ReferenceLayout, ReferenceLayoutTag);
+
+  inline bool operator==(ReferenceLayout const &lhs,
+                         ReferenceLayout const &rhs) {
+    return lhs.get() == rhs.get();
+  }
+  inline bool operator!=(ReferenceLayout const &lhs,
+                         ReferenceLayout const &rhs) {
+    return !(lhs == rhs);
+  }
+
+  /// @brief Vector of ReferenceLayout
+  using ReferenceLayouts = std::vector<ReferenceLayout>;
+  ADD_TRAIT(ReferenceLayouts, ReferenceLayoutsTag);
+
+  /// @brief Tag for Renderer class
+  struct RendererTag {};
+
+  namespace detail {
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        VectorParameter<RendererPackFormatIdRefs>;
+
+    using RendererBase = HasParameters<
+        RequiredParameter<RendererUri>, OptionalParameter<RendererName>,
+        OptionalParameter<RendererVersion>, OptionalParameter<CoordinateMode>,
+        VectorParameter<RendererPackFormatIdRefs>>;
+  }  // namespace detail
+
+  /**
+   * @brief Class representation of the renderer sub-element of an
+   * authoringInformation element (BS.2076-3 Tables A1-52 / A1-53).
+   */
+  class AuthoringRenderer
+      : private detail::RendererBase,
+        private detail::AddWrapperMethods<AuthoringRenderer> {
+   public:
+    using tag = RendererTag;
+
+    template <typename... Parameters>
+    explicit AuthoringRenderer(RendererUri uri, Parameters... namedArgs) {
+      this->set(std::move(uri));
+      detail::setNamedOptionHelper(this, std::move(namedArgs)...);
+    }
+
+    using detail::RendererBase::add;
+    using detail::RendererBase::remove;
+    using detail::RendererBase::set;
+    using detail::AddWrapperMethods<AuthoringRenderer>::get;
+    using detail::AddWrapperMethods<AuthoringRenderer>::has;
+    using detail::AddWrapperMethods<AuthoringRenderer>::isDefault;
+    using detail::AddWrapperMethods<AuthoringRenderer>::unset;
+
+    /// @brief Convert to LoudnessRenderer preserving all shared parameters.
+    ADM_EXPORT LoudnessRenderer toLoudnessRenderer() const;
+
+    ADM_EXPORT void print(std::ostream &os) const;
+
+   private:
+    using detail::RendererBase::get;
+    using detail::RendererBase::has;
+    using detail::RendererBase::isDefault;
+    using detail::RendererBase::unset;
+
+    friend class detail::AddWrapperMethods<AuthoringRenderer>;
+  };
+
+  ADD_TRAIT(AuthoringRenderer, RendererTag);
+
+  inline bool operator==(const AuthoringRenderer &a,
+                         const AuthoringRenderer &b) {
+    if (!detail::optionalsEqual<RendererUri, RendererName, RendererVersion,
+                                CoordinateMode>(a, b)) {
+      return false;
+    }
+
+    if (a.has<RendererPackFormatIdRefs>() !=
+        b.has<RendererPackFormatIdRefs>()) {
+      return false;
+    }
+
+    if (!a.has<RendererPackFormatIdRefs>()) {
+      return true;
+    }
+
+    return a.get<RendererPackFormatIdRefs>() ==
+           b.get<RendererPackFormatIdRefs>();
+  }
+  inline bool operator!=(const AuthoringRenderer &a,
+                         const AuthoringRenderer &b) {
+    return !(a == b);
+  }
+
+  /// @brief Vector of Renderer
+  using Renderers = std::vector<AuthoringRenderer>;
+  ADD_TRAIT(Renderers, RenderersTag);
+
+  /// @brief Tag for AuthoringInformation class
+  struct AuthoringInformationTag {};
+
+  namespace detail {
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        VectorParameter<ReferenceLayouts>;
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        VectorParameter<Renderers>;
+
+    using AuthoringInformationBase =
+        HasParameters<VectorParameter<ReferenceLayouts>,
+                      VectorParameter<Renderers>>;
+  }  // namespace detail
+
+  /**
+   * @brief Class representation of the authoringInformation sub-element of an
+   * audioProgramme element (BS.2076-3 §5.8.6).
+   */
+  class AuthoringInformation
+      : private detail::AuthoringInformationBase,
+        private detail::AddWrapperMethods<AuthoringInformation> {
+   public:
+    using tag = AuthoringInformationTag;
+
+    template <typename... Parameters>
+    explicit AuthoringInformation(Parameters... namedArgs) {
+      detail::setNamedOptionHelper(this, std::move(namedArgs)...);
+    }
+
+    using detail::AuthoringInformationBase::add;
+    using detail::AuthoringInformationBase::remove;
+    using detail::AuthoringInformationBase::set;
+    using detail::AddWrapperMethods<AuthoringInformation>::get;
+    using detail::AddWrapperMethods<AuthoringInformation>::has;
+    using detail::AddWrapperMethods<AuthoringInformation>::isDefault;
+    using detail::AddWrapperMethods<AuthoringInformation>::unset;
+
+    ADM_EXPORT void print(std::ostream &os) const;
+
+   private:
+    using detail::AuthoringInformationBase::get;
+    using detail::AuthoringInformationBase::has;
+    using detail::AuthoringInformationBase::isDefault;
+    using detail::AuthoringInformationBase::unset;
+
+    friend class detail::AddWrapperMethods<AuthoringInformation>;
+  };
+
+  ADD_TRAIT(AuthoringInformation, AuthoringInformationTag);
+
+}  // namespace adm
diff --git a/include/adm/elements/cartesian.hpp b/include/adm/elements/cartesian.hpp
new file mode 100644
index 00000000..bce91911
--- /dev/null
+++ b/include/adm/elements/cartesian.hpp
@@ -0,0 +1,11 @@
+/// @file cartesian.hpp
+#pragma once
+
+#include "adm/detail/named_type.hpp"
+
+namespace adm {
+  /// @brief Tag for NamedType ::Cartesian
+  struct CartesianTag {};
+  /// @brief NamedType for cartesian parameter
+  using Cartesian = detail::NamedType<bool, CartesianTag>;
+}  // namespace adm
diff --git a/include/adm/elements/common_parameters.hpp b/include/adm/elements/common_parameters.hpp
index 84a03c9e..ebf58446 100644
--- a/include/adm/elements/common_parameters.hpp
+++ b/include/adm/elements/common_parameters.hpp
@@ -1,6 +1,7 @@
 #pragma once
 #include "adm/detail/auto_base.hpp"
 #include "adm/elements/audio_block_format_id.hpp"
+#include "adm/elements/cartesian.hpp"
 #include "adm/elements/gain.hpp"
 #include "adm/elements/headphone_virtualise.hpp"
 #include "adm/elements/head_locked.hpp"
diff --git a/include/adm/elements/coordinate_mode.hpp b/include/adm/elements/coordinate_mode.hpp
new file mode 100644
index 00000000..2a6cce85
--- /dev/null
+++ b/include/adm/elements/coordinate_mode.hpp
@@ -0,0 +1,16 @@
+/// @file coordinate_mode.hpp
+#pragma once
+
+#include <string>
+#include "adm/detail/named_type.hpp"
+
+namespace adm {
+
+  /// @brief Tag for NamedType ::CoordinateMode
+  struct CoordinateModeTag {};
+  /// @brief NamedType for the coordinateMode attribute
+  ///
+  /// Allowable values are "polar" or "cartesian".
+  using CoordinateMode = detail::NamedType<std::string, CoordinateModeTag>;
+
+}  // namespace adm
diff --git a/include/adm/elements/dialogue.hpp b/include/adm/elements/dialogue.hpp
index 337dc470..c7974e9c 100644
--- a/include/adm/elements/dialogue.hpp
+++ b/include/adm/elements/dialogue.hpp
@@ -36,7 +36,7 @@ namespace adm {
    */
   using NonDialogueContentKind =
       detail::NamedType<unsigned int, NonDialogueContentKindTag,
-                        detail::RangeValidator<0, 2>>;
+                        detail::RangeValidator<0, 3>>;
 
   /// NonDialogueContentKind definitions
   namespace NonDialogueContent {
@@ -45,6 +45,8 @@ namespace adm {
     const NonDialogueContentKind MUSIC = NonDialogueContentKind(1);
     /// NonDialogueContentKind for effects
     const NonDialogueContentKind EFFECT = NonDialogueContentKind(2);
+    /// NonDialogueContentKind for music and effects
+    const NonDialogueContentKind MUSIC_AND_EFFECTS = NonDialogueContentKind(3);
   }  // namespace NonDialogueContent
 
   /// @brief Tag for NamedType ::DialogueContentKind
@@ -80,10 +82,10 @@ namespace adm {
   /**
    * @brief NamedType for the mixedContentKind type
    *
-   * Valid values are in the range [0, 3]
+   * Valid values are in the range [0, 4]
    */
   using MixedContentKind = detail::NamedType<unsigned int, MixedContentKindTag,
-                                             detail::RangeValidator<0, 3>>;
+                                             detail::RangeValidator<0, 4>>;
 
   /// MixedContent definitions
   namespace MixedContent {
@@ -94,6 +96,9 @@ namespace adm {
     const MixedContentKind MIXED = MixedContentKind(2);
     /// MixedContentKind for hearing impaired
     const MixedContentKind HEARING_IMPAIRED = MixedContentKind(3);
+    /// MixedContentKind for complete main with audio description/hearing impaired
+    const MixedContentKind COMPLETE_MAIN_HEARING_IMPAIRED_AD =
+        MixedContentKind(4);
   }  // namespace MixedContent
 
   ///@brief Type to hold a NonDialogueContentKind, DialogueContentKind or
diff --git a/include/adm/elements/loudness_metadata.hpp b/include/adm/elements/loudness_metadata.hpp
index e0ef37e1..90e3727e 100644
--- a/include/adm/elements/loudness_metadata.hpp
+++ b/include/adm/elements/loudness_metadata.hpp
@@ -3,6 +3,7 @@
 #include "adm/detail/named_type.hpp"
 #include "adm/detail/auto_base.hpp"
 #include "adm/detail/optional_comparison.hpp"
+#include "adm/elements/loudness_renderer.hpp"
 #include "adm/export.h"
 #include <boost/optional.hpp>
 #include <string>
@@ -11,6 +12,8 @@
 
 namespace adm {
 
+  class AuthoringRenderer;
+
   /// @brief Tag for NamedType ::LoudnessMethod
   struct loudnessMethodTag {};
   /// @brief NamedType for loudnessMethod parameter
@@ -115,6 +118,10 @@ namespace adm {
     ADM_EXPORT void set(MaxShortTerm maxShortTerm);
     /// @brief DialogueLoudness setter
     ADM_EXPORT void set(DialogueLoudness dialogueLoudness);
+    /// @brief LoudnessRenderer setter
+    ADM_EXPORT void set(LoudnessRenderer renderer);
+    /// @brief Renderer setter (converted to LoudnessRenderer)
+    ADM_EXPORT void set(AuthoringRenderer renderer);
 
     /**
      * @brief ADM parameter unset template
@@ -149,6 +156,8 @@ namespace adm {
         get(detail::ParameterTraits<MaxShortTerm>::tag) const;
     ADM_EXPORT DialogueLoudness
         get(detail::ParameterTraits<DialogueLoudness>::tag) const;
+    ADM_EXPORT LoudnessRenderer
+        get(detail::ParameterTraits<LoudnessRenderer>::tag) const;
 
     ADM_EXPORT bool has(detail::ParameterTraits<LoudnessMethod>::tag) const;
     ADM_EXPORT bool has(detail::ParameterTraits<LoudnessRecType>::tag) const;
@@ -160,6 +169,7 @@ namespace adm {
     ADM_EXPORT bool has(detail::ParameterTraits<MaxMomentary>::tag) const;
     ADM_EXPORT bool has(detail::ParameterTraits<MaxShortTerm>::tag) const;
     ADM_EXPORT bool has(detail::ParameterTraits<DialogueLoudness>::tag) const;
+    ADM_EXPORT bool has(detail::ParameterTraits<LoudnessRenderer>::tag) const;
 
     template <typename Tag>
     bool isDefault(Tag) const {
@@ -175,6 +185,7 @@ namespace adm {
     ADM_EXPORT void unset(detail::ParameterTraits<MaxMomentary>::tag);
     ADM_EXPORT void unset(detail::ParameterTraits<MaxShortTerm>::tag);
     ADM_EXPORT void unset(detail::ParameterTraits<DialogueLoudness>::tag);
+    ADM_EXPORT void unset(detail::ParameterTraits<LoudnessRenderer>::tag);
 
     boost::optional<LoudnessMethod> loudnessMethod_;
     boost::optional<LoudnessRecType> loudnessRecType_;
@@ -185,6 +196,7 @@ namespace adm {
     boost::optional<MaxMomentary> maxMomentary_;
     boost::optional<MaxShortTerm> maxShortTerm_;
     boost::optional<DialogueLoudness> dialogueLoudness_;
+    boost::optional<LoudnessRenderer> renderer_;
   };
 
   // ---- Implementation ---- //
diff --git a/include/adm/elements/loudness_renderer.hpp b/include/adm/elements/loudness_renderer.hpp
new file mode 100644
index 00000000..3f9cb43f
--- /dev/null
+++ b/include/adm/elements/loudness_renderer.hpp
@@ -0,0 +1,83 @@
+/// @file loudness_renderer.hpp
+#pragma once
+
+#include <ostream>
+
+#include "adm/detail/auto_base.hpp"
+#include "adm/detail/named_option_helper.hpp"
+#include "adm/elements/renderer_common_types.hpp"
+#include "adm/export.h"
+
+namespace adm {
+
+  class AuthoringRenderer;
+
+  /// @brief Tag for LoudnessRenderer class
+  struct LoudnessRendererTag {};
+
+  namespace detail {
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        OptionalParameter<RendererUri>;
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        OptionalParameter<RendererName>;
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        OptionalParameter<RendererVersion>;
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        OptionalParameter<CoordinateMode>;
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        VectorParameter<RendererPackFormatIdRefs>;
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        VectorParameter<RendererObjectIdRefs>;
+
+    using LoudnessRendererBase = HasParameters<
+        OptionalParameter<RendererUri>, OptionalParameter<RendererName>,
+        OptionalParameter<RendererVersion>, OptionalParameter<CoordinateMode>,
+        VectorParameter<RendererPackFormatIdRefs>,
+        VectorParameter<RendererObjectIdRefs>>;
+  }  // namespace detail
+
+  /**
+   * @brief Class representation of the renderer sub-element of a
+   * loudnessMetadata element (BS.2076-3 Tables A1-39 / A1-40).
+   */
+  class LoudnessRenderer : private detail::LoudnessRendererBase,
+                           private detail::AddWrapperMethods<LoudnessRenderer> {
+   public:
+    using tag = LoudnessRendererTag;
+
+    template <typename... Parameters>
+    explicit LoudnessRenderer(Parameters... namedArgs) {
+      detail::setNamedOptionHelper(this, std::move(namedArgs)...);
+    }
+
+    using detail::LoudnessRendererBase::add;
+    using detail::LoudnessRendererBase::remove;
+    using detail::LoudnessRendererBase::set;
+    using detail::AddWrapperMethods<LoudnessRenderer>::get;
+    using detail::AddWrapperMethods<LoudnessRenderer>::has;
+    using detail::AddWrapperMethods<LoudnessRenderer>::isDefault;
+    using detail::AddWrapperMethods<LoudnessRenderer>::unset;
+
+    /// @brief Create a LoudnessRenderer from an authoring Renderer.
+    ADM_EXPORT static LoudnessRenderer fromRenderer(
+        AuthoringRenderer const& renderer);
+
+    /// @brief Convert to Renderer, using provided uri and explicitly dropping audioObjectIDRef values.
+    /// uri is required as it is optional in a Loudness renderer but required in authoring renderer
+    ADM_EXPORT AuthoringRenderer
+    toRendererDroppingObjectRefs(RendererUri uri) const;
+
+    ADM_EXPORT void print(std::ostream& os) const;
+
+   private:
+    using detail::LoudnessRendererBase::get;
+    using detail::LoudnessRendererBase::has;
+    using detail::LoudnessRendererBase::isDefault;
+    using detail::LoudnessRendererBase::unset;
+
+    friend class detail::AddWrapperMethods<LoudnessRenderer>;
+  };
+
+  ADD_TRAIT(LoudnessRenderer, LoudnessRendererTag);
+
+}  // namespace adm
diff --git a/include/adm/elements/profile_list.hpp b/include/adm/elements/profile_list.hpp
index a49faf0d..ec19a79e 100644
--- a/include/adm/elements/profile_list.hpp
+++ b/include/adm/elements/profile_list.hpp
@@ -85,12 +85,12 @@ namespace adm {
     using ProfileListBase = HasParameters<VectorParameter<Profiles>>;
   }  // namespace detail
 
-  struct ProfileceListTag {};
+  struct ProfileListTag {};
 
   class ProfileList : private detail::ProfileListBase,
                       private detail::AddWrapperMethods<ProfileList> {
    public:
-    using tag = ProfileceListTag;
+    using tag = ProfileListTag;
 
     template <typename... Parameters>
     explicit ProfileList(Parameters... namedArgs) {
diff --git a/include/adm/elements/renderer_common_types.hpp b/include/adm/elements/renderer_common_types.hpp
new file mode 100644
index 00000000..e141c090
--- /dev/null
+++ b/include/adm/elements/renderer_common_types.hpp
@@ -0,0 +1,58 @@
+/// @file renderer_common_types.hpp
+#pragma once
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "adm/detail/auto_base.hpp"
+#include "adm/detail/named_type.hpp"
+#include "adm/elements/coordinate_mode.hpp"
+#include "adm/elements_fwd.hpp"
+
+namespace adm {
+
+  /// @brief Tag for NamedType ::RendererUri
+  struct RendererUriTag {};
+  /// @brief NamedType for the renderer uri attribute
+  using RendererUri = detail::NamedType<std::string, RendererUriTag>;
+
+  /// @brief Tag for NamedType ::RendererName
+  struct RendererNameTag {};
+  /// @brief NamedType for the renderer name attribute
+  using RendererName = detail::NamedType<std::string, RendererNameTag>;
+
+  /// @brief Tag for NamedType ::RendererVersion
+  struct RendererVersionTag {};
+  /// @brief NamedType for the renderer version attribute
+  using RendererVersion = detail::NamedType<std::string, RendererVersionTag>;
+
+  /// @brief Vector of audioPackFormat references used by a renderer
+  using RendererPackFormatIdRefs =
+      std::vector<std::shared_ptr<AudioPackFormat>>;
+  ADD_TRAIT(RendererPackFormatIdRefs, RendererPackFormatIdRefsTag);
+
+  /// @brief Vector of audioObject references used by a renderer
+  using RendererObjectIdRefs = std::vector<std::shared_ptr<AudioObject>>;
+  ADD_TRAIT(RendererObjectIdRefs, RendererObjectIdRefsTag);
+
+  namespace detail {
+    template <>
+    struct ParameterCompare<RendererPackFormatIdRefs> {
+      static bool compare(RendererPackFormatIdRefs const& lhs,
+                          RendererPackFormatIdRefs const& rhs) {
+        return lhs == rhs;
+      }
+    };
+
+    template <>
+    struct ParameterCompare<RendererObjectIdRefs> {
+      static bool compare(RendererObjectIdRefs const& lhs,
+                          RendererObjectIdRefs const& rhs) {
+        return lhs == rhs;
+      }
+    };
+  }  // namespace detail
+
+}  // namespace adm
diff --git a/include/adm/elements/tag_list.hpp b/include/adm/elements/tag_list.hpp
new file mode 100644
index 00000000..136fe469
--- /dev/null
+++ b/include/adm/elements/tag_list.hpp
@@ -0,0 +1,300 @@
+#pragma once
+#include <vector>
+#include "adm/detail/auto_base.hpp"
+#include "adm/elements/audio_programme.hpp"
+#include "adm/elements_fwd.hpp"
+#include "adm/detail/named_option_helper.hpp"
+#include "adm/detail/optional_comparison.hpp"
+#include "adm/errors.hpp"
+
+namespace adm {
+
+  class TagList;
+
+  struct TagValueTag {};
+  using TagValue = detail::NamedType<std::string, TagValueTag>;
+
+  struct TagClassTag {};
+  using TagClass = detail::NamedType<std::string, TagClassTag>;
+
+  struct TagTag {};
+
+  namespace detail {
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        RequiredParameter<TagValue>;
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        OptionalParameter<TagClass>;
+
+    using TagBase =
+        HasParameters<RequiredParameter<TagValue>, OptionalParameter<TagClass>>;
+  }  // namespace detail
+
+  class Tag : private detail::TagBase, private detail::AddWrapperMethods<Tag> {
+   public:
+    using tag = TagTag;
+
+    template <typename... Parameters>
+    explicit Tag(Parameters... namedArgs) {
+      detail::setNamedOptionHelper(this, std::move(namedArgs)...);
+    }
+
+    ADM_EXPORT explicit Tag(std::string str) : Tag(TagValue(std::move(str))) {}
+    ADM_EXPORT explicit Tag(const char *s);
+
+    ADM_EXPORT void print(std::ostream &os) const;
+
+    using detail::TagBase::set;
+    using detail::TagBase::unset;
+    using detail::AddWrapperMethods<Tag>::get;
+    using detail::AddWrapperMethods<Tag>::has;
+    using detail::AddWrapperMethods<Tag>::isDefault;
+    using detail::AddWrapperMethods<Tag>::unset;
+
+   private:
+    using detail::TagBase::get;
+    using detail::TagBase::has;
+
+    friend class detail::AddWrapperMethods<Tag>;
+  };
+
+  struct TagsTag {};
+
+  using Tags = std::vector<Tag>;
+  ADD_TRAIT(Tags, TagsTag);
+
+  inline bool operator==(const Tag &a, const Tag &b) {
+    return detail::optionalsEqual<TagValue, TagClass>(a, b);
+  }
+
+  inline bool operator!=(const Tag &a, const Tag &b) { return !(a == b); }
+
+  struct TagGroupTag {};
+
+  namespace detail {
+    extern template class ADM_EXPORT_TEMPLATE_METHODS VectorParameter<Tags>;
+
+    using TagGroupBase = HasParameters<VectorParameter<Tags>>;
+  }  // namespace detail
+
+  class TagGroup : private detail::TagGroupBase,
+                   private detail::AddWrapperMethods<TagGroup> {
+   public:
+    enum class RemoveResult {
+      Success,
+      LastReferenceError,  // A TagGroup must always have at least one reference
+      NotFound
+    };
+    using tag = TagGroupTag;
+
+    TagGroup() = default;
+
+    template <typename... Parameters>
+    explicit TagGroup(std::shared_ptr<AudioObject> const &reference,
+                      Parameters... namedArgs) {
+      addReference(reference);
+      detail::setNamedOptionHelper(this, std::move(namedArgs)...);
+    }
+    template <typename... Parameters>
+    explicit TagGroup(std::shared_ptr<AudioContent> const &reference,
+                      Parameters... namedArgs) {
+      addReference(reference);
+      detail::setNamedOptionHelper(this, std::move(namedArgs)...);
+    }
+    template <typename... Parameters>
+    explicit TagGroup(std::shared_ptr<AudioProgramme> const &reference,
+                      Parameters... namedArgs) {
+      addReference(reference);
+      detail::setNamedOptionHelper(this, std::move(namedArgs)...);
+    }
+
+    /// @brief Add reference to an AudioProgramme
+    ADM_EXPORT bool addReference(std::shared_ptr<AudioProgramme> programme);
+
+    /// @brief Add reference to an AudioContent
+    ADM_EXPORT bool addReference(std::shared_ptr<AudioContent> content);
+
+    /// @brief Add reference to an AudioObject
+    ADM_EXPORT bool addReference(std::shared_ptr<AudioObject> object);
+
+    template <typename Element>
+    ElementRange<Element> getReferences();
+
+    template <typename Element>
+    ElementRange<const Element> getReferences() const;
+
+    /// @brief Remove reference to an AudioProgramme
+    ADM_EXPORT RemoveResult
+    removeReference(std::shared_ptr<AudioProgramme> programme);
+
+    /// @brief Remove reference to an AudioContent
+    ADM_EXPORT RemoveResult
+    removeReference(std::shared_ptr<AudioContent> content);
+
+    /// @brief Remove reference to an AudioObject
+    ADM_EXPORT RemoveResult
+    removeReference(std::shared_ptr<AudioObject> object);
+
+    template <typename Element>
+    void clearReferences();
+
+    using AddWrapperMethods::get;
+    using AddWrapperMethods::has;
+    using AddWrapperMethods::isDefault;
+    using AddWrapperMethods::unset;
+    using detail::TagGroupBase::add;
+    using detail::TagGroupBase::remove;
+    using detail::TagGroupBase::set;
+
+    template <typename T>
+    bool has() const {
+      return has(typename detail::ParameterTraits<T>::tag{});
+    }
+
+   private:
+    using detail::TagGroupBase::get;
+    using detail::TagGroupBase::has;
+    using detail::TagGroupBase::isDefault;
+    using detail::TagGroupBase::unset;
+
+    friend class detail::AddWrapperMethods<TagGroup>;
+    friend class Document;
+    friend class TagList;
+
+    bool invalid() const;
+
+    ADM_EXPORT ElementRange<const AudioProgramme> getReferences(
+        detail::ParameterTraits<AudioProgramme>::tag) const;
+    ADM_EXPORT ElementRange<AudioProgramme> getReferences(
+        detail::ParameterTraits<AudioProgramme>::tag);
+    ADM_EXPORT ElementRange<const AudioContent> getReferences(
+        detail::ParameterTraits<AudioContent>::tag) const;
+    ADM_EXPORT ElementRange<AudioContent> getReferences(
+        detail::ParameterTraits<AudioContent>::tag);
+    ADM_EXPORT ElementRange<const AudioObject> getReferences(
+        detail::ParameterTraits<AudioObject>::tag) const;
+    ADM_EXPORT ElementRange<AudioObject> getReferences(
+        detail::ParameterTraits<AudioObject>::tag);
+
+    std::vector<std::shared_ptr<AudioProgramme>> audioProgrammes_;
+    std::vector<std::shared_ptr<AudioContent>> audioContents_;
+    std::vector<std::shared_ptr<AudioObject>> audioObjects_;
+  };
+
+  inline bool operator==(const TagGroup &a, const TagGroup &b) {
+    return detail::optionalsEqual<Tags>(a, b) &&
+           detail::elementRangeEqual<AudioObject const>(
+               a.getReferences<AudioObject>(),
+               b.getReferences<AudioObject>()) &&
+           detail::elementRangeEqual<AudioProgramme>(
+               a.getReferences<AudioProgramme>(),
+               b.getReferences<AudioProgramme>()) &&
+           detail::elementRangeEqual<AudioContent>(
+               a.getReferences<AudioContent>(),
+               b.getReferences<AudioContent>());
+  }
+
+  inline bool operator!=(const TagGroup &a, const TagGroup &b) {
+    return !(a == b);
+  }
+
+  template <typename Element>
+  ElementRange<const Element> TagGroup::getReferences() const {
+    typedef typename detail::ParameterTraits<Element>::tag Tag;
+    return getReferences(Tag());
+  }
+
+  template <typename Element>
+  ElementRange<Element> TagGroup::getReferences() {
+    typedef typename detail::ParameterTraits<Element>::tag Tag;
+    return getReferences(Tag());
+  }
+
+  inline ElementRange<const AudioProgramme> TagGroup::getReferences(
+      detail::ParameterTraits<AudioProgramme>::tag) const {
+    return ElementRange<const AudioProgramme>(audioProgrammes_.begin(),
+                                              audioProgrammes_.end());
+  }
+
+  inline ElementRange<const AudioContent> TagGroup::getReferences(
+      detail::ParameterTraits<AudioContent>::tag) const {
+    return ElementRange<const AudioContent>(audioContents_.begin(),
+                                            audioContents_.end());
+  }
+
+  inline ElementRange<const AudioObject> TagGroup::getReferences(
+      detail::ParameterTraits<AudioObject>::tag) const {
+    return ElementRange<const AudioObject>(audioObjects_.begin(),
+                                           audioObjects_.end());
+  }
+
+  inline ElementRange<AudioProgramme> TagGroup::getReferences(
+      detail::ParameterTraits<AudioProgramme>::tag) {
+    return ElementRange<AudioProgramme>(audioProgrammes_.begin(),
+                                        audioProgrammes_.end());
+  }
+
+  inline ElementRange<AudioContent> TagGroup::getReferences(
+      detail::ParameterTraits<AudioContent>::tag) {
+    return ElementRange<AudioContent>(audioContents_.begin(),
+                                      audioContents_.end());
+  }
+
+  inline ElementRange<AudioObject> TagGroup::getReferences(
+      detail::ParameterTraits<AudioObject>::tag) {
+    return ElementRange<AudioObject>(audioObjects_.begin(),
+                                     audioObjects_.end());
+  }
+
+  template <typename Element>
+  void TagGroup::clearReferences() {
+    typedef typename detail::ParameterTraits<Element>::tag Tag;
+    clearReferences(Tag());
+  }
+
+  struct TagGroupsTag {};
+
+  using TagGroups = std::vector<TagGroup>;
+  ADD_TRAIT(TagGroups, TagGroupsTag);
+
+  namespace detail {
+    extern template class ADM_EXPORT_TEMPLATE_METHODS
+        VectorParameter<TagGroups>;
+
+    using TagListBase = HasParameters<VectorParameter<TagGroups>>;
+  }  // namespace detail
+
+  struct TagListTag {};
+
+  class TagList : private detail::TagListBase,
+                  private detail::AddWrapperMethods<TagList>,
+                  public std::enable_shared_from_this<TagList> {
+   public:
+    template <typename... Parameters>
+    std::shared_ptr<TagList> create(Parameters... namedArgs) {
+      return std::make_shared<TagList>(
+          std::forward<Parameters...>(namedArgs...));
+    }
+    using tag = TagListTag;
+    using detail::TagListBase::set;
+    using detail::AddWrapperMethods<TagList>::get;
+    using detail::AddWrapperMethods<TagList>::has;
+    using detail::AddWrapperMethods<TagList>::isDefault;
+    using detail::AddWrapperMethods<TagList>::unset;
+    using detail::TagListBase::remove;
+
+    ADM_EXPORT bool add(TagGroup group);
+
+    template <typename... Parameters>
+    explicit TagList(Parameters... namedArgs) {
+      detail::setNamedOptionHelper(this, std::move(namedArgs)...);
+    }
+
+   private:
+    using detail::TagListBase::get;
+    using detail::TagListBase::has;
+    using detail::TagListBase::isDefault;
+    using detail::TagListBase::unset;
+
+    friend class detail::AddWrapperMethods<TagList>;
+  };
+}  // namespace adm
diff --git a/include/adm/elements_fwd.hpp b/include/adm/elements_fwd.hpp
index 518bdb2e..45c3f57f 100644
--- a/include/adm/elements_fwd.hpp
+++ b/include/adm/elements_fwd.hpp
@@ -47,5 +47,8 @@ namespace adm {
   class AudioTrackUidId;
 
   class LoudnessMetadata;
+  class LoudnessRenderer;
+  class AuthoringRenderer;
+  class AuthoringInformation;
   class AudioProgrammeReferenceScreen;
 }  // namespace adm
diff --git a/include/adm/helper/element_range.hpp b/include/adm/helper/element_range.hpp
index 1cd1678a..8d170942 100644
--- a/include/adm/helper/element_range.hpp
+++ b/include/adm/helper/element_range.hpp
@@ -197,6 +197,18 @@ namespace adm {
                      [](std::weak_ptr<Element> w) { return w.lock(); });
       return result;
     }
+    template <typename Element>
+    bool elementRangeEqual(ElementRange<Element const> a,
+                           ElementRange<Element const> b) {
+      if (a.size() != b.size()) {
+        return false;
+      }
+      bool equal = true;
+      for (std::size_t i = 0; i != a.size() && equal; ++i) {
+        equal = a[i] == b[i];
+      }
+      return equal;
+    }
 
   }  // namespace detail
 
diff --git a/include/adm/private/copy.hpp b/include/adm/private/copy.hpp
index 9fa6e544..3c464d22 100644
--- a/include/adm/private/copy.hpp
+++ b/include/adm/private/copy.hpp
@@ -9,9 +9,48 @@
 
 namespace adm {
 
+  /**
+   * @brief Per-element-kind shared_ptr mapping from a source Document's
+   * elements to their copies. Populated by `copyAllElements` and consumed
+   * by reference-resolution helpers such as `resolveReferences` and
+   * `copyAuxiliary`.
+   */
+  struct ElementMapping {
+    // clang-format off
+    std::unordered_map<std::shared_ptr<const AudioProgramme>, std::shared_ptr<AudioProgramme>> audioProgramme;
+    std::unordered_map<std::shared_ptr<const AudioContent>, std::shared_ptr<AudioContent>> audioContent;
+    std::unordered_map<std::shared_ptr<const AudioObject>, std::shared_ptr<AudioObject>> audioObject;
+    std::unordered_map<std::shared_ptr<const AudioPackFormat>, std::shared_ptr<AudioPackFormat>> audioPackFormat;
+    std::unordered_map<std::shared_ptr<const AudioChannelFormat>, std::shared_ptr<AudioChannelFormat>> audioChannelFormat;
+    std::unordered_map<std::shared_ptr<const AudioStreamFormat>, std::shared_ptr<AudioStreamFormat>> audioStreamFormat;
+    std::unordered_map<std::shared_ptr<const AudioTrackFormat>, std::shared_ptr<AudioTrackFormat>> audioTrackFormat;
+    std::unordered_map<std::shared_ptr<const AudioTrackUid>, std::shared_ptr<AudioTrackUid>> audioTrackUid;
+    // clang-format on
+  };
+
   std::vector<ElementVariant> copyAllElements(
       std::shared_ptr<const Document> document);
 
+  /**
+   * @brief Like `copyAllElements`, but also reports the source-to-copy
+   * mapping for every element kind, so callers can translate references
+   * stored in document-level parameters (e.g. tagList).
+   */
+  std::vector<ElementVariant> copyAllElements(
+      std::shared_ptr<const Document> document, ElementMapping& mapping);
+
+  /**
+   * @brief Copy document-level auxiliary parameters (ProfileList, TagList)
+   * from `src` to `dest`, translating any element references in the
+   * TagList through `mapping`.
+   *
+   * Must be called *after* the copied elements have been added to `dest`,
+   * so that `Document::set(TagList)` can adopt them via paternity checks.
+   */
+  void copyAuxiliary(std::shared_ptr<const Document> src,
+                     std::shared_ptr<Document> dest,
+                     ElementMapping const& mapping);
+
   template <typename C>
   class AddTo : public boost::static_visitor<> {
    public:
diff --git a/include/adm/private/document_parser.hpp b/include/adm/private/document_parser.hpp
index ee2ac5c2..fd3e1380 100644
--- a/include/adm/private/document_parser.hpp
+++ b/include/adm/private/document_parser.hpp
@@ -45,6 +45,8 @@ namespace adm {
     LoudnessMetadatas parseLoudnessMetadatas(const std::vector<NodePtr>& nodes);
     AudioProgrammeReferenceScreen parseAudioProgrammeReferenceScreen(
         NodePtr node);
+    AuthoringRenderer parseAuthoringRenderer(NodePtr node);
+    AuthoringInformation parseAuthoringInformation(NodePtr node);
     Label parseLabel(NodePtr node);
     AudioBlockFormatObjects parseAudioBlockFormatObjects(
         NodePtr node, boost::optional<TimeReference> timeReference);
@@ -70,6 +72,7 @@ namespace adm {
         NodePtr node, boost::optional<TimeReference> timeReference);
     Profile parseProfile(NodePtr node);
     ProfileList parseProfileList(NodePtr node);
+    Tag parseTTag(NodePtr node);
 
     NodePtr findAudioFormatExtendedNodeEbuCore(NodePtr root);
     NodePtr findAudioFormatExtendedNodeFullRecursive(NodePtr root);
@@ -105,6 +108,8 @@ namespace adm {
       std::shared_ptr<AudioPackFormat> parseAudioPackFormat(NodePtr node);
       std::shared_ptr<AudioTrackUid> parseAudioTrackUid(NodePtr node);
       std::shared_ptr<AudioChannelFormat> parseAudioChannelFormat(NodePtr node);
+      std::shared_ptr<TagGroup> parseTagGroup(NodePtr node);
+      TagList parseTagList(NodePtr node);
 
       rapidxml::file<> xmlFile_;
       ParserOptions options_;
@@ -127,6 +132,9 @@ namespace adm {
       std::map<std::shared_ptr<AudioStreamFormat>, AudioChannelFormatId> streamFormatChannelFormatRef_;
       std::map<std::shared_ptr<AudioStreamFormat>, AudioPackFormatId> streamFormatPackFormatRef_;
       std::map<std::shared_ptr<AudioStreamFormat>, std::vector<AudioTrackFormatId>> streamFormatTrackFormatRefs_;
+      std::map<std::shared_ptr<TagGroup>, std::vector<AudioProgrammeId>> tagGroupProgrammeRefs_;
+      std::map<std::shared_ptr<TagGroup>, std::vector<AudioContentId>> tagGroupContentRefs_;
+      std::map<std::shared_ptr<TagGroup>, std::vector<AudioObjectId>> tagGroupObjectRefs_;
       // clang-format on
 
       /// used to keep track of element IDs ourselves to avoid having it
@@ -154,6 +162,10 @@ namespace adm {
           const std::map<std::shared_ptr<AudioObject>,
                          std::vector<AudioTrackUidId>>& map);
 
+      void resolveProgrammeAuthoringRendererReferences();
+      void resolveProgrammeLoudnessRendererReferences();
+      void resolveContentLoudnessRendererReferences();
+
       template <typename Src, typename Target>
       void resolveReference(const std::map<Src, Target>& map) {
         for (const auto& entry : map) {
@@ -167,6 +179,21 @@ namespace adm {
       }
       void setCommonProperties(std::shared_ptr<AudioPackFormat> audioPackFormat,
                                NodePtr node);
+
+      struct RendererNestedIds {
+        std::vector<AudioPackFormatId> packFormatIds;
+        std::vector<AudioObjectId> objectIds;
+      };
+
+      std::map<std::shared_ptr<AudioProgramme>, std::vector<AudioPackFormatId>>
+          programmeAuthoringReferenceLayoutPackFormatRefs_;
+      std::map<std::shared_ptr<AudioProgramme>,
+               std::vector<std::vector<AudioPackFormatId>>>
+          programmeAuthoringRendererPackFormatRefs_;
+      std::map<std::shared_ptr<AudioProgramme>, std::vector<RendererNestedIds>>
+          programmeLoudnessRendererRefs_;
+      std::map<std::shared_ptr<AudioContent>, std::vector<RendererNestedIds>>
+          contentLoudnessRendererRefs_;
     };
 
   }  // namespace xml
diff --git a/include/adm/private/rapidxml_formatter.hpp b/include/adm/private/rapidxml_formatter.hpp
index df06671e..4ba22a3e 100644
--- a/include/adm/private/rapidxml_formatter.hpp
+++ b/include/adm/private/rapidxml_formatter.hpp
@@ -55,6 +55,9 @@ namespace adm {
         XmlNode &node, const std::shared_ptr<const AudioTrackUid> trackUid);
     void formatProfileList(XmlNode &node, const ProfileList &profileList);
     void formatProfile(XmlNode &node, const Profile &profile);
+    void formatTagList(XmlNode &node, const TagList &tagList);
+    void formatTagGroup(XmlNode &node, const TagGroup &tagGroup);
+    void formatTag(XmlNode &node, const Tag &tag);
 
     void formatBlockFormatDirectSpeakers(
         XmlNode &node, const AudioBlockFormatDirectSpeakers &audioBlock,
diff --git a/include/adm/private/rapidxml_wrapper.hpp b/include/adm/private/rapidxml_wrapper.hpp
index 5d4ce89a..65a9af99 100644
--- a/include/adm/private/rapidxml_wrapper.hpp
+++ b/include/adm/private/rapidxml_wrapper.hpp
@@ -102,6 +102,10 @@ namespace adm {
       void addBaseElements(const Source &src, const std::string &name,
                            Callable formatter);
 
+      template <typename ElementType, typename Source, typename Callable>
+      void addBaseElement(const Source &src, const std::string &name,
+                          Callable formatter);
+
       template <typename ElementType, typename AdmIdType, typename Source>
       void addReference(const Source &src, const std::string &name);
 
@@ -262,6 +266,16 @@ namespace adm {
       }
     }
 
+    template <typename ElementType, typename Source, typename Callable>
+    void XmlNode::addBaseElement(const Source &src, const std::string &name,
+                                 Callable formatter) {
+      auto admElement = src->template getElement<ElementType>();
+      if (admElement) {
+        auto node = addNode(name);
+        formatter(node, *admElement);
+      }
+    }
+
     template <typename ElementType, typename AdmIdType, typename Source>
     void XmlNode::addReference(const Source &src, const std::string &name) {
       addElement<AdmIdType>(src->template getReference<ElementType>(), name);
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index b11f800f..37e71fa0 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -36,6 +36,7 @@ add_library(adm
   elements/audio_block_format_binaural.cpp
   elements/audio_object_interaction.cpp
   elements/audio_pack_format_hoa.cpp
+  elements/authoring_information.cpp
   elements/common_parameters.cpp
   elements/time.cpp
   elements/channel_lock.cpp
@@ -44,6 +45,7 @@ add_library(adm
   elements/jump_position.cpp
   elements/label.cpp
   elements/loudness_metadata.cpp
+  elements/loudness_renderer.cpp
   elements/object_divergence.cpp
   elements/position.cpp
   elements/position_offset.cpp
@@ -54,6 +56,7 @@ add_library(adm
   elements/type_descriptor.cpp
   elements/format_descriptor.cpp
   elements/headphone_virtualise.cpp
+  elements/tag_list.cpp
   utilities/block_duration_assignment.cpp
   utilities/copy.cpp
   utilities/id_assignment.cpp
diff --git a/src/document.cpp b/src/document.cpp
index 85759cdd..c08d0bcc 100644
--- a/src/document.cpp
+++ b/src/document.cpp
@@ -8,12 +8,218 @@
 #include "adm/private/copy.hpp"
 
 #include <algorithm>
+#include <stdexcept>
 
 namespace adm {
+  namespace {
+    template <typename ContainerT, typename Predicate>
+    bool pruneIf(ContainerT& container, Predicate predicate) {
+      auto end = std::remove_if(container.begin(), container.end(), predicate);
+      if (end == container.end()) {
+        return false;
+      }
+      container.erase(end, container.end());
+      return true;
+    }
+
+    template <typename Element>
+    void pruneTagGroupsReferencing(
+        Document& document,
+        std::shared_ptr<Element> const& removedElement) {
+      if (!document.has<TagList>()) return;
+      auto list = document.get<TagList>();
+      auto groups = list.get<TagGroups>();
+      auto pruned = pruneIf(groups, [&](TagGroup const& group) {
+        auto refs = group.template getReferences<Element>();
+        return std::find(refs.begin(), refs.end(), removedElement) !=
+               refs.end();
+      });
+      if (!pruned) return;
+      if (groups.empty()) {
+        document.unset<TagList>();
+        return;
+      }
+      TagList newList;
+      for (auto& group : groups) newList.add(group);
+      document.set(newList);
+    }
+  }  // namespace
+
   namespace detail {
     template class OptionalParameter<Version>;
+    template class OptionalParameter<TagList>;
+    template class OptionalParameter<ProfileList>;
   }  // namespace detail
 
+  namespace {
+    // Bound the recursion depth of Document::add() to prevent a stack
+    // overflow when the cross-reference graph is pathologically deep
+    // (e.g. an adversarial XML with thousands of nested
+    // audioPackFormatIDRefs). Re-entering an already-added element is
+    // already short-circuited by checkParent(), so this only fires on
+    // genuinely deep, unique chains. The limit is far above any realistic
+    // ADM document.
+    constexpr int kMaxAddRecursionDepth = 1000;
+    thread_local int g_addRecursionDepth = 0;
+
+    struct AddRecursionGuard {
+      AddRecursionGuard() {
+        if (g_addRecursionDepth >= kMaxAddRecursionDepth) {
+          throw std::runtime_error(
+              "Document::add: cross-reference recursion depth exceeded "
+              "(possible deeply-nested or malformed input)");
+        }
+        ++g_addRecursionDepth;
+      }
+      ~AddRecursionGuard() { --g_addRecursionDepth; }
+      AddRecursionGuard(const AddRecursionGuard&) = delete;
+      AddRecursionGuard& operator=(const AddRecursionGuard&) = delete;
+    };
+
+    template <typename RendererType, typename RefsParameter, typename Element>
+    bool pruneRendererRefs(
+        RendererType& renderer,
+        std::shared_ptr<Element> const& removedElement) {
+      if (!renderer.template has<RefsParameter>()) {
+        return false;
+      }
+      auto const removedId = removedElement->template get<typename Element::id_type>();
+      auto refs = renderer.template get<RefsParameter>();
+      pruneIf(refs, [&removedId, &removedElement](auto const& ref) {
+        if (ref == removedElement) {
+          return true;
+        }
+        bool removed = ref->template get<typename Element::id_type>() ==
+                       removedId;
+        return removed;
+      });
+
+      if (refs.empty()) {
+        renderer.template unset<RefsParameter>();
+      } else {
+        renderer.set(std::move(refs));
+      }
+      return true;
+    }
+
+    template <typename T>
+    bool pruneLoudnessMetadataIdRefs(
+      LoudnessMetadatas& data,
+      std::shared_ptr<T> removedElement) {
+      bool changed = false;
+      for (auto& loudnessMetadata : data) {
+        if (!loudnessMetadata.has<LoudnessRenderer>()) {
+          continue;
+        }
+        auto renderer = loudnessMetadata.get<LoudnessRenderer>();
+        if (!pruneRendererRefs<LoudnessRenderer, std::vector<std::shared_ptr<T>>>(
+                renderer,
+                removedElement)) {
+          continue;
+                }
+        loudnessMetadata.set(std::move(renderer));
+        changed = true;
+      }
+      return changed;
+
+    }
+
+    template<typename Element, typename RemovedElement>
+    void pruneElementLoudnessIdRefs(
+      std::shared_ptr<Element> const& element,
+      std::shared_ptr<RemovedElement> const& removedElement) {
+      if (!element->template has<LoudnessMetadatas>()) {
+        return;
+      }
+      auto loudnessMetadatas = element->template get<LoudnessMetadatas>();
+      if (!pruneLoudnessMetadataIdRefs(loudnessMetadatas, removedElement)) {
+        return;
+      }
+      element->set(std::move(loudnessMetadatas));
+    }
+
+    bool pruneAuthoringInformationPackFormatIdRefs(
+        AuthoringInformation& info,
+        AudioPackFormatId const& removedId,
+        std::shared_ptr<AudioPackFormat> const& removedPackFormat) {
+      bool changed = false;
+
+      if (info.has<Renderers>()) {
+        auto renderers = info.get<Renderers>();
+        bool renderersChanged = false;
+        for (auto& renderer : renderers) {
+          renderersChanged |=
+              pruneRendererRefs<AuthoringRenderer, RendererPackFormatIdRefs>(
+                  renderer,
+                  removedPackFormat);
+        }
+        if (renderersChanged) {
+          if (renderers.empty()) {
+            info.unset<Renderers>();
+          } else {
+            info.set(std::move(renderers));
+          }
+          changed = true;
+        }
+      }
+
+      if (info.has<ReferenceLayouts>()) {
+        auto referenceLayouts = info.get<ReferenceLayouts>();
+        auto pruned = pruneIf(referenceLayouts, [&](ReferenceLayout const& layout) {
+          auto const& ref = layout.get();
+          if (ref == removedPackFormat) {
+            return true;
+          }
+          return ref->get<AudioPackFormatId>() == removedId;
+        });
+        if (pruned) {
+          if (referenceLayouts.empty()) {
+            info.unset<ReferenceLayouts>();
+          } else {
+            info.set(std::move(referenceLayouts));
+          }
+          changed = true;
+        }
+      }
+
+      return changed;
+    }
+
+    void prunePackFormatIdRefs(
+        Document& document,
+        AudioPackFormatId const& removedId,
+        std::shared_ptr<AudioPackFormat> const& removedPackFormat) {
+      for (auto const& programme : document.getElements<AudioProgramme>()) {
+        if (programme->has<AuthoringInformation>()) {
+          auto info = programme->get<AuthoringInformation>();
+          if (pruneAuthoringInformationPackFormatIdRefs(
+                  info,
+                  removedId,
+                  removedPackFormat)) {
+            programme->set(std::move(info));
+          }
+        }
+        pruneElementLoudnessIdRefs(programme, removedPackFormat);
+      }
+
+      for (auto const& content : document.getElements<AudioContent>()) {
+        pruneElementLoudnessIdRefs(content, removedPackFormat);
+      }
+    }
+
+    void pruneObjectIdRefs(
+        Document& document,
+        std::shared_ptr<AudioObject> const& removedObject) {
+      for (auto const& programme : document.getElements<AudioProgramme>()) {
+        pruneElementLoudnessIdRefs(programme, removedObject);
+      }
+
+      for (auto const& content : document.getElements<AudioContent>()) {
+        pruneElementLoudnessIdRefs(content, removedObject);
+      }
+    }
+  }  // namespace
+
   Document::Document() { idAssigner_.document(this); }
 
   std::shared_ptr<Document> Document::create() {
@@ -31,8 +237,8 @@ namespace adm {
     copy->audioTrackFormats_.reserve(audioTrackFormats_.size());
     copy->audioTrackUids_.reserve(audioTrackUids_.size());
 
-    auto elements = copyAllElements(shared_from_this());
-    if (has<Version>()) copy->set(get<Version>());
+    ElementMapping mapping;
+    auto elements = copyAllElements(shared_from_this(), mapping);
     for (auto& e : elements) {
       if (auto v = boost::get<std::shared_ptr<AudioProgramme>>(&e)) {
         AudioProgrammeAttorney::setParent(*v, copy);
@@ -60,11 +266,13 @@ namespace adm {
         copy->audioTrackUids_.push_back(*v);
       }
     }
+    copyAuxiliary(shared_from_this(), copy, mapping);
     return copy;
   }
 
   // ---- add elements ---- //
   bool Document::add(std::shared_ptr<AudioProgramme> programme) {
+    AddRecursionGuard guard;
     if (!checkParent(programme, "AudioProgramme")) {
       idAssigner_.assignId(*programme);
       AudioProgrammeAttorney::setParent(programme, shared_from_this());
@@ -79,6 +287,7 @@ namespace adm {
   }
 
   bool Document::add(std::shared_ptr<AudioContent> content) {
+    AddRecursionGuard guard;
     if (!checkParent(content, "AudioContent")) {
       idAssigner_.assignId(*content);
       AudioContentAttorney::setParent(content, shared_from_this());
@@ -93,6 +302,7 @@ namespace adm {
   }
 
   bool Document::add(std::shared_ptr<AudioObject> object) {
+    AddRecursionGuard guard;
     if (!checkParent(object, "AudioObject")) {
       idAssigner_.assignId(*object);
       AudioObjectAttorney::setParent(object, shared_from_this());
@@ -115,6 +325,7 @@ namespace adm {
     }
   }
   bool Document::add(std::shared_ptr<AudioPackFormat> packFormat) {
+    AddRecursionGuard guard;
     if (!checkParent(packFormat, "AudioPackFormat")) {
       idAssigner_.assignId(*packFormat);
       AudioPackFormatAttorney::setParent(packFormat, shared_from_this());
@@ -132,6 +343,7 @@ namespace adm {
   }
 
   bool Document::add(std::shared_ptr<AudioChannelFormat> channelFormat) {
+    AddRecursionGuard guard;
     if (!checkParent(channelFormat, "AudioChannelFormat")) {
       idAssigner_.assignId(*channelFormat);
       AudioChannelFormatAttorney::setParent(channelFormat, shared_from_this());
@@ -143,6 +355,7 @@ namespace adm {
   }
 
   bool Document::add(std::shared_ptr<AudioStreamFormat> streamFormat) {
+    AddRecursionGuard guard;
     if (!checkParent(streamFormat, "AudioStreamFormat")) {
       idAssigner_.assignId(*streamFormat);
       AudioStreamFormatAttorney::setParent(streamFormat, shared_from_this());
@@ -170,6 +383,7 @@ namespace adm {
   }
 
   bool Document::add(std::shared_ptr<AudioTrackFormat> trackFormat) {
+    AddRecursionGuard guard;
     if (!checkParent(trackFormat, "AudioTrackFormat")) {
       // NOTE: That the id assignment works properly the AudioStreamFormats
       // have to be added before the AudioTrackFormat.
@@ -192,6 +406,7 @@ namespace adm {
   }
 
   bool Document::add(std::shared_ptr<AudioTrackUid> trackUid) {
+    AddRecursionGuard guard;
     if (!checkParent(trackUid, "AudioTrackUid")) {
       idAssigner_.assignId(*trackUid);
       AudioTrackUidAttorney::setParent(trackUid, shared_from_this());
@@ -222,6 +437,7 @@ namespace adm {
     if (it != audioProgrammes_.end()) {
       audioProgrammes_.erase(it);
       AudioProgrammeAttorney::setParent(programme, {});
+      pruneTagGroupsReferencing(*this, programme);
       return true;
     }
     return false;
@@ -235,6 +451,7 @@ namespace adm {
       for (auto& audioProgramme : audioProgrammes_) {
         audioProgramme->removeReference(content);
       }
+      pruneTagGroupsReferencing(*this, content);
       return true;
     }
     return false;
@@ -251,15 +468,53 @@ namespace adm {
       for (auto& audioContent : audioContents_) {
         audioContent->removeReference(object);
       }
+      pruneTagGroupsReferencing(*this, object);
+      pruneObjectIdRefs(*this, object);
       return true;
     }
     return false;
   }
 
+  namespace {
+    template <typename Element>
+    bool tagGroupRefsBelongToOtherDoc(
+        Document const& doc,
+        std::vector<std::shared_ptr<Element>> const& refs) {
+      for (auto const& ref : refs) {
+        auto parent = ref->getParent().lock();
+        if (parent && parent.get() != &doc) return true;
+      }
+      return false;
+    }
+  }  // namespace
+
+  bool Document::set(TagList tagList) {
+    // Validate every TagGroup reference against this document up-front so a
+    // failure leaves the document unmodified.
+    for (auto const& group : tagList.get<TagGroups>()) {
+      if (tagGroupRefsBelongToOtherDoc(*this, group.audioProgrammes_) ||
+          tagGroupRefsBelongToOtherDoc(*this, group.audioContents_) ||
+          tagGroupRefsBelongToOtherDoc(*this, group.audioObjects_)) {
+        return false;
+      }
+    }
+    // Adopt any unparented references into this document. Elements already
+    // belonging to this document are short-circuited by checkParent() inside
+    // add().
+    for (auto const& group : tagList.get<TagGroups>()) {
+      for (auto const& p : group.audioProgrammes_) add(p);
+      for (auto const& c : group.audioContents_) add(c);
+      for (auto const& o : group.audioObjects_) add(o);
+    }
+    detail::DocumentBase::set(std::move(tagList));
+    return true;
+  }
+
   bool Document::remove(std::shared_ptr<AudioPackFormat> packFormat) {
     auto it = std::find(audioPackFormats_.begin(), audioPackFormats_.end(),
                         packFormat);
     if (it != audioPackFormats_.end()) {
+      auto removedPackId = packFormat->get<AudioPackFormatId>();
       audioPackFormats_.erase(it);
       AudioPackFormatAttorney::setParent(packFormat, {});
       for (auto& audioPackFormat : audioPackFormats_) {
@@ -278,6 +533,7 @@ namespace adm {
           audioTrackUid->removeReference<AudioPackFormat>();
         }
       }
+      prunePackFormatIdRefs(*this, removedPackId, packFormat);
       return true;
     }
     return false;
diff --git a/src/elements/audio_block_format_direct_speakers.cpp b/src/elements/audio_block_format_direct_speakers.cpp
index 86ad5352..ede9fec8 100644
--- a/src/elements/audio_block_format_direct_speakers.cpp
+++ b/src/elements/audio_block_format_direct_speakers.cpp
@@ -24,6 +24,18 @@ namespace adm {
       detail::ParameterTraits<SpeakerLabels>::tag) const {
     return speakerLabels_;
   }
+  Cartesian AudioBlockFormatDirectSpeakers::get(
+      detail::ParameterTraits<Cartesian>::tag) const {
+    if (cartesian_ != boost::none) {
+      return cartesian_.get();
+    } else {
+      if (has<SphericalSpeakerPosition>()) {
+        return Cartesian(false);
+      } else {
+        return Cartesian(true);
+      }
+    }
+  }
   CartesianSpeakerPosition AudioBlockFormatDirectSpeakers::get(
       detail::ParameterTraits<CartesianSpeakerPosition>::tag) const {
     return boost::get<CartesianSpeakerPosition>(speakerPosition_);
@@ -50,6 +62,10 @@ namespace adm {
       detail::ParameterTraits<SpeakerLabels>::tag) const {
     return speakerLabels_.size() > 0;
   }
+  bool AudioBlockFormatDirectSpeakers::has(
+      detail::ParameterTraits<Cartesian>::tag) const {
+    return true;
+  }
   bool AudioBlockFormatDirectSpeakers::has(
       detail::ParameterTraits<CartesianSpeakerPosition>::tag) const {
     return (boost::get<CartesianSpeakerPosition>(&speakerPosition_));
@@ -64,6 +80,10 @@ namespace adm {
       detail::ParameterTraits<Rtime>::tag) const {
     return duration_ == boost::none;
   }
+  bool AudioBlockFormatDirectSpeakers::isDefault(
+      detail::ParameterTraits<Cartesian>::tag) const {
+    return cartesian_ == boost::none;
+  }
 
   // ---- Setter ---- //
   void AudioBlockFormatDirectSpeakers::set(AudioBlockFormatId id) { id_ = id; }
@@ -71,16 +91,37 @@ namespace adm {
   void AudioBlockFormatDirectSpeakers::set(Duration duration) {
     duration_ = duration;
   }
+  void AudioBlockFormatDirectSpeakers::set(Cartesian cartesian) {
+    cartesian_ = cartesian;
+
+    if (cartesian.get()) {
+      if (has<SphericalSpeakerPosition>()) {
+        speakerPosition_ = CartesianSpeakerPosition{};
+      }
+    } else {
+      if (has<CartesianSpeakerPosition>()) {
+        speakerPosition_ = SphericalSpeakerPosition{};
+      }
+    }
+  }
   void AudioBlockFormatDirectSpeakers::set(
       CartesianSpeakerPosition speakerPosition) {
     speakerPosition_ = speakerPosition;
+    cartesian_ = Cartesian(true);
   }
   void AudioBlockFormatDirectSpeakers::set(
       SphericalSpeakerPosition speakerPosition) {
     speakerPosition_ = speakerPosition;
+    if (cartesian_ != boost::none) {
+      cartesian_ = Cartesian(false);
+    }
   }
   void AudioBlockFormatDirectSpeakers::set(SpeakerPosition speakerPosition) {
-    speakerPosition_ = speakerPosition;
+    if (speakerPosition.which() == 0) {
+      set(boost::get<SphericalSpeakerPosition>(speakerPosition));
+    } else if (speakerPosition.which() == 1) {
+      set(boost::get<CartesianSpeakerPosition>(speakerPosition));
+    }
   }
 
   // ---- Unsetter ---- //
@@ -96,6 +137,13 @@ namespace adm {
       detail::ParameterTraits<SpeakerLabels>::tag) {
     speakerLabels_.clear();
   }
+  void AudioBlockFormatDirectSpeakers::unset(
+      detail::ParameterTraits<Cartesian>::tag) {
+    cartesian_ = boost::none;
+    if (!has<SphericalSpeakerPosition>()) {
+      set(SphericalSpeakerPosition{});
+    }
+  }
 
   // ---- Add ---- //
   bool AudioBlockFormatDirectSpeakers::add(SpeakerLabel speakerLabel) {
diff --git a/src/elements/audio_programme.cpp b/src/elements/audio_programme.cpp
index cbb59b31..5ee6ef47 100644
--- a/src/elements/audio_programme.cpp
+++ b/src/elements/audio_programme.cpp
@@ -45,6 +45,10 @@ namespace adm {
       detail::ParameterTraits<AudioProgrammeReferenceScreen>::tag) const {
     return refScreen_.get();
   }
+  AuthoringInformation AudioProgramme::get(
+      detail::ParameterTraits<AuthoringInformation>::tag) const {
+    return authoringInformation_.get();
+  }
 
   // ---- Has ---- //
   bool AudioProgramme::has(
@@ -73,6 +77,10 @@ namespace adm {
       detail::ParameterTraits<AudioProgrammeReferenceScreen>::tag) const {
     return refScreen_ != boost::none;
   }
+  bool AudioProgramme::has(
+      detail::ParameterTraits<AuthoringInformation>::tag) const {
+    return authoringInformation_ != boost::none;
+  }
 
   // ---- isDefault ---- //
   bool AudioProgramme::isDefault(detail::ParameterTraits<Start>::tag) const {
@@ -101,6 +109,9 @@ namespace adm {
   void AudioProgramme::set(AudioProgrammeReferenceScreen refScreen) {
     refScreen_ = refScreen;
   }
+  void AudioProgramme::set(AuthoringInformation authoringInformation) {
+    authoringInformation_ = std::move(authoringInformation);
+  }
 
   // ---- Unsetter ---- //
   void AudioProgramme::unset(
@@ -120,6 +131,10 @@ namespace adm {
       detail::ParameterTraits<AudioProgrammeReferenceScreen>::tag) {
     refScreen_ = boost::none;
   }
+  void AudioProgramme::unset(
+      detail::ParameterTraits<AuthoringInformation>::tag) {
+    authoringInformation_ = boost::none;
+  }
 
   // ---- References ---- //
   bool AudioProgramme::addReference(std::shared_ptr<AudioContent> content) {
diff --git a/src/elements/authoring_information.cpp b/src/elements/authoring_information.cpp
new file mode 100644
index 00000000..5b79e0a0
--- /dev/null
+++ b/src/elements/authoring_information.cpp
@@ -0,0 +1,46 @@
+#include "adm/elements/authoring_information.hpp"
+#include "adm/elements/loudness_renderer.hpp"
+
+namespace adm {
+
+  LoudnessRenderer AuthoringRenderer::toLoudnessRenderer() const {
+    return LoudnessRenderer::fromRenderer(*this);
+  }
+
+  void AuthoringRenderer::print(std::ostream& os) const {
+    os << "(";
+    bool first = true;
+    auto sep = [&]() {
+      if (!first) os << ", ";
+      first = false;
+    };
+    if (has<RendererUri>()) {
+      sep();
+      os << "uri=" << get<RendererUri>();
+    }
+    if (has<RendererName>()) {
+      sep();
+      os << "name=" << get<RendererName>();
+    }
+    if (has<RendererVersion>()) {
+      sep();
+      os << "version=" << get<RendererVersion>();
+    }
+    if (has<CoordinateMode>()) {
+      sep();
+      os << "coordinateMode=" << get<CoordinateMode>();
+    }
+    os << ")";
+  }
+
+  void AuthoringInformation::print(std::ostream& os) const {
+    os << "(referenceLayouts=" << get<ReferenceLayouts>().size()
+       << ", renderers=" << get<Renderers>().size() << ")";
+  }
+
+  namespace detail {
+    template class VectorParameter<ReferenceLayouts>;
+    template class VectorParameter<Renderers>;
+  }  // namespace detail
+
+}  // namespace adm
diff --git a/src/elements/loudness_metadata.cpp b/src/elements/loudness_metadata.cpp
index c441b939..224dcc40 100644
--- a/src/elements/loudness_metadata.cpp
+++ b/src/elements/loudness_metadata.cpp
@@ -1,4 +1,5 @@
 #include "adm/elements/loudness_metadata.hpp"
+#include "adm/elements/authoring_information.hpp"
 
 #include <iomanip>
 
@@ -45,6 +46,10 @@ namespace adm {
       detail::ParameterTraits<DialogueLoudness>::tag) const {
     return dialogueLoudness_.get();
   }
+  LoudnessRenderer LoudnessMetadata::get(
+      detail::ParameterTraits<LoudnessRenderer>::tag) const {
+    return renderer_.get();
+  }
 
   // ---- Has ---- //
   bool LoudnessMetadata::has(
@@ -80,6 +85,10 @@ namespace adm {
       detail::ParameterTraits<DialogueLoudness>::tag) const {
     return dialogueLoudness_ != boost::none;
   }
+  bool LoudnessMetadata::has(
+      detail::ParameterTraits<LoudnessRenderer>::tag) const {
+    return renderer_ != boost::none;
+  }
 
   // ---- Setter ---- //
   void LoudnessMetadata::set(LoudnessMethod loudnessMethod) {
@@ -109,6 +118,12 @@ namespace adm {
   void LoudnessMetadata::set(DialogueLoudness dialogueLoudness) {
     dialogueLoudness_ = dialogueLoudness;
   }
+  void LoudnessMetadata::set(LoudnessRenderer renderer) {
+    renderer_ = std::move(renderer);
+  }
+  void LoudnessMetadata::set(AuthoringRenderer renderer) {
+    renderer_ = renderer.toLoudnessRenderer();
+  }
 
   // ---- Unsetter ---- //
   void LoudnessMetadata::unset(detail::ParameterTraits<LoudnessMethod>::tag) {
@@ -140,6 +155,9 @@ namespace adm {
   void LoudnessMetadata::unset(detail::ParameterTraits<DialogueLoudness>::tag) {
     dialogueLoudness_ = boost::none;
   }
+  void LoudnessMetadata::unset(detail::ParameterTraits<LoudnessRenderer>::tag) {
+    renderer_ = boost::none;
+  }
 
   void LoudnessMetadata::print(std::ostream& os) const {
     os << "(";
diff --git a/src/elements/loudness_renderer.cpp b/src/elements/loudness_renderer.cpp
new file mode 100644
index 00000000..aeced284
--- /dev/null
+++ b/src/elements/loudness_renderer.cpp
@@ -0,0 +1,83 @@
+#include "adm/elements/loudness_renderer.hpp"
+#include "adm/elements/authoring_information.hpp"
+
+namespace adm {
+
+  LoudnessRenderer LoudnessRenderer::fromRenderer(
+      AuthoringRenderer const& renderer) {
+    LoudnessRenderer loudnessRenderer;
+    if (renderer.has<RendererUri>()) {
+      loudnessRenderer.set(renderer.get<RendererUri>());
+    }
+    if (renderer.has<RendererName>()) {
+      loudnessRenderer.set(renderer.get<RendererName>());
+    }
+    if (renderer.has<RendererVersion>()) {
+      loudnessRenderer.set(renderer.get<RendererVersion>());
+    }
+    if (renderer.has<CoordinateMode>()) {
+      loudnessRenderer.set(renderer.get<CoordinateMode>());
+    }
+    if (renderer.has<RendererPackFormatIdRefs>()) {
+      loudnessRenderer.set(renderer.get<RendererPackFormatIdRefs>());
+    }
+    return loudnessRenderer;
+  }
+
+  AuthoringRenderer LoudnessRenderer::toRendererDroppingObjectRefs(
+      RendererUri uri) const {
+    AuthoringRenderer renderer{std::move(uri)};
+    if (has<RendererUri>()) {
+      renderer.set(get<RendererUri>());
+    }
+    if (has<RendererName>()) {
+      renderer.set(get<RendererName>());
+    }
+    if (has<RendererVersion>()) {
+      renderer.set(get<RendererVersion>());
+    }
+    if (has<CoordinateMode>()) {
+      renderer.set(get<CoordinateMode>());
+    }
+    if (has<RendererPackFormatIdRefs>()) {
+      renderer.set(get<RendererPackFormatIdRefs>());
+    }
+    return renderer;
+  }
+
+  void LoudnessRenderer::print(std::ostream& os) const {
+    os << "(";
+    bool first = true;
+    auto sep = [&]() {
+      if (!first) os << ", ";
+      first = false;
+    };
+    if (has<RendererUri>()) {
+      sep();
+      os << "uri=" << get<RendererUri>();
+    }
+    if (has<RendererName>()) {
+      sep();
+      os << "name=" << get<RendererName>();
+    }
+    if (has<RendererVersion>()) {
+      sep();
+      os << "version=" << get<RendererVersion>();
+    }
+    if (has<CoordinateMode>()) {
+      sep();
+      os << "coordinateMode=" << get<CoordinateMode>();
+    }
+    os << ")";
+  }
+
+  namespace detail {
+    template class OptionalParameter<RendererUri>;
+    template class OptionalParameter<RendererName>;
+    template class OptionalParameter<RendererVersion>;
+    template class OptionalParameter<CoordinateMode>;
+    template class VectorParameter<RendererPackFormatIdRefs>;
+    template class VectorParameter<RendererObjectIdRefs>;
+  }  // namespace detail
+
+}  // namespace adm
diff --git a/src/elements/tag_list.cpp b/src/elements/tag_list.cpp
new file mode 100644
index 00000000..f76c16bf
--- /dev/null
+++ b/src/elements/tag_list.cpp
@@ -0,0 +1,102 @@
+#include "adm/elements/tag_list.hpp"
+#include <algorithm>
+
+namespace adm {
+  Tag::Tag(const char* s) {
+    // to avoid UB from std::string
+    if (!s) {
+      throw error::AdmGenericRuntimeError{
+          "Cannot construct Tag from null const char*"};
+    }
+    set(TagValue{std::string{s}});
+  }
+
+  template <typename T>
+  bool add_reference(std::vector<std::shared_ptr<T>>& references,
+                     std::shared_ptr<T> ref) {
+    auto it = std::find(references.begin(), references.end(), ref);
+    if (it == references.end()) {
+      references.push_back(ref);
+      return true;
+    }
+    return false;
+  }
+
+  // ---- References ---- //
+  bool TagGroup::addReference(std::shared_ptr<AudioProgramme> programme) {
+    return add_reference(audioProgrammes_, std::move(programme));
+  }
+
+  bool TagGroup::addReference(std::shared_ptr<AudioContent> content) {
+    return add_reference(audioContents_, std::move(content));
+  }
+
+  bool TagGroup::addReference(std::shared_ptr<AudioObject> object) {
+    return add_reference(audioObjects_, std::move(object));
+  }
+
+  template <typename T>
+  TagGroup::RemoveResult remove_reference(
+      std::vector<std::shared_ptr<T>>& references,
+      std::shared_ptr<T> const& ref) {
+    auto it = std::find(references.begin(), references.end(), ref);
+    if (it == references.end()) {
+      return TagGroup::RemoveResult::NotFound;
+    }
+    references.erase(it);
+    return TagGroup::RemoveResult::Success;
+  }
+
+  TagGroup::RemoveResult TagGroup::removeReference(
+      std::shared_ptr<AudioProgramme> programme) {
+    if (remove_reference(audioProgrammes_, programme) ==
+        RemoveResult::NotFound) {
+      return RemoveResult::NotFound;
+    }
+    if (invalid()) {
+      addReference(std::move(programme));
+      return RemoveResult::LastReferenceError;
+    }
+    return RemoveResult::Success;
+  }
+
+  TagGroup::RemoveResult TagGroup::removeReference(
+      std::shared_ptr<AudioContent> content) {
+    if (remove_reference(audioContents_, content) == RemoveResult::NotFound) {
+      return RemoveResult::NotFound;
+    }
+    if (invalid()) {
+      addReference(std::move(content));
+      return RemoveResult::LastReferenceError;
+    }
+    return RemoveResult::Success;
+  }
+
+  TagGroup::RemoveResult TagGroup::removeReference(
+      std::shared_ptr<AudioObject> object) {
+    if (remove_reference(audioObjects_, object) == RemoveResult::NotFound) {
+      return RemoveResult::NotFound;
+    }
+    if (invalid()) {
+      addReference(std::move(object));
+      return RemoveResult::LastReferenceError;
+    }
+    return RemoveResult::Success;
+  }
+
+  bool TagGroup::invalid() const {
+    return audioContents_.empty() && audioObjects_.empty() &&
+           audioProgrammes_.empty();
+  }
+
+  bool TagList::add(TagGroup group) {
+    return detail::TagListBase::add(std::move(group));
+  }
+
+  namespace detail {
+    template class RequiredParameter<TagValue>;
+    template class OptionalParameter<TagClass>;
+    template class VectorParameter<Tags>;
+    template class VectorParameter<TagGroups>;
+  }  // namespace detail
+}  // namespace adm
diff --git a/src/private/copy.cpp b/src/private/copy.cpp
index cf56b01e..295eb5a2 100644
--- a/src/private/copy.cpp
+++ b/src/private/copy.cpp
@@ -3,22 +3,142 @@
 
 namespace adm {
 
-  struct ElementMapping {
-    // clang-format off
-    std::unordered_map<std::shared_ptr<const AudioProgramme>, std::shared_ptr<AudioProgramme>> audioProgramme;
-    std::unordered_map<std::shared_ptr<const AudioContent>, std::shared_ptr<AudioContent>> audioContent;
-    std::unordered_map<std::shared_ptr<const AudioObject>, std::shared_ptr<AudioObject>> audioObject;
-    std::unordered_map<std::shared_ptr<const AudioPackFormat>, std::shared_ptr<AudioPackFormat>> audioPackFormat;
-    std::unordered_map<std::shared_ptr<const AudioChannelFormat>, std::shared_ptr<AudioChannelFormat>> audioChannelFormat;
-    std::unordered_map<std::shared_ptr<const AudioStreamFormat>, std::shared_ptr<AudioStreamFormat>> audioStreamFormat;
-    std::unordered_map<std::shared_ptr<const AudioTrackFormat>, std::shared_ptr<AudioTrackFormat>> audioTrackFormat;
-    std::unordered_map<std::shared_ptr<const AudioTrackUid>, std::shared_ptr<AudioTrackUid>> audioTrackUid;
-    // clang-format on
-  };
+  namespace {
+    RendererPackFormatIdRefs remapPackFormatRefs(
+        RendererPackFormatIdRefs const& refs, ElementMapping const& mapping) {
+      RendererPackFormatIdRefs remapped;
+      remapped.reserve(refs.size());
+      for (auto const& ref : refs) {
+        auto it = mapping.audioPackFormat.find(ref);
+        if (it != mapping.audioPackFormat.end()) {
+          remapped.push_back(it->second);
+        } else {
+          remapped.push_back(ref);
+        }
+      }
+      return remapped;
+    }
+
+    RendererObjectIdRefs remapObjectRefs(RendererObjectIdRefs const& refs,
+                                         ElementMapping const& mapping) {
+      RendererObjectIdRefs remapped;
+      remapped.reserve(refs.size());
+      for (auto const& ref : refs) {
+        auto it = mapping.audioObject.find(ref);
+        if (it != mapping.audioObject.end()) {
+          remapped.push_back(it->second);
+        } else {
+          remapped.push_back(ref);
+        }
+      }
+      return remapped;
+    }
+
+    void remapAuthoringInformationReferences(
+        std::shared_ptr<AudioProgramme> const& programme,
+        ElementMapping const& mapping) {
+      if (!programme->has<AuthoringInformation>()) {
+        return;
+      }
+
+      auto info = programme->get<AuthoringInformation>();
+      bool changed = false;
+      if (info.has<ReferenceLayouts>()) {
+        auto layouts = info.get<ReferenceLayouts>();
+        ReferenceLayouts remappedLayouts;
+        remappedLayouts.reserve(layouts.size());
+        for (auto const& refLayout : layouts) {
+          auto const& ref = refLayout.get();
+          auto it = mapping.audioPackFormat.find(ref);
+          if (it != mapping.audioPackFormat.end()) {
+            remappedLayouts.push_back(ReferenceLayout{it->second});
+          } else {
+            remappedLayouts.push_back(ReferenceLayout{ref});
+          }
+        }
+
+        if (remappedLayouts.empty()) {
+          info.unset<ReferenceLayouts>();
+        } else {
+          info.set(std::move(remappedLayouts));
+        }
+        changed = true;
+      }
+
+      if (info.has<Renderers>()) {
+        auto renderers = info.get<Renderers>();
+        for (auto& renderer : renderers) {
+          if (!renderer.has<RendererPackFormatIdRefs>()) {
+            continue;
+          }
+
+          auto remapped = remapPackFormatRefs(
+              renderer.get<RendererPackFormatIdRefs>(), mapping);
+          if (remapped.empty()) {
+            renderer.unset<RendererPackFormatIdRefs>();
+          } else {
+            renderer.set(std::move(remapped));
+          }
+          changed = true;
+        }
+
+        if (changed) {
+          info.set(std::move(renderers));
+        }
+      }
+
+      if (changed) programme->set(std::move(info));
+    }
+
+    template <typename Owner>
+    void remapLoudnessRendererReferences(std::shared_ptr<Owner> const& owner,
+                                         ElementMapping const& mapping) {
+      if (!owner->template has<LoudnessMetadatas>()) {
+        return;
+      }
+
+      auto loudnessMetadatas = owner->template get<LoudnessMetadatas>();
+      bool changed = false;
+      for (auto& loudnessMetadata : loudnessMetadatas) {
+        if (!loudnessMetadata.template has<LoudnessRenderer>()) {
+          continue;
+        }
+
+        auto renderer = loudnessMetadata.template get<LoudnessRenderer>();
+
+        if (renderer.template has<RendererPackFormatIdRefs>()) {
+          auto remapped = remapPackFormatRefs(
+              renderer.template get<RendererPackFormatIdRefs>(), mapping);
+          if (remapped.empty()) {
+            renderer.template unset<RendererPackFormatIdRefs>();
+          } else {
+            renderer.set(std::move(remapped));
+          }
+          changed = true;
+        }
+
+        if (renderer.template has<RendererObjectIdRefs>()) {
+          auto remapped = remapObjectRefs(
+              renderer.template get<RendererObjectIdRefs>(), mapping);
+          if (remapped.empty()) {
+            renderer.template unset<RendererObjectIdRefs>();
+          } else {
+            renderer.set(std::move(remapped));
+          }
+          changed = true;
+        }
+
+        loudnessMetadata.set(std::move(renderer));
+      }
+
+      if (changed) {
+        owner->set(std::move(loudnessMetadatas));
+      }
+    }
+  }  // namespace
 
   std::vector<ElementVariant> copyAllElements(
-      std::shared_ptr<const Document> document) {
-    ElementMapping mapping;
+      std::shared_ptr<const Document> document, ElementMapping& mapping) {
     std::vector<ElementVariant> copiedElements;
     // copy
     for (const auto& element : document->getElements<AudioProgramme>()) {
@@ -92,7 +212,62 @@ namespace adm {
       resolveReference(element, mapping.audioTrackUid,
                        mapping.audioChannelFormat);
     }
+
+    for (const auto& element : document->getElements<AudioProgramme>()) {
+      auto copiedProgramme = mapping.audioProgramme.at(element);
+      remapAuthoringInformationReferences(copiedProgramme, mapping);
+      remapLoudnessRendererReferences(copiedProgramme, mapping);
+    }
+
+    for (const auto& element : document->getElements<AudioContent>()) {
+      auto copiedContent = mapping.audioContent.at(element);
+      remapLoudnessRendererReferences(copiedContent, mapping);
+    }
+
     return copiedElements;
   }
 
+  std::vector<ElementVariant> copyAllElements(
+      std::shared_ptr<const Document> document) {
+    ElementMapping mapping;
+    return copyAllElements(std::move(document), mapping);
+  }
+
+  void copyAuxiliary(std::shared_ptr<const Document> src,
+                     std::shared_ptr<Document> dest,
+                     ElementMapping const& mapping) {
+    if (src->has<Version>()) dest->set(src->get<Version>());
+    if (src->has<ProfileList>()) dest->set(src->get<ProfileList>());
+    if (!src->has<TagList>()) return;
+
+    auto srcTagList = src->get<TagList>();
+    TagList newTagList;
+    for (auto const& srcGroup : srcTagList.get<TagGroups>()) {
+      // Translate each ref through the mapping. The source document is
+      // assumed valid: Document::set(TagList) and Document::remove() keep
+      // every TagGroup ref attached to the document, so it is guaranteed
+      // to be in the mapping (mirrors the assumption used by
+      // resolveReferences for ordinary cross-references). TagGroup has no
+      // default ctor, so the first translated ref seeds the new group.
+      std::unique_ptr<TagGroup> newGroup;
+      auto translate = [&](auto const& srcRefs, auto const& mappingMap) {
+        for (auto const& r : srcRefs) {
+          auto const& mapped = mappingMap.at(r);
+          if (!newGroup)
+            newGroup.reset(new TagGroup(mapped));
+          else
+            newGroup->addReference(mapped);
+        }
+      };
+      translate(srcGroup.getReferences<AudioObject>(), mapping.audioObject);
+      translate(srcGroup.getReferences<AudioContent>(), mapping.audioContent);
+      translate(srcGroup.getReferences<AudioProgramme>(),
+                mapping.audioProgramme);
+      if (!newGroup) continue;  // not possible for a valid source document
+      for (auto const& tag : srcGroup.get<Tags>()) newGroup->add(tag);
+      newTagList.add(*newGroup);
+    }
+    dest->set(std::move(newTagList));
+  }
+
 }  // namespace adm
diff --git a/src/private/document_parser.cpp b/src/private/document_parser.cpp
index cb2635b8..cbfc006f 100644
--- a/src/private/document_parser.cpp
+++ b/src/private/document_parser.cpp
@@ -3,6 +3,9 @@
 #include "adm/private/xml_parser_helper.hpp"
 #include "adm/detail/named_type_validators.hpp"
 #include "adm/errors.hpp"
+
+#include <algorithm>
+
 namespace adm {
   namespace xml {
 
@@ -110,7 +113,22 @@ namespace adm {
         resolveReference(streamFormatChannelFormatRef_);
         resolveReference(streamFormatPackFormatRef_);
         resolveReferences(streamFormatTrackFormatRefs_);
+        resolveProgrammeAuthoringRendererReferences();
+        resolveProgrammeLoudnessRendererReferences();
+        resolveContentLoudnessRendererReferences();
 
+        // add other ADM elements to ADM document
+        for (NodePtr node = root->first_node(); node;
+             node = node->next_sibling()) {
+          std::string nodeName(node->name(), node->name_size());
+          if (nodeName == "profileList") {
+            // Can't use the local add function as that contains an ID setting
+            document_->set(parseProfileList(node));
+          } else if (nodeName == "tagList") {
+            // Can't use the local add function as that contains an ID setting
+            document_->set(parseTagList(node));
+          }
+        }
       } else {
         throw error::XmlParsingError("audioFormatExtended node not found");
       }
@@ -222,10 +240,61 @@ namespace adm {
 
       setOptionalMultiElement<LoudnessMetadatas>(node, "loudnessMetadata", audioProgramme, &parseLoudnessMetadatas);
       setOptionalElement<AudioProgrammeReferenceScreen>(node, "audioProgrammeReferenceScreen", audioProgramme, &parseAudioProgrammeReferenceScreen);
+      setOptionalElement<AuthoringInformation>(node, "authoringInformation", audioProgramme, &parseAuthoringInformation);
 
       addOptionalReferences<AudioContentId>(node, "audioContentIDRef", audioProgramme, programmeContentRefs_, &parseAudioContentId);
 
       addOptionalElements<Label>(node, "audioProgrammeLabel", audioProgramme, &parseLabel);
+
+      if (auto authoringNode = detail::findElement(node, "authoringInformation")) {
+        std::vector<AudioPackFormatId> referenceLayoutIds;
+        for (auto& layoutNode : detail::findElements(authoringNode, "referenceLayout")) {
+          auto packNode = detail::findElement(layoutNode, "audioPackFormatIDRef");
+          if (!packNode) {
+            throw error::XmlParsingError(
+                "referenceLayout requires an audioPackFormatIDRef child",
+                getDocumentLine(layoutNode));
+          }
+          referenceLayoutIds.push_back(parseAudioPackFormatId(packNode->value()));
+        }
+        if (!referenceLayoutIds.empty()) {
+          programmeAuthoringReferenceLayoutPackFormatRefs_[audioProgramme] =
+              std::move(referenceLayoutIds);
+        }
+
+        std::vector<std::vector<AudioPackFormatId>> rendererPackFormatIds;
+        for (auto& rendererNode : detail::findElements(authoringNode, "renderer")) {
+          std::vector<AudioPackFormatId> packFormatIds;
+          for (auto& packNode : detail::findElements(rendererNode, "audioPackFormatIDRef")) {
+            packFormatIds.push_back(parseAudioPackFormatId(packNode->value()));
+          }
+          rendererPackFormatIds.push_back(std::move(packFormatIds));
+        }
+        if (!rendererPackFormatIds.empty()) {
+          programmeAuthoringRendererPackFormatRefs_[audioProgramme] =
+              std::move(rendererPackFormatIds);
+        }
+      }
+
+      auto loudnessMetadataNodes = detail::findElements(node, "loudnessMetadata");
+      if (!loudnessMetadataNodes.empty()) {
+        std::vector<RendererNestedIds> loudnessRendererRefs;
+        loudnessRendererRefs.reserve(loudnessMetadataNodes.size());
+        for (auto& loudnessNode : loudnessMetadataNodes) {
+          RendererNestedIds refs;
+          if (auto rendererNode = detail::findElement(loudnessNode, "renderer")) {
+            for (auto& packNode : detail::findElements(rendererNode, "audioPackFormatIDRef")) {
+              refs.packFormatIds.push_back(parseAudioPackFormatId(packNode->value()));
+            }
+            for (auto& objectNode : detail::findElements(rendererNode, "audioObjectIDRef")) {
+              refs.objectIds.push_back(parseAudioObjectId(objectNode->value()));
+            }
+          }
+          loudnessRendererRefs.push_back(std::move(refs));
+        }
+        programmeLoudnessRendererRefs_[audioProgramme] =
+            std::move(loudnessRendererRefs);
+      }
       // clang-format on
       return audioProgramme;
     }
@@ -248,6 +317,26 @@ namespace adm {
       addOptionalReferences<AudioObjectId>(node, "audioObjectIDRef", audioContent, contentObjectRefs_, &parseAudioObjectId);
 
       addOptionalElements<Label>(node, "audioContentLabel", audioContent, &parseLabel);
+
+      auto loudnessMetadataNodes = detail::findElements(node, "loudnessMetadata");
+      if (!loudnessMetadataNodes.empty()) {
+        std::vector<RendererNestedIds> loudnessRendererRefs;
+        loudnessRendererRefs.reserve(loudnessMetadataNodes.size());
+        for (auto& loudnessNode : loudnessMetadataNodes) {
+          RendererNestedIds refs;
+          if (auto rendererNode = detail::findElement(loudnessNode, "renderer")) {
+            for (auto& packNode : detail::findElements(rendererNode, "audioPackFormatIDRef")) {
+              refs.packFormatIds.push_back(parseAudioPackFormatId(packNode->value()));
+            }
+            for (auto& objectNode : detail::findElements(rendererNode, "audioObjectIDRef")) {
+              refs.objectIds.push_back(parseAudioObjectId(objectNode->value()));
+            }
+          }
+          loudnessRendererRefs.push_back(std::move(refs));
+        }
+        contentLoudnessRendererRefs_[audioContent] =
+            std::move(loudnessRendererRefs);
+      }
       // clang-format on
       return audioContent;
     }
@@ -400,6 +489,187 @@ namespace adm {
       }
     }
 
+    void DocumentParser::resolveProgrammeAuthoringRendererReferences() {
+      for (auto const& programme : document_->getElements<AudioProgramme>()) {
+        if (!programme->has<AuthoringInformation>()) {
+          continue;
+        }
+
+        auto info = programme->get<AuthoringInformation>();
+        bool changed = false;
+
+        auto layoutIt =
+            programmeAuthoringReferenceLayoutPackFormatRefs_.find(programme);
+        if (layoutIt !=
+            programmeAuthoringReferenceLayoutPackFormatRefs_.end()) {
+          auto const& referenceLayoutIds = layoutIt->second;
+          ReferenceLayouts referenceLayouts;
+          referenceLayouts.reserve(referenceLayoutIds.size());
+          for (auto const& id : referenceLayoutIds) {
+            if (auto element = idMap_.lookup(id)) {
+              referenceLayouts.push_back(ReferenceLayout{element});
+            } else {
+              throw error::XmlParsingUnresolvedReference(formatId(id));
+            }
+          }
+          if (!referenceLayouts.empty()) {
+            info.set(std::move(referenceLayouts));
+          }
+          changed = true;
+        }
+
+        auto rendererIt =
+            programmeAuthoringRendererPackFormatRefs_.find(programme);
+        if (rendererIt != programmeAuthoringRendererPackFormatRefs_.end() &&
+            info.has<Renderers>()) {
+          auto const& rendererPackIds = rendererIt->second;
+          auto renderers = info.get<Renderers>();
+          auto count = std::min(renderers.size(), rendererPackIds.size());
+          for (size_t i = 0; i < count; ++i) {
+            auto& renderer = renderers.at(i);
+            auto const& ids = rendererPackIds.at(i);
+            if (ids.empty()) {
+              continue;
+            }
+
+            RendererPackFormatIdRefs refs;
+            refs.reserve(ids.size());
+            for (auto const& id : ids) {
+              if (auto element = idMap_.lookup(id)) {
+                refs.push_back(element);
+              } else {
+                throw error::XmlParsingUnresolvedReference(formatId(id));
+              }
+            }
+            if (!refs.empty()) {
+              renderer.set(std::move(refs));
+            }
+          }
+          info.unset<Renderers>();
+          for (auto& renderer : renderers) {
+            info.add(std::move(renderer));
+          }
+          changed = true;
+        }
+
+        if (changed) {
+          programme->set(std::move(info));
+        }
+      }
+    }
+
+    void DocumentParser::resolveProgrammeLoudnessRendererReferences() {
+      for (auto const& entry : programmeLoudnessRendererRefs_) {
+        auto const& programme = entry.first;
+        auto const& rendererIds = entry.second;
+        if (!programme->has<LoudnessMetadatas>()) {
+          continue;
+        }
+
+        auto loudnessMetadatas = programme->get<LoudnessMetadatas>();
+        auto count = std::min(loudnessMetadatas.size(), rendererIds.size());
+        for (size_t i = 0; i < count; ++i) {
+          auto& loudnessMetadata = loudnessMetadatas.at(i);
+          if (!loudnessMetadata.has<LoudnessRenderer>()) {
+            continue;
+          }
+
+          auto renderer = loudnessMetadata.get<LoudnessRenderer>();
+          auto const& ids = rendererIds.at(i);
+
+          if (!ids.packFormatIds.empty()) {
+            RendererPackFormatIdRefs packRefs;
+            packRefs.reserve(ids.packFormatIds.size());
+            for (auto const& id : ids.packFormatIds) {
+              if (auto element = idMap_.lookup(id)) {
+                packRefs.push_back(element);
+              } else {
+                throw error::XmlParsingUnresolvedReference(formatId(id));
+              }
+            }
+            if (!packRefs.empty()) {
+              renderer.set(std::move(packRefs));
+            }
+          }
+
+          if (!ids.objectIds.empty()) {
+            RendererObjectIdRefs objectRefs;
+            objectRefs.reserve(ids.objectIds.size());
+            for (auto const& id : ids.objectIds) {
+              if (auto element = idMap_.lookup(id)) {
+                objectRefs.push_back(element);
+              } else {
+                throw error::XmlParsingUnresolvedReference(formatId(id));
+              }
+            }
+            if (!objectRefs.empty()) {
+              renderer.set(std::move(objectRefs));
+            }
+          }
+
+          loudnessMetadata.set(std::move(renderer));
+        }
+
+        programme->set(std::move(loudnessMetadatas));
+      }
+    }
+
+    void DocumentParser::resolveContentLoudnessRendererReferences() {
+      for (auto const& entry : contentLoudnessRendererRefs_) {
+        auto const& content = entry.first;
+        auto const& rendererIds = entry.second;
+        if (!content->has<LoudnessMetadatas>()) {
+          continue;
+        }
+
+        auto loudnessMetadatas = content->get<LoudnessMetadatas>();
+        auto count = std::min(loudnessMetadatas.size(), rendererIds.size());
+        for (size_t i = 0; i < count; ++i) {
+          auto& loudnessMetadata = loudnessMetadatas.at(i);
+          if (!loudnessMetadata.has<LoudnessRenderer>()) {
+            continue;
+          }
+
+          auto renderer = loudnessMetadata.get<LoudnessRenderer>();
+          auto const& ids = rendererIds.at(i);
+
+          if (!ids.packFormatIds.empty()) {
+            RendererPackFormatIdRefs packRefs;
+            packRefs.reserve(ids.packFormatIds.size());
+            for (auto const& id : ids.packFormatIds) {
+              if (auto element = idMap_.lookup(id)) {
+                packRefs.push_back(element);
+              } else {
+                throw error::XmlParsingUnresolvedReference(formatId(id));
+              }
+            }
+            if (!packRefs.empty()) {
+              renderer.set(std::move(packRefs));
+            }
+          }
+
+          if (!ids.objectIds.empty()) {
+            RendererObjectIdRefs objectRefs;
+            objectRefs.reserve(ids.objectIds.size());
+            for (auto const& id : ids.objectIds) {
+              if (auto element = idMap_.lookup(id)) {
+                objectRefs.push_back(element);
+              } else {
+                throw error::XmlParsingUnresolvedReference(formatId(id));
+              }
+            }
+            if (!objectRefs.empty()) {
+              renderer.set(std::move(objectRefs));
+            }
+          }
+
+          loudnessMetadata.set(std::move(renderer));
+        }
+
+        content->set(std::move(loudnessMetadatas));
+      }
+    }
+
     void DocumentParser::setCommonProperties(
         std::shared_ptr<AudioPackFormat> audioPackFormat, NodePtr node) {
       // clang-format off
@@ -540,6 +810,121 @@ namespace adm {
       return profileList;
     }
 
+    Tag parseTTag(NodePtr node) {
+      Tag ttag;
+      setValue<TagValue>(node, ttag);
+      setOptionalAttribute<TagClass>(node, "class", ttag);
+      return ttag;
+    }
+
+    struct TagGroupBuilder {
+      TagGroupBuilder(std::vector<NodePtr> programmeNodes,
+                      std::vector<NodePtr> contentNodes,
+                      std::vector<NodePtr> objectNodes) {
+        for (auto n : programmeNodes) {
+          programmeIds.push_back(parseAudioProgrammeId(n->value()));
+        }
+        for (auto n : contentNodes) {
+          contentIds.push_back(parseAudioContentId(n->value()));
+        }
+        for (auto n : objectNodes) {
+          objectIds.push_back(parseAudioObjectId(n->value()));
+        }
+      }
+
+      bool valid_ids() const {
+        return !(programmeIds.empty() && contentIds.empty() &&
+                 objectIds.empty());
+      }
+
+      void resolveReferences(adm::detail::IDMap& map) {
+        for (auto const& id : programmeIds) {
+          if (auto element = map.lookup(id)) {
+            programmes.push_back(element);
+          }
+        }
+        for (auto const& id : contentIds) {
+          if (auto element = map.lookup(id)) {
+            contents.push_back(element);
+          }
+        }
+        for (auto const& id : objectIds) {
+          if (auto element = map.lookup(id)) {
+            objects.push_back(element);
+          }
+        }
+      }
+
+      bool valid_references() {
+        return !(programmes.empty() && contents.empty() && objects.empty());
+      }
+
+      template <typename T>
+      void add_all(std::vector<std::shared_ptr<T>> const& refs,
+                   TagGroup& group) {
+        for (auto const& r : refs) {
+          group.addReference(r);
+        }
+      }
+
+      template <typename T>
+      std::shared_ptr<TagGroup> create_with(
+          std::vector<std::shared_ptr<T>>& refs) {
+        auto last = refs.back();
+        auto group = std::make_shared<TagGroup>(last);
+        refs.pop_back();
+        add_all(refs, *group);
+        refs.clear();
+        return group;
+      }
+
+      std::shared_ptr<TagGroup> build(adm::detail::IDMap& id_map) {
+        std::shared_ptr<TagGroup> group;
+        if (!valid_ids()) return group;
+        resolveReferences(id_map);
+        if (!valid_references()) return group;
+        if (!programmes.empty()) {
+          group = create_with(programmes);
+        } else if (!contents.empty()) {
+          group = create_with(contents);
+        } else if (!objects.empty()) {
+          group = create_with(objects);
+        }
+        add_all(programmes, *group);
+        add_all(contents, *group);
+        add_all(objects, *group);
+        return group;
+      }
+
+      std::vector<AudioProgrammeId> programmeIds;
+      std::vector<AudioContentId> contentIds;
+      std::vector<AudioObjectId> objectIds;
+      std::vector<std::shared_ptr<AudioProgramme>> programmes;
+      std::vector<std::shared_ptr<AudioContent>> contents;
+      std::vector<std::shared_ptr<AudioObject>> objects;
+    };
+
+    std::shared_ptr<TagGroup> DocumentParser::parseTagGroup(NodePtr node) {
+      TagGroupBuilder builder(detail::findElements(node, "audioProgrammeIDRef"),
+                              detail::findElements(node, "audioContentIDRef"),
+                              detail::findElements(node, "audioObjectIDRef"));
+      auto tagGroup = builder.build(idMap_);
+      if (!tagGroup) {
+        throw std::runtime_error("Error parsing tag group");
+      }
+      addOptionalElements<Tag>(node, "tag", tagGroup, &parseTTag);
+      return tagGroup;
+    }
+
+    TagList DocumentParser::parseTagList(NodePtr node) {
+      TagList tagList;
+      auto elements = detail::findElements(node, "tagGroup");
+      for (auto& element : elements) {
+        detail::invokeAdd(tagList, TagGroup(*parseTagGroup(element)));
+      }
+      return tagList;
+    }
+
     namespace {
       template <typename T>
       void addTimeParametersToBlock(
@@ -599,6 +984,7 @@ namespace adm {
       setOptionalAttribute<AudioBlockFormatId>(node, "audioBlockFormatID", audioBlockFormat, &parseAudioBlockFormatId);
       addTimeParametersToBlock(node, audioBlockFormat, timeReference);
       setOptionalAttribute<InitializeBlock>(node, "initializeBlock", audioBlockFormat);
+      setOptionalElement<Cartesian>(node, "cartesian", audioBlockFormat);
       setMultiElement<SpeakerPosition>(node, "position", audioBlockFormat, &parseSpeakerPosition);
       addOptionalElements<SpeakerLabel>(node, "speakerLabel", audioBlockFormat, &parseSpeakerLabel);
       setOptionalElement<HeadLocked>(node, "headLocked", audioBlockFormat);
@@ -943,6 +1329,20 @@ namespace adm {
       return jumpPosition;
     }
 
+    template <typename T>
+    void setRendererCommonParameters(NodePtr node, T& renderer) {
+      setOptionalAttribute<RendererName>(node, "name", renderer);
+      setOptionalAttribute<RendererVersion>(node, "version", renderer);
+      setOptionalAttribute<CoordinateMode>(node, "coordinateMode", renderer);
+    }
+
+    LoudnessRenderer parseLoudnessRenderer(NodePtr node) {
+      LoudnessRenderer renderer;
+      setRendererCommonParameters(node, renderer);
+      setOptionalAttribute<RendererUri>(node, "uri", renderer);
+      return renderer;
+    }
+
     LoudnessMetadata parseLoudnessMetadata(NodePtr node) {
       LoudnessMetadata loudnessMetadata;
       setOptionalAttribute<LoudnessMethod>(node, "loudnessMethod",
@@ -960,6 +1360,8 @@ namespace adm {
       setOptionalElement<MaxShortTerm>(node, "maxShortTerm", loudnessMetadata);
       setOptionalElement<DialogueLoudness>(node, "dialogueLoudness",
                                            loudnessMetadata);
+      setOptionalElement<LoudnessRenderer>(node, "renderer", loudnessMetadata,
+                                           &parseLoudnessRenderer);
       return loudnessMetadata;
     }
 
@@ -995,8 +1397,29 @@ namespace adm {
     }
 
     AudioProgrammeReferenceScreen parseAudioProgrammeReferenceScreen(
-        NodePtr /* node */) {
-      return AudioProgrammeReferenceScreen();
+        NodePtr node) {
+      AudioProgrammeReferenceScreen screen;
+      setOptionalAttribute<CoordinateMode>(node, "coordinateMode", screen);
+      return screen;
+    }
+
+    AuthoringRenderer parseAuthoringRenderer(NodePtr node) {
+      auto uri = parseAttribute<RendererUri>(node, "uri");
+      AuthoringRenderer renderer{uri};
+      setRendererCommonParameters(node, renderer);
+      return renderer;
+    }
+
+    AuthoringInformation parseAuthoringInformation(NodePtr node) {
+      AuthoringInformation info;
+      Renderers renderers;
+      for (auto& rendererNode : detail::findElements(node, "renderer")) {
+        renderers.push_back(parseAuthoringRenderer(rendererNode));
+      }
+      if (!renderers.empty()) {
+        info.set(std::move(renderers));
+      }
+      return info;
     }
 
     AudioBlockFormatHoa parseAudioBlockFormatHoa(
diff --git a/src/private/rapidxml_formatter.cpp b/src/private/rapidxml_formatter.cpp
index eed2d7bf..0cbed2cc 100644
--- a/src/private/rapidxml_formatter.cpp
+++ b/src/private/rapidxml_formatter.cpp
@@ -78,6 +78,46 @@ namespace adm {
 
     }  // namespace detail
 
+    void formatAudioProgrammeReferenceScreen(
+        XmlNode &node, const AudioProgrammeReferenceScreen &screen) {
+      node.addOptionalAttribute<CoordinateMode>(&screen, "coordinateMode");
+    }
+
+    template <typename T>
+    void formatRendererCommon(XmlNode &node, const T &renderer) {
+      node.addOptionalAttribute<RendererUri>(&renderer, "uri");
+      node.addOptionalAttribute<RendererName>(&renderer, "name");
+      node.addOptionalAttribute<RendererVersion>(&renderer, "version");
+      node.addOptionalAttribute<CoordinateMode>(&renderer, "coordinateMode");
+      for (auto const &packRef :
+           renderer.template get<RendererPackFormatIdRefs>()) {
+        node.addElement("audioPackFormatIDRef",
+                        formatId(packRef->template get<AudioPackFormatId>()));
+      }
+    }
+
+    void formatAuthoringRenderer(XmlNode &node,
+                                 const AuthoringRenderer &renderer) {
+      formatRendererCommon(node, renderer);
+    }
+
+    void formatReferenceLayout(XmlNode &node, const ReferenceLayout &layout) {
+      node.addElement("audioPackFormatIDRef",
+                      formatId(layout.get()->get<AudioPackFormatId>()));
+    }
+
+    void formatAuthoringInformation(XmlNode &node,
+                                    const AuthoringInformation &info) {
+      for (auto const &layout : info.get<ReferenceLayouts>()) {
+        auto layoutNode = node.addNode("referenceLayout");
+        formatReferenceLayout(layoutNode, layout);
+      }
+      for (auto const &renderer : info.get<Renderers>()) {
+        auto rendererNode = node.addNode("renderer");
+        formatAuthoringRenderer(rendererNode, renderer);
+      }
+    }
+
     void formatAudioProgramme(
         XmlNode &node, const std::shared_ptr<const AudioProgramme> programme) {
       // clang-format off
@@ -89,10 +129,21 @@ namespace adm {
       node.addOptionalAttribute<MaxDuckingDepth>(programme, "maxDuckingDepth");
       node.addReferences<AudioContent, AudioContentId>(programme, "audioContentIDRef");
       node.addVectorElements<LoudnessMetadatas>(programme, "loudnessMetadata", &formatLoudnessMetadata);
+      node.addOptionalElement<AuthoringInformation>(programme, "authoringInformation", &formatAuthoringInformation);
+      node.addOptionalElement<AudioProgrammeReferenceScreen>(programme, "audioProgrammeReferenceScreen", &formatAudioProgrammeReferenceScreen);
       node.addVectorElements<Labels>(programme, "audioProgrammeLabel", &formatLabel);
       // clang-format on
     }
 
+    void formatLoudnessRenderer(XmlNode &node,
+                                const LoudnessRenderer &renderer) {
+      formatRendererCommon(node, renderer);
+      for (auto const &objectRef : renderer.get<RendererObjectIdRefs>()) {
+        node.addElement("audioObjectIDRef",
+                        formatId(objectRef->get<AudioObjectId>()));
+      }
+    }
+
     void formatLoudnessMetadata(XmlNode &node,
                                 const LoudnessMetadata loudnessMetadata) {
       node.addOptionalAttribute<LoudnessMethod>(&loudnessMetadata,
@@ -110,6 +161,8 @@ namespace adm {
       node.addOptionalElement<MaxShortTerm>(&loudnessMetadata, "maxShortTerm");
       node.addOptionalElement<DialogueLoudness>(&loudnessMetadata,
                                                 "dialogueLoudness");
+      node.addOptionalElement<LoudnessRenderer>(&loudnessMetadata, "renderer",
+                                                &formatLoudnessRenderer);
     }
 
     void formatAudioContent(XmlNode &node,
@@ -349,6 +402,7 @@ namespace adm {
       if(audioBlock.has<CartesianSpeakerPosition>()) {
         node.addMultiElement<CartesianSpeakerPosition>(&audioBlock, "position", &formatCartesianSpeakerPosition);
       }
+      node.addOptionalElement<Cartesian>(&audioBlock, "cartesian");
 
       node.addOptionalElement<HeadLocked>(&audioBlock, "headLocked");
       node.addOptionalElement<HeadphoneVirtualise>(&audioBlock, "headphoneVirtualise", &formatHeadphoneVirtualise);
@@ -789,5 +843,25 @@ namespace adm {
       node.addAttribute<ProfileVersion>(&profile, "profileVersion");
       node.addAttribute<ProfileLevel>(&profile, "profileLevel");
     }
+
+    void formatTagList(XmlNode &node, const TagList &tagList) {
+      node.addVectorElements<TagGroups>(&tagList, "tagGroup", &formatTagGroup);
+    }
+
+    void formatTagGroup(XmlNode &node, const TagGroup &tagGroup) {
+      node.addVectorElements<Tags>(&tagGroup, "tag", &formatTag);
+      node.addReferences<AudioProgramme, AudioProgrammeId>(
+          &tagGroup, "audioProgrammeIDRef");
+      node.addReferences<AudioContent, AudioContentId>(&tagGroup,
+                                                       "audioContentIDRef");
+      node.addReferences<AudioObject, AudioObjectId>(&tagGroup,
+                                                     "audioObjectIDRef");
+    }
+
+    void formatTag(XmlNode &node, const Tag &tag) {
+      node.setValue(tag.get<TagValue>());
+      node.addOptionalAttribute<TagClass>(&tag, "class");
+    }
+
   }  // namespace xml
 }  // namespace adm
diff --git a/src/private/xml_writer.cpp b/src/private/xml_writer.cpp
index 6ebc608a..401c45af 100644
--- a/src/private/xml_writer.cpp
+++ b/src/private/xml_writer.cpp
@@ -30,6 +30,8 @@ namespace adm {
           TimeReference timeReference = TimeReference::TOTAL) {
         // clang-format off
         audioFormatExtended.addOptionalAttribute<Version>(document, "version");
+        audioFormatExtended.addOptionalElement<ProfileList>(document, "profileList", &formatProfileList);
+        audioFormatExtended.addOptionalElement<TagList>(document, "tagList", &formatTagList);
         audioFormatExtended.addBaseElements<AudioProgramme, AudioProgrammeId>(document, "audioProgramme", &formatAudioProgramme);
         audioFormatExtended.addBaseElements<AudioContent, AudioContentId>(document, "audioContent", &formatAudioContent);
         audioFormatExtended.addBaseElements<AudioObject, AudioObjectId>(document, "audioObject", &formatAudioObject);
diff --git a/src/utilities/copy.cpp b/src/utilities/copy.cpp
index f6fa1db1..28ae3807 100644
--- a/src/utilities/copy.cpp
+++ b/src/utilities/copy.cpp
@@ -10,8 +10,10 @@ namespace adm {
 
   void deepCopyTo(std::shared_ptr<const Document> src,
                   std::shared_ptr<Document> dest) {
-    auto copiedElements = copyAllElements(src);
+    ElementMapping mapping;
+    auto copiedElements = copyAllElements(src, mapping);
     addElements(copiedElements, dest);
+    copyAuxiliary(src, dest, mapping);
   }
 
 }  // namespace adm
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 0fef76a9..56ebfc0d 100755
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -40,6 +40,8 @@ add_adm_test("audio_object_tests")
 add_adm_test("audio_pack_format_tests")
 add_adm_test("audio_pack_format_hoa_tests")
 add_adm_test("audio_programme_tests")
+add_adm_test("audio_programme_ref_screen_tests")
+add_adm_test("authoring_information_tests")
 add_adm_test("audio_stream_format_tests")
 add_adm_test("audio_track_format_tests")
 add_adm_test("audio_track_uid_tests")
@@ -60,6 +62,7 @@ add_adm_test("gain_tests")
 add_adm_test("jump_position_tests")
 add_adm_test("label_tests")
 add_adm_test("loudness_metadata_tests")
+add_adm_test("loudness_renderer_tests")
 add_adm_test("named_type_tests")
 add_adm_test("object_creation_tests")
 add_adm_test("object_divergence_tests")
@@ -67,13 +70,17 @@ add_adm_test("position_interaction_range_tests")
 add_adm_test("position_tests")
 add_adm_test("position_offset_tests")
 add_adm_test("profile_list_tests")
+add_adm_test("renderer_interop_tests")
 add_adm_test("route_tracer_tests")
 add_adm_test("screen_edge_lock_tests")
 add_adm_test("speaker_position_tests")
 add_adm_test("type_descriptor_tests")
 add_adm_test("version_tests")
+add_adm_test("tag_list_tests")
 add_adm_test("xml_audio_block_format_objects_tests")
 add_adm_test("xml_loudness_metadata_tests")
+add_adm_test("xml_loudness_renderer_tests")
+add_adm_test("xml_authoring_information_tests")
 add_adm_test("xml_parser_audio_block_format_direct_speakers_tests")
 add_adm_test("xml_parser_audio_block_format_hoa_tests")
 add_adm_test("xml_parser_audio_block_format_binaural_tests")
diff --git a/tests/adm_document_tests.cpp b/tests/adm_document_tests.cpp
index 1fdd289f..5ed2ad79 100644
--- a/tests/adm_document_tests.cpp
+++ b/tests/adm_document_tests.cpp
@@ -356,6 +356,157 @@ TEST_CASE("copy_document_all_adm_elements") {
           copy->getElements<AudioChannelFormat>()[0]);
 }
 
+TEST_CASE("copy_document_remaps_2076_3_renderer_references") {
+  using namespace adm;
+
+  auto admDocument = Document::create();
+
+  auto programme = AudioProgramme::create(AudioProgrammeName("Programme"));
+  auto content = AudioContent::create(AudioContentName("Content"));
+  auto object = AudioObject::create(AudioObjectName("Object"));
+  auto packA = AudioPackFormat::create(AudioPackFormatName("PackA"),
+                                       TypeDefinition::OBJECTS);
+  auto packB = AudioPackFormat::create(AudioPackFormatName("PackB"),
+                                       TypeDefinition::OBJECTS);
+
+  object->addReference(packA);
+  object->addReference(packB);
+  content->addReference(object);
+  programme->addReference(content);
+  admDocument->add(programme);
+
+  auto packAId = packA->get<AudioPackFormatId>();
+  auto packBId = packB->get<AudioPackFormatId>();
+  auto objectId = object->get<AudioObjectId>();
+
+  AuthoringInformation info;
+  AuthoringRenderer authoringRenderer{
+      RendererUri{"urn:itu:bs:2127:0:itu_adm_renderer"}};
+  authoringRenderer.set(RendererPackFormatIdRefs{packA, packB});
+  info.add(authoringRenderer);
+  info.add(ReferenceLayout{packA});
+  info.add(ReferenceLayout{packB});
+  programme->set(info);
+
+  LoudnessRenderer programmeRenderer;
+  programmeRenderer.set(RendererPackFormatIdRefs{packA, packB});
+  programmeRenderer.set(RendererObjectIdRefs{object});
+  LoudnessMetadata programmeLm;
+  programmeLm.set(programmeRenderer);
+  programme->set(LoudnessMetadatas{programmeLm});
+
+  LoudnessRenderer contentRenderer;
+  contentRenderer.set(RendererPackFormatIdRefs{packA, packB});
+  contentRenderer.set(RendererObjectIdRefs{object});
+  LoudnessMetadata contentLm;
+  contentLm.set(contentRenderer);
+  content->set(LoudnessMetadatas{contentLm});
+
+  auto copy = admDocument->deepCopy();
+
+  auto copiedProgramme = copy->getElements<AudioProgramme>().front();
+  auto copiedContent = copy->getElements<AudioContent>().front();
+
+  auto copiedInfo = copiedProgramme->get<AuthoringInformation>();
+  REQUIRE(copiedInfo.has<Renderers>());
+  auto copiedRenderers = copiedInfo.get<Renderers>();
+  REQUIRE(copiedRenderers.size() == 1);
+  REQUIRE(copiedRenderers.at(0).has<RendererPackFormatIdRefs>());
+  auto copiedAuthoringRefs =
+      copiedRenderers.at(0).get<RendererPackFormatIdRefs>();
+  REQUIRE(copiedAuthoringRefs.size() == 2);
+  bool sawPackAInAuthoring = false;
+  bool sawPackBInAuthoring = false;
+  for (auto const& ref : copiedAuthoringRefs) {
+    REQUIRE(ref->getParent().lock() == copy);
+    REQUIRE(ref != packA);
+    REQUIRE(ref != packB);
+    if (ref->get<AudioPackFormatId>() == packAId) sawPackAInAuthoring = true;
+    if (ref->get<AudioPackFormatId>() == packBId) sawPackBInAuthoring = true;
+  }
+  REQUIRE(sawPackAInAuthoring);
+  REQUIRE(sawPackBInAuthoring);
+
+  REQUIRE(copiedInfo.has<ReferenceLayouts>());
+  auto copiedLayouts = copiedInfo.get<ReferenceLayouts>();
+  REQUIRE(copiedLayouts.size() == 2);
+  bool sawPackAInLayouts = false;
+  bool sawPackBInLayouts = false;
+  for (auto const& layout : copiedLayouts) {
+    auto const& pack = layout.get();
+    REQUIRE(pack->getParent().lock() == copy);
+    REQUIRE(pack != packA);
+    REQUIRE(pack != packB);
+    if (pack->get<AudioPackFormatId>() == packAId) sawPackAInLayouts = true;
+    if (pack->get<AudioPackFormatId>() == packBId) sawPackBInLayouts = true;
+  }
+  REQUIRE(sawPackAInLayouts);
+  REQUIRE(sawPackBInLayouts);
+
+  auto copiedProgrammeLms = copiedProgramme->get<LoudnessMetadatas>();
+  REQUIRE(copiedProgrammeLms.size() == 1);
+  auto copiedProgrammeRenderer =
+      copiedProgrammeLms.at(0).get<LoudnessRenderer>();
+  REQUIRE(copiedProgrammeRenderer.has<RendererPackFormatIdRefs>());
+  REQUIRE(copiedProgrammeRenderer.has<RendererObjectIdRefs>());
+
+  auto copiedProgrammePackRefs =
+      copiedProgrammeRenderer.get<RendererPackFormatIdRefs>();
+  REQUIRE(copiedProgrammePackRefs.size() == 2);
+  bool sawPackAInProgrammeRenderer = false;
+  bool sawPackBInProgrammeRenderer = false;
+  for (auto const& ref : copiedProgrammePackRefs) {
+    REQUIRE(ref->getParent().lock() == copy);
+    REQUIRE(ref != packA);
+    REQUIRE(ref != packB);
+    if (ref->get<AudioPackFormatId>() == packAId)
+      sawPackAInProgrammeRenderer = true;
+    if (ref->get<AudioPackFormatId>() == packBId)
+      sawPackBInProgrammeRenderer = true;
+  }
+  REQUIRE(sawPackAInProgrammeRenderer);
+  REQUIRE(sawPackBInProgrammeRenderer);
+
+  auto copiedProgrammeObjectRefs =
+      copiedProgrammeRenderer.get<RendererObjectIdRefs>();
+  REQUIRE(copiedProgrammeObjectRefs.size() == 1);
+  auto copiedProgrammeObject = copiedProgrammeObjectRefs.front();
+  REQUIRE(copiedProgrammeObject->getParent().lock() == copy);
+  REQUIRE(copiedProgrammeObject != object);
+  REQUIRE(copiedProgrammeObject->get<AudioObjectId>() == objectId);
+
+  auto copiedContentLms = copiedContent->get<LoudnessMetadatas>();
+  REQUIRE(copiedContentLms.size() == 1);
+  auto copiedContentRenderer = copiedContentLms.at(0).get<LoudnessRenderer>();
+  REQUIRE(copiedContentRenderer.has<RendererPackFormatIdRefs>());
+  REQUIRE(copiedContentRenderer.has<RendererObjectIdRefs>());
+
+  auto copiedContentPackRefs =
+      copiedContentRenderer.get<RendererPackFormatIdRefs>();
+  REQUIRE(copiedContentPackRefs.size() == 2);
+  bool sawPackAInContentRenderer = false;
+  bool sawPackBInContentRenderer = false;
+  for (auto const& ref : copiedContentPackRefs) {
+    REQUIRE(ref->getParent().lock() == copy);
+    REQUIRE(ref != packA);
+    REQUIRE(ref != packB);
+    if (ref->get<AudioPackFormatId>() == packAId)
+      sawPackAInContentRenderer = true;
+    if (ref->get<AudioPackFormatId>() == packBId)
+      sawPackBInContentRenderer = true;
+  }
+  REQUIRE(sawPackAInContentRenderer);
+  REQUIRE(sawPackBInContentRenderer);
+
+  auto copiedContentObjectRefs =
+      copiedContentRenderer.get<RendererObjectIdRefs>();
+  REQUIRE(copiedContentObjectRefs.size() == 1);
+  auto copiedContentObject = copiedContentObjectRefs.front();
+  REQUIRE(copiedContentObject->getParent().lock() == copy);
+  REQUIRE(copiedContentObject != object);
+  REQUIRE(copiedContentObject->get<AudioObjectId>() == objectId);
+}
+
 template <typename T>
 std::vector<T> asVector(std::initializer_list<T> l) {
   return std::vector<T>{l};
@@ -581,6 +732,140 @@ TEST_CASE("remove_elements") {
     REQUIRE(streamFormat->getReference<AudioPackFormat>() == nullptr);
   }
 
+  SECTION("AudioPackFormat – prunes authoring and loudness renderer IDs") {
+    auto admDocument = Document::create();
+
+    auto packFormat = AudioPackFormat::create(
+        AudioPackFormatName("My PackFormat"), TypeDefinition::OBJECTS);
+    admDocument->add(packFormat);
+
+    auto programme = AudioProgramme::create(AudioProgrammeName("Programme"));
+    auto content = AudioContent::create(AudioContentName("Content"));
+
+    // authoringInformation.renderer + referenceLayout
+    AuthoringInformation info;
+    AuthoringRenderer authoringRenderer{
+        RendererUri{"urn:itu:bs:2127:0:itu_adm_renderer"}};
+    authoringRenderer.set(RendererPackFormatIdRefs{packFormat});
+    info.add(authoringRenderer);
+    info.add(ReferenceLayout{packFormat});
+    programme->set(info);
+
+    // loudnessMetadata.renderer on programme
+    LoudnessRenderer programmeRenderer;
+    programmeRenderer.set(RendererPackFormatIdRefs{packFormat});
+    LoudnessMetadata programmeLm;
+    programmeLm.set(programmeRenderer);
+    programme->set(LoudnessMetadatas{programmeLm});
+
+    // loudnessMetadata.renderer on content
+    LoudnessRenderer contentRenderer;
+    contentRenderer.set(RendererPackFormatIdRefs{packFormat});
+    LoudnessMetadata contentLm;
+    contentLm.set(contentRenderer);
+    content->set(LoudnessMetadatas{contentLm});
+
+    admDocument->add(programme);
+    admDocument->add(content);
+
+    REQUIRE(admDocument->remove(packFormat));
+
+    auto updatedInfo = programme->get<AuthoringInformation>();
+    REQUIRE(updatedInfo.has<Renderers>());
+    auto renderers = updatedInfo.get<Renderers>();
+    REQUIRE(renderers.size() == 1);
+    REQUIRE(renderers.at(0).has<RendererPackFormatIdRefs>() == false);
+    REQUIRE(updatedInfo.has<ReferenceLayouts>() == false);
+
+    auto programmeLms = programme->get<LoudnessMetadatas>();
+    REQUIRE(programmeLms.size() == 1);
+    REQUIRE(programmeLms.at(0).has<LoudnessRenderer>());
+    auto updatedProgrammeRenderer = programmeLms.at(0).get<LoudnessRenderer>();
+    REQUIRE(updatedProgrammeRenderer.has<RendererPackFormatIdRefs>() == false);
+
+    auto contentLms = content->get<LoudnessMetadatas>();
+    REQUIRE(contentLms.size() == 1);
+    REQUIRE(contentLms.at(0).has<LoudnessRenderer>());
+    auto updatedContentRenderer = contentLms.at(0).get<LoudnessRenderer>();
+    REQUIRE(updatedContentRenderer.has<RendererPackFormatIdRefs>() == false);
+  }
+
+  SECTION(
+      "AudioPackFormat – prunes matching renderer IDs and preserves others") {
+    auto admDocument = Document::create();
+
+    auto removedPackFormat = AudioPackFormat::create(
+        AudioPackFormatName("Removed PackFormat"), TypeDefinition::OBJECTS);
+    auto keptPackFormat = AudioPackFormat::create(
+        AudioPackFormatName("Kept PackFormat"), TypeDefinition::OBJECTS);
+    admDocument->add(removedPackFormat);
+    admDocument->add(keptPackFormat);
+
+    auto programme = AudioProgramme::create(AudioProgrammeName("Programme"));
+    auto content = AudioContent::create(AudioContentName("Content"));
+
+    AuthoringInformation info;
+    AuthoringRenderer authoringRenderer{
+        RendererUri{"urn:itu:bs:2127:0:itu_adm_renderer"}};
+    authoringRenderer.set(
+        RendererPackFormatIdRefs{removedPackFormat, keptPackFormat});
+    info.add(authoringRenderer);
+    info.add(ReferenceLayout{removedPackFormat});
+    info.add(ReferenceLayout{keptPackFormat});
+    programme->set(info);
+
+    LoudnessRenderer programmeRenderer;
+    programmeRenderer.set(
+        RendererPackFormatIdRefs{removedPackFormat, keptPackFormat});
+    LoudnessMetadata programmeLm;
+    programmeLm.set(programmeRenderer);
+    programme->set(LoudnessMetadatas{programmeLm});
+
+    LoudnessRenderer contentRenderer;
+    contentRenderer.set(
+        RendererPackFormatIdRefs{removedPackFormat, keptPackFormat});
+    LoudnessMetadata contentLm;
+    contentLm.set(contentRenderer);
+    content->set(LoudnessMetadatas{contentLm});
+
+    admDocument->add(programme);
+    admDocument->add(content);
+
+    REQUIRE(admDocument->remove(removedPackFormat));
+
+    auto updatedInfo = programme->get<AuthoringInformation>();
+    REQUIRE(updatedInfo.has<Renderers>());
+    auto renderers = updatedInfo.get<Renderers>();
+    REQUIRE(renderers.size() == 1);
+    REQUIRE(renderers.at(0).has<RendererPackFormatIdRefs>());
+    auto authoringRefs = renderers.at(0).get<RendererPackFormatIdRefs>();
+    REQUIRE(authoringRefs.size() == 1);
+    REQUIRE(authoringRefs.at(0) == keptPackFormat);
+
+    REQUIRE(updatedInfo.has<ReferenceLayouts>());
+    auto layouts = updatedInfo.get<ReferenceLayouts>();
+    REQUIRE(layouts.size() == 1);
+    auto remainingLayout = layouts.at(0).get();
+    REQUIRE(remainingLayout == keptPackFormat);
+
+    auto programmeLms = programme->get<LoudnessMetadatas>();
+    REQUIRE(programmeLms.size() == 1);
+    auto updatedProgrammeRenderer = programmeLms.at(0).get<LoudnessRenderer>();
+    REQUIRE(updatedProgrammeRenderer.has<RendererPackFormatIdRefs>());
+    auto programmeRefs =
+        updatedProgrammeRenderer.get<RendererPackFormatIdRefs>();
+    REQUIRE(programmeRefs.size() == 1);
+    REQUIRE(programmeRefs.at(0) == keptPackFormat);
+
+    auto contentLms = content->get<LoudnessMetadatas>();
+    REQUIRE(contentLms.size() == 1);
+    auto updatedContentRenderer = contentLms.at(0).get<LoudnessRenderer>();
+    REQUIRE(updatedContentRenderer.has<RendererPackFormatIdRefs>());
+    auto contentRefs = updatedContentRenderer.get<RendererPackFormatIdRefs>();
+    REQUIRE(contentRefs.size() == 1);
+    REQUIRE(contentRefs.at(0) == keptPackFormat);
+  }
+
   SECTION("AudioChannelFormat – reference removal") {
     auto admDocument = Document::create();
     auto packFormat = AudioPackFormat::create(
@@ -630,6 +915,90 @@ TEST_CASE("remove_elements") {
     REQUIRE(streamFormat->getAudioTrackFormatReferences().size() == 0);
     REQUIRE(trackUid->getReference<AudioTrackFormat>() == nullptr);
   }
+
+  SECTION("AudioObject – prunes loudness renderer object IDs") {
+    auto admDocument = Document::create();
+
+    auto object = AudioObject::create(AudioObjectName("Object"));
+    admDocument->add(object);
+
+    auto programme = AudioProgramme::create(AudioProgrammeName("Programme"));
+    auto content = AudioContent::create(AudioContentName("Content"));
+
+    LoudnessRenderer programmeRenderer;
+    programmeRenderer.set(RendererObjectIdRefs{object});
+    LoudnessMetadata programmeLm;
+    programmeLm.set(programmeRenderer);
+    programme->set(LoudnessMetadatas{programmeLm});
+
+    LoudnessRenderer contentRenderer;
+    contentRenderer.set(RendererObjectIdRefs{object});
+    LoudnessMetadata contentLm;
+    contentLm.set(contentRenderer);
+    content->set(LoudnessMetadatas{contentLm});
+
+    admDocument->add(programme);
+    admDocument->add(content);
+
+    REQUIRE(admDocument->remove(object));
+
+    auto programmeLms = programme->get<LoudnessMetadatas>();
+    REQUIRE(programmeLms.size() == 1);
+    auto updatedProgrammeRenderer = programmeLms.at(0).get<LoudnessRenderer>();
+    REQUIRE(updatedProgrammeRenderer.has<RendererObjectIdRefs>() == false);
+
+    auto contentLms = content->get<LoudnessMetadatas>();
+    REQUIRE(contentLms.size() == 1);
+    auto updatedContentRenderer = contentLms.at(0).get<LoudnessRenderer>();
+    REQUIRE(updatedContentRenderer.has<RendererObjectIdRefs>() == false);
+  }
+
+  SECTION(
+      "AudioObject – prunes matching renderer object IDs and preserves "
+      "others") {
+    auto admDocument = Document::create();
+
+    auto removedObject = AudioObject::create(AudioObjectName("Removed Object"));
+    auto keptObject = AudioObject::create(AudioObjectName("Kept Object"));
+    admDocument->add(removedObject);
+    admDocument->add(keptObject);
+
+    auto programme = AudioProgramme::create(AudioProgrammeName("Programme"));
+    auto content = AudioContent::create(AudioContentName("Content"));
+
+    LoudnessRenderer programmeRenderer;
+    programmeRenderer.set(RendererObjectIdRefs{removedObject, keptObject});
+    LoudnessMetadata programmeLm;
+    programmeLm.set(programmeRenderer);
+    programme->set(LoudnessMetadatas{programmeLm});
+
+    LoudnessRenderer contentRenderer;
+    contentRenderer.set(RendererObjectIdRefs{removedObject, keptObject});
+    LoudnessMetadata contentLm;
+    contentLm.set(contentRenderer);
+    content->set(LoudnessMetadatas{contentLm});
+
+    admDocument->add(programme);
+    admDocument->add(content);
+
+    REQUIRE(admDocument->remove(removedObject));
+
+    auto programmeLms = programme->get<LoudnessMetadatas>();
+    REQUIRE(programmeLms.size() == 1);
+    auto updatedProgrammeRenderer = programmeLms.at(0).get<LoudnessRenderer>();
+    REQUIRE(updatedProgrammeRenderer.has<RendererObjectIdRefs>());
+    auto programmeRefs = updatedProgrammeRenderer.get<RendererObjectIdRefs>();
+    REQUIRE(programmeRefs.size() == 1);
+    REQUIRE(programmeRefs.at(0) == keptObject);
+
+    auto contentLms = content->get<LoudnessMetadatas>();
+    REQUIRE(contentLms.size() == 1);
+    auto updatedContentRenderer = contentLms.at(0).get<LoudnessRenderer>();
+    REQUIRE(updatedContentRenderer.has<RendererObjectIdRefs>());
+    auto contentRefs = updatedContentRenderer.get<RendererObjectIdRefs>();
+    REQUIRE(contentRefs.size() == 1);
+    REQUIRE(contentRefs.at(0) == keptObject);
+  }
 }
 
 // Tests deepcopy using a modified version of the kitchen sink test material from https://qc.ebu.io/testmaterial
@@ -642,3 +1011,24 @@ TEST_CASE("Copy the kitchen sink") {
   writeXml(xmlCopy, documentCopy);
   REQUIRE(xml.str() == xmlCopy.str());
 }
+
+TEST_CASE("recursion_depth_guard") {
+  // Adversarial input: a chain of 5000 audioPackFormats, each referencing
+  // the next. Document::add() recurses through getReferences(), which
+  // would overflow the stack without an explicit depth limit.
+  using namespace adm;
+  auto document = Document::create();
+  std::vector<std::shared_ptr<AudioPackFormat>> packs;
+  packs.reserve(5000);
+  for (int i = 0; i < 5000; ++i) {
+    packs.push_back(AudioPackFormat::create(AudioPackFormatName("p"),
+                                            TypeDefinition::OBJECTS));
+  }
+  for (size_t i = 0; i + 1 < packs.size(); ++i) {
+    packs[i]->addReference(packs[i + 1]);
+  }
+  // Adding the head element should now throw (depth-limit) rather than
+  // crash; the limit is well below 5000.
+  REQUIRE_THROWS_WITH(document->add(packs.front()),
+                      Catch::Contains("recursion depth exceeded"));
+}
diff --git a/tests/audio_block_format_direct_speakers_tests.cpp b/tests/audio_block_format_direct_speakers_tests.cpp
index b0b422a4..5804c19d 100644
--- a/tests/audio_block_format_direct_speakers_tests.cpp
+++ b/tests/audio_block_format_direct_speakers_tests.cpp
@@ -10,11 +10,14 @@ TEST_CASE("DirectSpeakers block format common subelements") {
   REQUIRE(blockFormat.has<Rtime>() == true);
   REQUIRE(blockFormat.has<Duration>() == false);
   REQUIRE(blockFormat.has<SpeakerLabels>() == false);
+  REQUIRE(blockFormat.has<Cartesian>() == true);
 
   REQUIRE(blockFormat.isDefault<Rtime>() == true);
+  REQUIRE(blockFormat.isDefault<Cartesian>() == true);
 
   auto defaultRtime = std::chrono::seconds{0};
   REQUIRE(blockFormat.get<Rtime>().get() == defaultRtime);
+  REQUIRE(blockFormat.get<Cartesian>() == false);
 
   auto rTime = std::chrono::seconds{1};
   auto duration = std::chrono::seconds{10};
@@ -60,6 +63,8 @@ TEST_CASE("DirectSpeakers block format with Spherical coordinates") {
             defaultPosition.get<Azimuth>());
     REQUIRE(blockFormat.get<SphericalSpeakerPosition>().get<Elevation>() ==
             defaultPosition.get<Elevation>());
+    REQUIRE(blockFormat.get<Cartesian>() == false);
+    REQUIRE(blockFormat.isDefault<Cartesian>() == true);
 
     auto speakerPosition =
         SphericalSpeakerPosition(Azimuth(30), Elevation(10), Distance(0.5));
@@ -70,6 +75,8 @@ TEST_CASE("DirectSpeakers block format with Spherical coordinates") {
             Approx(10));
     REQUIRE(blockFormat.get<SphericalSpeakerPosition>().get<Distance>() ==
             Approx(0.5));
+    REQUIRE(blockFormat.get<Cartesian>() == false);
+    REQUIRE(blockFormat.isDefault<Cartesian>() == true);
   }
 }
 
@@ -85,4 +92,65 @@ TEST_CASE("DirectSpeakers block format with Cartesian coordinates") {
   REQUIRE(retrievedPosition.get<X>() == speakerPosition.get<X>());
   REQUIRE(retrievedPosition.get<Y>() == speakerPosition.get<Y>());
   REQUIRE(retrievedPosition.get<Z>() == speakerPosition.get<Z>());
+  REQUIRE(blockFormat.get<Cartesian>() == true);
+  REQUIRE(blockFormat.isDefault<Cartesian>() == false);
+}
+
+TEST_CASE("DirectSpeakers block format cartesian interactions") {
+  using namespace adm;
+
+  SECTION("spherical speaker position does not set cartesian when unset") {
+    auto blockFormat = AudioBlockFormatDirectSpeakers{};
+    blockFormat.set(SphericalSpeakerPosition{Azimuth{30.0f}, Elevation{5.0f}});
+
+    REQUIRE(blockFormat.has<SphericalSpeakerPosition>() == true);
+    REQUIRE(blockFormat.has<CartesianSpeakerPosition>() == false);
+    REQUIRE(blockFormat.get<Cartesian>() == false);
+    REQUIRE(blockFormat.isDefault<Cartesian>() == true);
+  }
+
+  SECTION(
+      "unsetting cartesian with cartesian position sets default spherical") {
+    auto blockFormat = AudioBlockFormatDirectSpeakers{};
+    blockFormat.set(CartesianSpeakerPosition{X{0.8f}, Y{-0.3f}, Z{0.2f}});
+
+    REQUIRE(blockFormat.has<CartesianSpeakerPosition>() == true);
+    REQUIRE(blockFormat.get<Cartesian>() == true);
+
+    blockFormat.unset<Cartesian>();
+
+    REQUIRE(blockFormat.has<SphericalSpeakerPosition>() == true);
+    REQUIRE(blockFormat.has<CartesianSpeakerPosition>() == false);
+    REQUIRE(blockFormat.get<SphericalSpeakerPosition>().get<Azimuth>() ==
+            Approx(0.0f));
+    REQUIRE(blockFormat.get<SphericalSpeakerPosition>().get<Elevation>() ==
+            Approx(0.0f));
+    REQUIRE(blockFormat.get<SphericalSpeakerPosition>().has<Distance>() ==
+            false);
+    REQUIRE(blockFormat.get<Cartesian>() == false);
+    REQUIRE(blockFormat.isDefault<Cartesian>() == true);
+  }
+
+  SECTION(
+      "setting cartesian true with spherical position sets default cartesian") {
+    auto blockFormat = AudioBlockFormatDirectSpeakers{};
+    blockFormat.set(SphericalSpeakerPosition{Azimuth{10.0f}, Elevation{15.0f},
+                                             Distance{1.0f}});
+
+    REQUIRE(blockFormat.has<SphericalSpeakerPosition>() == true);
+    REQUIRE(blockFormat.get<SphericalSpeakerPosition>().get<Azimuth>() ==
+            Approx(10.0f));
+
+    blockFormat.set(Cartesian{true});
+
+    REQUIRE(blockFormat.has<CartesianSpeakerPosition>() == true);
+    REQUIRE(blockFormat.has<SphericalSpeakerPosition>() == false);
+    REQUIRE(blockFormat.get<CartesianSpeakerPosition>().get<X>() ==
+            Approx(0.0f));
+    REQUIRE(blockFormat.get<CartesianSpeakerPosition>().get<Y>() ==
+            Approx(0.0f));
+    REQUIRE(blockFormat.get<CartesianSpeakerPosition>().has<Z>() == false);
+    REQUIRE(blockFormat.get<Cartesian>() == true);
+    REQUIRE(blockFormat.isDefault<Cartesian>() == false);
+  }
 }
diff --git a/tests/audio_content_tests.cpp b/tests/audio_content_tests.cpp
index 6f4f78f8..da391f17 100644
--- a/tests/audio_content_tests.cpp
+++ b/tests/audio_content_tests.cpp
@@ -40,10 +40,15 @@ TEST_CASE("audio_content parameters") {
     SECTION("NonDialog") {
       check_optional_param<NonDialogueContentKind>(
           audioContent, canBeSetTo(NonDialogueContent::EFFECT));
+      check_optional_param<NonDialogueContentKind>(
+          audioContent, canBeSetTo(NonDialogueContent::MUSIC_AND_EFFECTS));
     }
     SECTION("Mixed") {
       check_optional_param<MixedContentKind>(
           audioContent, canBeSetTo(MixedContent::HEARING_IMPAIRED));
+      check_optional_param<MixedContentKind>(
+          audioContent,
+          canBeSetTo(MixedContent::COMPLETE_MAIN_HEARING_IMPAIRED_AD));
     }
   }
   SECTION("LoudnessMetadatas") {
diff --git a/tests/audio_programme_ref_screen_tests.cpp b/tests/audio_programme_ref_screen_tests.cpp
new file mode 100644
index 00000000..a1ee32a0
--- /dev/null
+++ b/tests/audio_programme_ref_screen_tests.cpp
@@ -0,0 +1,15 @@
+#include <catch2/catch.hpp>
+#include "adm/elements/audio_programme_ref_screen.hpp"
+#include "adm/elements/coordinate_mode.hpp"
+
+using namespace adm;
+
+TEST_CASE("audio_programme_ref_screen/coordinate_mode") {
+  AudioProgrammeReferenceScreen screen;
+  REQUIRE(screen.has<CoordinateMode>() == false);
+  screen.set(CoordinateMode("cartesian"));
+  REQUIRE(screen.has<CoordinateMode>() == true);
+  REQUIRE(screen.get<CoordinateMode>() == std::string{"cartesian"});
+  screen.unset<CoordinateMode>();
+  REQUIRE(screen.has<CoordinateMode>() == false);
+}
diff --git a/tests/authoring_information_tests.cpp b/tests/authoring_information_tests.cpp
new file mode 100644
index 00000000..679b2a8b
--- /dev/null
+++ b/tests/authoring_information_tests.cpp
@@ -0,0 +1,45 @@
+#include <catch2/catch.hpp>
+#include "adm/elements/authoring_information.hpp"
+#include "adm/elements/audio_pack_format.hpp"
+
+using namespace adm;
+
+TEST_CASE("authoring_information/empty") {
+  AuthoringInformation info;
+  REQUIRE(info.get<ReferenceLayouts>().empty());
+  REQUIRE(info.get<Renderers>().empty());
+}
+
+TEST_CASE("authoring_information/add_reference_layout") {
+  AuthoringInformation info;
+  auto packA = AudioPackFormat::create(AudioPackFormatName("packA"),
+                                       TypeDefinition::OBJECTS);
+  auto packB = AudioPackFormat::create(AudioPackFormatName("packB"),
+                                       TypeDefinition::OBJECTS);
+  info.add(ReferenceLayout{packA});
+  info.add(ReferenceLayout{packB});
+  auto layouts = info.get<ReferenceLayouts>();
+  REQUIRE(layouts.size() == 2);
+  REQUIRE(layouts.at(0).get() == packA);
+  REQUIRE(layouts.at(1).get() == packB);
+}
+
+TEST_CASE("authoring_information/add_renderer") {
+  AuthoringInformation info;
+  AuthoringRenderer renderer{RendererUri("urn:itu:bs:2127:0:itu_adm_renderer"),
+                             CoordinateMode("polar")};
+  auto packA = AudioPackFormat::create(AudioPackFormatName("packA"),
+                                       TypeDefinition::OBJECTS);
+  auto packB = AudioPackFormat::create(AudioPackFormatName("packB"),
+                                       TypeDefinition::OBJECTS);
+  RendererPackFormatIdRefs packs{packA, packB};
+  renderer.set(packs);
+  info.add(renderer);
+  auto renderers = info.get<Renderers>();
+  REQUIRE(renderers.size() == 1);
+  auto const& r = renderers.at(0);
+  REQUIRE(r.get<RendererUri>() ==
+          std::string{"urn:itu:bs:2127:0:itu_adm_renderer"});
+  REQUIRE(r.get<CoordinateMode>() == std::string{"polar"});
+  REQUIRE(r.get<RendererPackFormatIdRefs>().size() == 2);
+}
diff --git a/tests/loudness_renderer_tests.cpp b/tests/loudness_renderer_tests.cpp
new file mode 100644
index 00000000..e2c288dd
--- /dev/null
+++ b/tests/loudness_renderer_tests.cpp
@@ -0,0 +1,63 @@
+#include <catch2/catch.hpp>
+#include "adm/elements/loudness_renderer.hpp"
+#include "adm/elements/audio_pack_format.hpp"
+#include "adm/elements/audio_object.hpp"
+
+using namespace adm;
+
+TEST_CASE("loudness_renderer/empty") {
+  LoudnessRenderer renderer;
+  REQUIRE(renderer.has<RendererUri>() == false);
+  REQUIRE(renderer.has<RendererName>() == false);
+  REQUIRE(renderer.has<RendererVersion>() == false);
+  REQUIRE(renderer.has<CoordinateMode>() == false);
+  REQUIRE(renderer.get<RendererPackFormatIdRefs>().empty());
+  REQUIRE(renderer.get<RendererObjectIdRefs>().empty());
+}
+
+TEST_CASE("loudness_renderer/set_unset") {
+  LoudnessRenderer renderer;
+  renderer.set(RendererUri("urn:itu:bs:2127:0:itu_adm_renderer"));
+  renderer.set(RendererName("Rec. ITU-R BS.2127"));
+  renderer.set(RendererVersion("1.0.0"));
+  renderer.set(CoordinateMode("polar"));
+
+  REQUIRE(renderer.get<RendererUri>() ==
+          std::string{"urn:itu:bs:2127:0:itu_adm_renderer"});
+  REQUIRE(renderer.get<RendererName>() == std::string{"Rec. ITU-R BS.2127"});
+  REQUIRE(renderer.get<RendererVersion>() == std::string{"1.0.0"});
+  REQUIRE(renderer.get<CoordinateMode>() == std::string{"polar"});
+
+  renderer.unset<RendererUri>();
+  renderer.unset<RendererName>();
+  renderer.unset<RendererVersion>();
+  renderer.unset<CoordinateMode>();
+
+  REQUIRE(renderer.has<RendererUri>() == false);
+  REQUIRE(renderer.has<RendererName>() == false);
+  REQUIRE(renderer.has<RendererVersion>() == false);
+  REQUIRE(renderer.has<CoordinateMode>() == false);
+}
+
+TEST_CASE("loudness_renderer/id_refs") {
+  LoudnessRenderer renderer;
+  auto pack = AudioPackFormat::create(AudioPackFormatName("pack"),
+                                      TypeDefinition::OBJECTS);
+  auto objectA = AudioObject::create(AudioObjectName("objectA"));
+  auto objectB = AudioObject::create(AudioObjectName("objectB"));
+  RendererPackFormatIdRefs packs{pack};
+  RendererObjectIdRefs objects{objectA, objectB};
+  renderer.set(packs);
+  renderer.set(objects);
+
+  REQUIRE(renderer.get<RendererPackFormatIdRefs>().size() == 1);
+  REQUIRE(renderer.get<RendererObjectIdRefs>().size() == 2);
+}
+
+TEST_CASE("loudness_renderer/named_args_constructor") {
+  LoudnessRenderer renderer{RendererUri("urn:itu:bs:2127:0:itu_adm_renderer"),
+                            CoordinateMode("cartesian")};
+  REQUIRE(renderer.get<RendererUri>() ==
+          std::string{"urn:itu:bs:2127:0:itu_adm_renderer"});
+  REQUIRE(renderer.get<CoordinateMode>() == std::string{"cartesian"});
+}
diff --git a/tests/profile_list_tests.cpp b/tests/profile_list_tests.cpp
index 887ae81d..e5361902 100644
--- a/tests/profile_list_tests.cpp
+++ b/tests/profile_list_tests.cpp
@@ -66,3 +66,40 @@ TEST_CASE("sadm xml/profilelist") {
   writeXml(xml, document, header);
   CHECK_THAT(xml.str(), EqualsXmlFile("profile_list_frame_header"));
 }
+
+TEST_CASE("document deep copy preserves profile list") {
+  auto document = Document::create();
+
+  ProfileList profileList;
+  profileList.add(Profile{ProfileValue{"value1"}, ProfileName{"name1"},
+                          ProfileVersion{"version1"}, ProfileLevel{"level1"}});
+  profileList.add(Profile{ProfileValue{"value2"}, ProfileName{"name2"},
+                          ProfileVersion{"version2"}, ProfileLevel{"level2"}});
+  document->set(profileList);
+
+  auto documentCopy = document->deepCopy();
+  REQUIRE(documentCopy->has<ProfileList>());
+  auto copiedProfiles = documentCopy->get<ProfileList>().get<Profiles>();
+  REQUIRE(copiedProfiles.size() == 2);
+
+  CHECK(copiedProfiles.at(0).get<ProfileValue>() == "value1");
+  CHECK(copiedProfiles.at(0).get<ProfileName>() == "name1");
+  CHECK(copiedProfiles.at(0).get<ProfileVersion>() == "version1");
+  CHECK(copiedProfiles.at(0).get<ProfileLevel>() == "level1");
+
+  CHECK(copiedProfiles.at(1).get<ProfileValue>() == "value2");
+  CHECK(copiedProfiles.at(1).get<ProfileName>() == "name2");
+  CHECK(copiedProfiles.at(1).get<ProfileVersion>() == "version2");
+  CHECK(copiedProfiles.at(1).get<ProfileLevel>() == "level2");
+
+  ProfileList updatedProfileList;
+  updatedProfileList.add(
+      Profile{ProfileValue{"changed"}, ProfileName{"changed"},
+              ProfileVersion{"changed"}, ProfileLevel{"changed"}});
+  document->set(updatedProfileList);
+
+  auto copiedProfilesAfterUpdate =
+      documentCopy->get<ProfileList>().get<Profiles>();
+  REQUIRE(copiedProfilesAfterUpdate.size() == 2);
+  CHECK(copiedProfilesAfterUpdate.at(0).get<ProfileValue>() == "value1");
+}
diff --git a/tests/renderer_interop_tests.cpp b/tests/renderer_interop_tests.cpp
new file mode 100644
index 00000000..c85b86f0
--- /dev/null
+++ b/tests/renderer_interop_tests.cpp
@@ -0,0 +1,83 @@
+#include <catch2/catch.hpp>
+
+#include "adm/elements/authoring_information.hpp"
+#include "adm/elements/audio_object.hpp"
+#include "adm/elements/audio_pack_format.hpp"
+#include "adm/elements/loudness_metadata.hpp"
+#include "adm/elements/loudness_renderer.hpp"
+
+using namespace adm;
+
+TEST_CASE("renderer_interop/renderer_to_loudness_renderer") {
+  AuthoringRenderer renderer{RendererUri("urn:itu:bs:2127:0:itu_adm_renderer"),
+                             RendererName("Rec. ITU-R BS.2127"),
+                             RendererVersion("1.0.0"),
+                             CoordinateMode("cartesian")};
+  auto packA = AudioPackFormat::create(AudioPackFormatName("packA"),
+                                       TypeDefinition::OBJECTS);
+  auto packB = AudioPackFormat::create(AudioPackFormatName("packB"),
+                                       TypeDefinition::OBJECTS);
+  RendererPackFormatIdRefs packs{packA, packB};
+  renderer.set(packs);
+
+  auto loudnessRenderer = renderer.toLoudnessRenderer();
+
+  REQUIRE(loudnessRenderer.get<RendererUri>() ==
+          std::string{"urn:itu:bs:2127:0:itu_adm_renderer"});
+  REQUIRE(loudnessRenderer.get<RendererName>() ==
+          std::string{"Rec. ITU-R BS.2127"});
+  REQUIRE(loudnessRenderer.get<RendererVersion>() == std::string{"1.0.0"});
+  REQUIRE(loudnessRenderer.get<CoordinateMode>() == std::string{"cartesian"});
+  REQUIRE(loudnessRenderer.get<RendererPackFormatIdRefs>().size() == 2);
+  REQUIRE(loudnessRenderer.get<RendererObjectIdRefs>().empty());
+}
+
+TEST_CASE(
+    "renderer_interop/loudness_renderer_to_renderer_dropping_object_refs") {
+  LoudnessRenderer loudnessRenderer{
+      RendererUri("urn:itu:bs:2127:0:itu_adm_renderer"),
+      RendererName("Rec. ITU-R BS.2127"), RendererVersion("1.0.0"),
+      CoordinateMode("polar")};
+  auto pack = AudioPackFormat::create(AudioPackFormatName("pack"),
+                                      TypeDefinition::OBJECTS);
+  auto objectA = AudioObject::create(AudioObjectName("objectA"));
+  auto objectB = AudioObject::create(AudioObjectName("objectB"));
+  RendererPackFormatIdRefs packs{pack};
+  RendererObjectIdRefs objects{objectA, objectB};
+  loudnessRenderer.set(packs);
+  loudnessRenderer.set(objects);
+
+  auto renderer = loudnessRenderer.toRendererDroppingObjectRefs(
+      loudnessRenderer.get<RendererUri>());
+
+  REQUIRE(renderer.get<RendererUri>() ==
+          std::string{"urn:itu:bs:2127:0:itu_adm_renderer"});
+  REQUIRE(renderer.get<RendererName>() == std::string{"Rec. ITU-R BS.2127"});
+  REQUIRE(renderer.get<RendererVersion>() == std::string{"1.0.0"});
+  REQUIRE(renderer.get<CoordinateMode>() == std::string{"polar"});
+  REQUIRE(renderer.get<RendererPackFormatIdRefs>().size() == 1);
+
+  auto roundTrip = renderer.toLoudnessRenderer();
+  REQUIRE(roundTrip.get<RendererObjectIdRefs>().empty());
+  REQUIRE(roundTrip.get<RendererPackFormatIdRefs>().size() == 1);
+}
+
+TEST_CASE("renderer_interop/loudness_metadata_accepts_renderer") {
+  LoudnessMetadata loudnessMetadata;
+  AuthoringRenderer renderer{RendererUri("urn:itu:bs:2127:0:itu_adm_renderer"),
+                             CoordinateMode("polar")};
+  auto pack = AudioPackFormat::create(AudioPackFormatName("pack"),
+                                      TypeDefinition::OBJECTS);
+  RendererPackFormatIdRefs packs{pack};
+  renderer.set(packs);
+
+  loudnessMetadata.set(renderer);
+
+  REQUIRE(loudnessMetadata.has<LoudnessRenderer>());
+  auto loudnessRenderer = loudnessMetadata.get<LoudnessRenderer>();
+  REQUIRE(loudnessRenderer.get<RendererUri>() ==
+          std::string{"urn:itu:bs:2127:0:itu_adm_renderer"});
+  REQUIRE(loudnessRenderer.get<CoordinateMode>() == std::string{"polar"});
+  REQUIRE(loudnessRenderer.get<RendererPackFormatIdRefs>().size() == 1);
+  REQUIRE(loudnessRenderer.get<RendererObjectIdRefs>().empty());
+}
\ No newline at end of file
diff --git a/tests/tag_list_tests.cpp b/tests/tag_list_tests.cpp
new file mode 100644
index 00000000..eea54421
--- /dev/null
+++ b/tests/tag_list_tests.cpp
@@ -0,0 +1,255 @@
+#include <catch2/catch.hpp>
+#include "helper/parameter_checks.hpp"
+#include "adm/document.hpp"
+#include "adm/parse.hpp"
+#include "adm/write.hpp"
+#include "helper/file_comparator.hpp"
+#include "adm/elements/tag_list.hpp"
+#include "adm/utilities/object_creation.hpp"
+
+#include <iostream>
+
+using namespace adm;
+using namespace adm_test;
+
+TEST_CASE("Tag parameters") {
+  Tag tag{TagValue("value")};
+
+  check_optional_param<TagClass>(tag, canBeSetTo(TagClass{"class2"}));
+  check_required_param<TagValue>(tag, hasDefaultOf(TagValue{"value"}),
+                                 canBeSetTo(TagValue{"value2"}));
+}
+
+TEST_CASE("TagGroup parameters") {
+  auto programme = AudioProgramme::create(AudioProgrammeName{"Test"});
+  TagGroup tagGroup{programme};
+  Tag tag{TagClass("class"), TagValue("value")};
+
+  check_vector_param<Tags>(tagGroup, canBeSetTo(Tags{tag}));
+}
+
+TEST_CASE("TagList parameters") {
+  auto programme = AudioProgramme::create(AudioProgrammeName{"Test"});
+  Tag tag{TagClass("class"), TagValue("value")};
+  TagGroup tagGroup{programme};
+  tagGroup.add(tag);
+  TagList tagList;
+
+  check_vector_param<TagGroups>(tagList, canBeSetTo(TagGroups{tagGroup}));
+}
+
+TEST_CASE("adm xml/taglist") {
+  auto doc = parseXml("tag_list.accepted.xml");
+
+  REQUIRE(doc->has<TagList>());
+  auto tag_list = doc->get<TagList>();
+  auto tag_groups = tag_list.get<TagGroups>();
+  REQUIRE(tag_groups.size() == 1);
+
+  auto tag_group = tag_groups.at(0);
+  auto tags = tag_group.get<Tags>();
+  auto tag = tags.at(0);
+  CHECK(tag.get<TagClass>() == "class1");
+  CHECK(tag.get<TagValue>() == "value1");
+
+  std::stringstream xml;
+  writeXml(xml, doc);
+  CHECK_THAT(xml.str(), EqualsXmlFile("tag_list"));
+}
+
+TEST_CASE("document copy updates tagList references") {
+  auto doc = Document::create();
+  auto holder = addSimpleObjectTo(doc, "Test");
+  Tag tag{TagClass("class"), TagValue("value")};
+  auto programme = AudioProgramme::create(AudioProgrammeName{"Test"});
+  TagGroup tagGroup{programme};
+  tagGroup.add(tag);
+  tagGroup.addReference(holder.audioObject);
+  auto tagList = TagList{};
+  tagList.add(tagGroup);
+  doc->set(tagList);
+
+  auto doc_copy = doc->deepCopy();
+  auto copied_object = doc_copy->getElements<AudioObject>().front();
+  REQUIRE(doc_copy->has<TagList>());
+  auto copied_tag_groups = doc_copy->get<TagList>().get<TagGroups>();
+  REQUIRE(!copied_tag_groups.empty());
+  auto copied_tagged_object_refs =
+      copied_tag_groups.front().getReferences<AudioObject>();
+  REQUIRE(!copied_tagged_object_refs.empty());
+  auto tagged_object_ref = copied_tagged_object_refs.front();
+  REQUIRE(copied_object == tagged_object_ref);
+}
+
+TEST_CASE("document copy remaps tagList programme/content/object references") {
+  auto doc = Document::create();
+  auto programme = AudioProgramme::create(AudioProgrammeName{"Programme"});
+  auto content = AudioContent::create(AudioContentName{"Content"});
+  auto object = AudioObject::create(AudioObjectName{"Object"});
+  doc->add(programme);
+  doc->add(content);
+  doc->add(object);
+
+  TagGroup tagGroup{programme};
+  tagGroup.addReference(content);
+  tagGroup.addReference(object);
+  tagGroup.add(Tag{TagClass("class"), TagValue("value")});
+  TagList tagList{};
+  tagList.add(tagGroup);
+  doc->set(tagList);
+
+  auto docCopy = doc->deepCopy();
+  REQUIRE(docCopy->has<TagList>());
+
+  auto copiedProgramme = docCopy->getElements<AudioProgramme>().front();
+  auto copiedContent = docCopy->getElements<AudioContent>().front();
+  auto copiedObject = docCopy->getElements<AudioObject>().front();
+
+  auto copiedGroups = docCopy->get<TagList>().get<TagGroups>();
+  REQUIRE(copiedGroups.size() == 1);
+
+  auto copiedProgrammeRefs =
+      copiedGroups.front().getReferences<AudioProgramme>();
+  REQUIRE(copiedProgrammeRefs.size() == 1);
+  REQUIRE(copiedProgrammeRefs.front() == copiedProgramme);
+  REQUIRE(copiedProgrammeRefs.front() != programme);
+
+  auto copiedContentRefs = copiedGroups.front().getReferences<AudioContent>();
+  REQUIRE(copiedContentRefs.size() == 1);
+  REQUIRE(copiedContentRefs.front() == copiedContent);
+  REQUIRE(copiedContentRefs.front() != content);
+
+  auto copiedObjectRefs = copiedGroups.front().getReferences<AudioObject>();
+  REQUIRE(copiedObjectRefs.size() == 1);
+  REQUIRE(copiedObjectRefs.front() == copiedObject);
+  REQUIRE(copiedObjectRefs.front() != object);
+}
+
+TEST_CASE(
+    "removing last referenced element from document removes TagGroup and "
+    "transitively TagList") {
+  auto doc = Document::create();
+  auto holder = addSimpleObjectTo(doc, "Test");
+  Tag tag{TagClass("class"), TagValue("value")};
+  auto programme = AudioProgramme::create(AudioProgrammeName{"Test"});
+  TagGroup tagGroup{programme};
+  tagGroup.add(tag);
+  tagGroup.addReference(holder.audioObject);
+  auto tagList = TagList{};
+  tagList.add(tagGroup);
+  doc->set(tagList);
+  REQUIRE(doc->has<TagList>());
+  REQUIRE(doc->get<TagList>().get<TagGroups>().size() == 1);
+  doc->remove(holder.audioObject);
+  REQUIRE(!doc->has<TagList>());
+}
+
+TEST_CASE(
+    "removing referenced AudioProgramme from document removes TagGroup and "
+    "transitively TagList") {
+  auto doc = Document::create();
+  auto programme = AudioProgramme::create(AudioProgrammeName{"Programme"});
+  auto content = AudioContent::create(AudioContentName{"Content"});
+  doc->add(programme);
+  doc->add(content);
+
+  TagGroup tagGroup{programme};
+  tagGroup.add(Tag{TagClass("class"), TagValue("value")});
+  tagGroup.addReference(content);
+  TagList tagList{};
+  tagList.add(tagGroup);
+  doc->set(tagList);
+
+  REQUIRE(doc->has<TagList>());
+  REQUIRE(doc->get<TagList>().get<TagGroups>().size() == 1);
+  doc->remove(programme);
+  REQUIRE(!doc->has<TagList>());
+}
+
+TEST_CASE(
+    "removing referenced AudioContent from document removes TagGroup and "
+    "transitively TagList") {
+  auto doc = Document::create();
+  auto programme = AudioProgramme::create(AudioProgrammeName{"Programme"});
+  auto content = AudioContent::create(AudioContentName{"Content"});
+  doc->add(programme);
+  doc->add(content);
+
+  TagGroup tagGroup{programme};
+  tagGroup.add(Tag{TagClass("class"), TagValue("value")});
+  tagGroup.addReference(content);
+  TagList tagList{};
+  tagList.add(tagGroup);
+  doc->set(tagList);
+
+  REQUIRE(doc->has<TagList>());
+  REQUIRE(doc->get<TagList>().get<TagGroups>().size() == 1);
+  doc->remove(content);
+  REQUIRE(!doc->has<TagList>());
+}
+
+TEST_CASE(
+    "TagList referencing elements owned by another document is rejected") {
+  auto otherDoc = Document::create();
+  auto holder = addSimpleObjectTo(otherDoc, "Other");
+
+  TagGroup tagGroup{holder.audioObject};
+  tagGroup.add(Tag{TagValue("v")});
+  TagList tagList;
+  tagList.add(tagGroup);
+
+  auto doc = Document::create();
+  REQUIRE(doc->set(tagList) == false);
+  REQUIRE(!doc->has<TagList>());
+}
+
+TEST_CASE(
+    "TagList referencing unparented elements adopts them into the document") {
+  auto doc = Document::create();
+  auto programme = AudioProgramme::create(AudioProgrammeName{"P"});
+  auto content = AudioContent::create(AudioContentName{"C"});
+  auto object = AudioObject::create(AudioObjectName{"O"});
+
+  TagGroup tagGroup{programme};
+  tagGroup.addReference(content);
+  tagGroup.addReference(object);
+  tagGroup.add(Tag{TagValue("v")});
+  TagList tagList;
+  tagList.add(tagGroup);
+
+  doc->set(tagList);
+  REQUIRE(doc->has<TagList>());
+  // The previously-unparented elements should now belong to the document.
+  REQUIRE(programme->getParent().lock() == doc);
+  REQUIRE(content->getParent().lock() == doc);
+  REQUIRE(object->getParent().lock() == doc);
+  // ... and be reachable through the usual element collections.
+  auto programmes = doc->getElements<AudioProgramme>();
+  REQUIRE(std::find(programmes.begin(), programmes.end(), programme) !=
+          programmes.end());
+  auto contents = doc->getElements<AudioContent>();
+  REQUIRE(std::find(contents.begin(), contents.end(), content) !=
+          contents.end());
+  auto objects = doc->getElements<AudioObject>();
+  REQUIRE(std::find(objects.begin(), objects.end(), object) != objects.end());
+}
+
+TEST_CASE(
+    "TagGroups with same tag are only equal if references are also equal") {
+  auto object = adm::AudioObject::create(AudioObjectName("First"));
+  auto programme = adm::AudioProgramme::create(AudioProgrammeName("Second"));
+  Tag tag("Duplicate");
+  TagGroup first(object);
+  first.add(tag);
+
+  TagGroup second(programme);
+  second.add(tag);
+
+  TagGroup third(object);
+  third.add(tag);
+
+  REQUIRE(first != second);
+  REQUIRE(first == first);
+  REQUIRE(second == second);
+  REQUIRE(first == third);
+}
\ No newline at end of file
diff --git a/tests/test_data/authoring_information.accepted.xml b/tests/test_data/authoring_information.accepted.xml
new file mode 100644
index 00000000..b77f67ee
--- /dev/null
+++ b/tests/test_data/authoring_information.accepted.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns="urn:ebu:metadata-schema:ebuCore_2014" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" schema="EBU_CORE_20140201.xsd" xml:lang="en">
+	<coreMetadata>
+		<format>
+			<audioFormatExtended>
+				<audioProgramme audioProgrammeID="APR_1001" audioProgrammeName="MyProgramme">
+					<authoringInformation>
+						<referenceLayout>
+							<audioPackFormatIDRef>AP_00010003</audioPackFormatIDRef>
+						</referenceLayout>
+						<renderer uri="urn:itu:bs:2127:0:itu_adm_renderer" name="Rec. ITU-R BS.2127" version="1.0.0" coordinateMode="polar">
+							<audioPackFormatIDRef>AP_00010003</audioPackFormatIDRef>
+							<audioPackFormatIDRef>AP_00010017</audioPackFormatIDRef>
+						</renderer>
+					</authoringInformation>
+					<audioProgrammeReferenceScreen coordinateMode="cartesian"/>
+				</audioProgramme>
+			</audioFormatExtended>
+		</format>
+	</coreMetadata>
+</ebuCoreMain>
+
diff --git a/tests/test_data/loudness_renderer.accepted.xml b/tests/test_data/loudness_renderer.accepted.xml
new file mode 100644
index 00000000..41618cec
--- /dev/null
+++ b/tests/test_data/loudness_renderer.accepted.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns="urn:ebu:metadata-schema:ebuCore_2014" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" schema="EBU_CORE_20140201.xsd" xml:lang="en">
+	<coreMetadata>
+		<format>
+			<audioFormatExtended>
+				<audioProgramme audioProgrammeID="APR_1001" audioProgrammeName="MyProgramme">
+					<loudnessMetadata loudnessMethod="ITU-R BS.1770">
+						<integratedLoudness>-23.000000</integratedLoudness>
+						<renderer uri="urn:itu:bs:2127:0:itu_adm_renderer" name="Rec. ITU-R BS.2127" version="1.0.0" coordinateMode="polar">
+							<audioPackFormatIDRef>AP_00010002</audioPackFormatIDRef>
+							<audioObjectIDRef>AO_1001</audioObjectIDRef>
+							<audioObjectIDRef>AO_1002</audioObjectIDRef>
+						</renderer>
+					</loudnessMetadata>
+				</audioProgramme>
+				<audioObject audioObjectID="AO_1001" audioObjectName="Object 1"/>
+				<audioObject audioObjectID="AO_1002" audioObjectName="Object 2"/>
+			</audioFormatExtended>
+		</format>
+	</coreMetadata>
+</ebuCoreMain>
+
diff --git a/tests/test_data/tag_list.accepted.xml b/tests/test_data/tag_list.accepted.xml
new file mode 100644
index 00000000..4c349e5d
--- /dev/null
+++ b/tests/test_data/tag_list.accepted.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns="urn:ebu:metadata-schema:ebuCore_2014" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" schema="EBU_CORE_20140201.xsd" xml:lang="en">
+	<coreMetadata>
+		<format>
+			<audioFormatExtended>
+				<tagList>
+					<tagGroup>
+						<tag class="class1">value1</tag>
+						<audioProgrammeIDRef>APR_1001</audioProgrammeIDRef>
+						<audioContentIDRef>ACO_1001</audioContentIDRef>
+						<audioObjectIDRef>AO_1001</audioObjectIDRef>
+					</tagGroup>
+				</tagList>
+				<audioProgramme audioProgrammeID="APR_1001" audioProgrammeName="Programme1">
+					<audioContentIDRef>ACO_1001</audioContentIDRef>
+				</audioProgramme>
+				<audioContent audioContentID="ACO_1001" audioContentName="Content1">
+					<audioObjectIDRef>AO_1001</audioObjectIDRef>
+				</audioContent>
+				<audioObject audioObjectID="AO_1001" audioObjectName="Object1">
+					<audioPackFormatIDRef>AP_00010001</audioPackFormatIDRef>
+					<audioTrackUIDRef>ATU_00000001</audioTrackUIDRef>
+				</audioObject>
+				<audioTrackUID UID="ATU_00000001">
+					<audioTrackFormatIDRef>AT_00010003_01</audioTrackFormatIDRef>
+					<audioPackFormatIDRef>AP_00010001</audioPackFormatIDRef>
+				</audioTrackUID>
+			</audioFormatExtended>
+		</format>
+	</coreMetadata>
+</ebuCoreMain>
+
diff --git a/tests/test_data/write_default_cartesian_speaker.accepted.xml b/tests/test_data/write_default_cartesian_speaker.accepted.xml
index 44013271..269af8c9 100644
--- a/tests/test_data/write_default_cartesian_speaker.accepted.xml
+++ b/tests/test_data/write_default_cartesian_speaker.accepted.xml
@@ -7,6 +7,7 @@
 					<audioBlockFormat audioBlockFormatID="AB_00011001_00000001">
 						<position coordinate="X">0.000000</position>
 						<position coordinate="Y">0.000000</position>
+						<cartesian>1</cartesian>
 					</audioBlockFormat>
 				</audioChannelFormat>
 			</audioFormatExtended>
diff --git a/tests/test_data/write_specified_cartesian_speaker.accepted.xml b/tests/test_data/write_specified_cartesian_speaker.accepted.xml
index 99959e97..bbce659e 100644
--- a/tests/test_data/write_specified_cartesian_speaker.accepted.xml
+++ b/tests/test_data/write_specified_cartesian_speaker.accepted.xml
@@ -15,6 +15,7 @@
 						<position coordinate="Z">0.500000</position>
 						<position coordinate="Z" bound="min">0.400000</position>
 						<position coordinate="Z" bound="max">0.600000</position>
+						<cartesian>1</cartesian>
 						<headLocked>1</headLocked>
 						<gain>0.500000</gain>
 						<importance>5</importance>
diff --git a/tests/test_data/write_specified_headphone_virtualise.accepted.xml b/tests/test_data/write_specified_headphone_virtualise.accepted.xml
index daee63a0..eb81eda1 100644
--- a/tests/test_data/write_specified_headphone_virtualise.accepted.xml
+++ b/tests/test_data/write_specified_headphone_virtualise.accepted.xml
@@ -16,6 +16,7 @@
 					<audioBlockFormat audioBlockFormatID="AB_00011001_00000001">
 						<position coordinate="X">0.000000</position>
 						<position coordinate="Y">0.000000</position>
+						<cartesian>1</cartesian>
 						<headphoneVirtualise bypass="0" DRR="30.000000"/>
 					</audioBlockFormat>
 				</audioChannelFormat>
diff --git a/tests/test_data/xml_parser/audio_block_format_direct_speakers_cartesian.xml b/tests/test_data/xml_parser/audio_block_format_direct_speakers_cartesian.xml
index c4ee285d..fc7fafdb 100644
--- a/tests/test_data/xml_parser/audio_block_format_direct_speakers_cartesian.xml
+++ b/tests/test_data/xml_parser/audio_block_format_direct_speakers_cartesian.xml
@@ -15,6 +15,7 @@
 						<position coordinate="Z">0.500000</position>
 						<position coordinate="Z" bound="min">0.400000</position>
 						<position coordinate="Z" bound="max">0.600000</position>
+						<cartesian>1</cartesian>
 					</audioBlockFormat>
 				</audioChannelFormat>
 			</audioFormatExtended>
@@ -22,3 +23,4 @@
 	</coreMetadata>
 </ebuCoreMain>
 
+
diff --git a/tests/test_data/xml_parser/audio_block_format_direct_speakers_cartesian_spherical_mismatch.xml b/tests/test_data/xml_parser/audio_block_format_direct_speakers_cartesian_spherical_mismatch.xml
new file mode 100644
index 00000000..45f422a4
--- /dev/null
+++ b/tests/test_data/xml_parser/audio_block_format_direct_speakers_cartesian_spherical_mismatch.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain>
+  <coreMetadata>
+    <format>
+      <audioFormatExtended>
+        <audioChannelFormat audioChannelFormatID="AC_00011001" audioChannelFormatName="FrontLeft" typeLabel="0001" typeDefinition="DirectSpeakers">
+          <audioBlockFormat audioBlockFormatID="AB_00011001_00000001">
+            <position coordinate="X">0.0</position>
+            <position coordinate="Y">0.0</position>
+            <position coordinate="Z">0.5</position>
+            <cartesian>0</cartesian>
+          </audioBlockFormat>
+        </audioChannelFormat>
+      </audioFormatExtended>
+    </format>
+  </coreMetadata>
+</ebuCoreMain>
diff --git a/tests/test_data/xml_parser/audio_block_format_direct_speakers_spherical_cartesian_mismatch.xml b/tests/test_data/xml_parser/audio_block_format_direct_speakers_spherical_cartesian_mismatch.xml
new file mode 100644
index 00000000..60370e99
--- /dev/null
+++ b/tests/test_data/xml_parser/audio_block_format_direct_speakers_spherical_cartesian_mismatch.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain>
+  <coreMetadata>
+    <format>
+      <audioFormatExtended>
+        <audioChannelFormat audioChannelFormatID="AC_00011001" audioChannelFormatName="FrontLeft" typeLabel="0001" typeDefinition="DirectSpeakers">
+          <audioBlockFormat audioBlockFormatID="AB_00011001_00000001">
+            <position coordinate="azimuth">30.0</position>
+            <position coordinate="elevation">0.0</position>
+            <position coordinate="distance">1.0</position>
+            <cartesian>1</cartesian>
+          </audioBlockFormat>
+        </audioChannelFormat>
+      </audioFormatExtended>
+    </format>
+  </coreMetadata>
+</ebuCoreMain>
diff --git a/tests/test_data/xml_parser/audio_stream_format_forward_track_refs.xml b/tests/test_data/xml_parser/audio_stream_format_forward_track_refs.xml
new file mode 100644
index 00000000..42802057
--- /dev/null
+++ b/tests/test_data/xml_parser/audio_stream_format_forward_track_refs.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain>
+  <coreMetadata>
+    <format>
+      <audioFormatExtended>
+        <audioStreamFormat audioStreamFormatID="AS_00031001" audioStreamFormatName="MyStreamFormat" formatLabel="0001" formatDefinition="PCM">
+          <audioTrackFormatIDRef>AT_00031001_01</audioTrackFormatIDRef>
+          <audioTrackFormatIDRef>AT_00031002_01</audioTrackFormatIDRef>
+        </audioStreamFormat>
+
+        <audioTrackFormat audioTrackFormatID="AT_00031001_01" audioTrackFormatName="Track A" formatLabel="0001" formatDefinition="PCM"/>
+        <audioTrackFormat audioTrackFormatID="AT_00031002_01" audioTrackFormatName="Track B" formatLabel="0001" formatDefinition="PCM"/>
+      </audioFormatExtended>
+    </format>
+  </coreMetadata>
+</ebuCoreMain>
diff --git a/tests/test_data/xml_parser/authoring_information.xml b/tests/test_data/xml_parser/authoring_information.xml
new file mode 100644
index 00000000..e26acccd
--- /dev/null
+++ b/tests/test_data/xml_parser/authoring_information.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain>
+  <coreMetadata>
+    <format>
+      <audioFormatExtended>
+        <audioProgramme audioProgrammeID="APR_1001" audioProgrammeName="MyProgramme">
+          <authoringInformation>
+            <referenceLayout>
+              <audioPackFormatIDRef>AP_00010003</audioPackFormatIDRef>
+            </referenceLayout>
+            <renderer uri="urn:itu:bs:2127:0:itu_adm_renderer" name="Rec. ITU-R BS.2127" version="1.0.0" coordinateMode="polar">
+              <audioPackFormatIDRef>AP_00010003</audioPackFormatIDRef>
+              <audioPackFormatIDRef>AP_00010017</audioPackFormatIDRef>
+            </renderer>
+          </authoringInformation>
+          <audioProgrammeReferenceScreen coordinateMode="cartesian"/>
+        </audioProgramme>
+      </audioFormatExtended>
+    </format>
+  </coreMetadata>
+</ebuCoreMain>
diff --git a/tests/test_data/xml_parser/authoring_information_forward_pack_refs.xml b/tests/test_data/xml_parser/authoring_information_forward_pack_refs.xml
new file mode 100644
index 00000000..10175460
--- /dev/null
+++ b/tests/test_data/xml_parser/authoring_information_forward_pack_refs.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain>
+  <coreMetadata>
+    <format>
+      <audioFormatExtended>
+        <audioProgramme audioProgrammeID="APR_1001" audioProgrammeName="MyProgramme">
+          <authoringInformation>
+            <referenceLayout>
+              <audioPackFormatIDRef>AP_00031001</audioPackFormatIDRef>
+            </referenceLayout>
+            <renderer uri="urn:itu:bs:2127:0:itu_adm_renderer" name="Forward Renderer" version="1.0.0">
+              <audioPackFormatIDRef>AP_00031001</audioPackFormatIDRef>
+              <audioPackFormatIDRef>AP_00031002</audioPackFormatIDRef>
+            </renderer>
+          </authoringInformation>
+        </audioProgramme>
+
+        <audioPackFormat audioPackFormatID="AP_00031001" audioPackFormatName="Pack A"/>
+        <audioPackFormat audioPackFormatID="AP_00031002" audioPackFormatName="Pack B"/>
+      </audioFormatExtended>
+    </format>
+  </coreMetadata>
+</ebuCoreMain>
diff --git a/tests/test_data/xml_parser/authoring_information_identical_renderers.xml b/tests/test_data/xml_parser/authoring_information_identical_renderers.xml
new file mode 100644
index 00000000..d6e68fe2
--- /dev/null
+++ b/tests/test_data/xml_parser/authoring_information_identical_renderers.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain>
+  <coreMetadata>
+    <format>
+      <audioFormatExtended version="ITU-R_BS.2076-3">
+        <audioProgramme audioProgrammeID="APR_1001" audioProgrammeName="MyProgramme">
+          <authoringInformation>
+            <renderer uri="urn:itu:bs:2127:0:itu_adm_renderer">
+              <audioPackFormatIDRef>AP_00010001</audioPackFormatIDRef>
+            </renderer>
+            <renderer uri="urn:itu:bs:2127:0:itu_adm_renderer">
+              <audioPackFormatIDRef>AP_00010001</audioPackFormatIDRef>
+            </renderer>
+          </authoringInformation>
+        </audioProgramme>
+      </audioFormatExtended>
+    </format>
+  </coreMetadata>
+</ebuCoreMain>
diff --git a/tests/test_data/xml_parser/authoring_information_multiple_renderers.xml b/tests/test_data/xml_parser/authoring_information_multiple_renderers.xml
new file mode 100644
index 00000000..3c5c0d2e
--- /dev/null
+++ b/tests/test_data/xml_parser/authoring_information_multiple_renderers.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain>
+  <coreMetadata>
+    <format>
+      <audioFormatExtended version="ITU-R_BS.2076-3">
+        <audioProgramme audioProgrammeID="APR_1001" audioProgrammeName="MyProgramme">
+          <authoringInformation>
+            <renderer uri="urn:itu:bs:2127:0:itu_adm_renderer">
+              <audioPackFormatIDRef>AP_00010001</audioPackFormatIDRef>
+            </renderer>
+            <renderer uri="urn:itu:bs:2127:0:itu_adm_renderer">
+              <audioPackFormatIDRef>AP_00010002</audioPackFormatIDRef>
+            </renderer>
+          </authoringInformation>
+        </audioProgramme>
+      </audioFormatExtended>
+    </format>
+  </coreMetadata>
+</ebuCoreMain>
diff --git a/tests/test_data/xml_parser/loudness_renderer.xml b/tests/test_data/xml_parser/loudness_renderer.xml
new file mode 100644
index 00000000..f17df930
--- /dev/null
+++ b/tests/test_data/xml_parser/loudness_renderer.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain>
+  <coreMetadata>
+    <format>
+      <audioFormatExtended>
+        <audioProgramme audioProgrammeID="APR_1001" audioProgrammeName="MyProgramme">
+          <loudnessMetadata loudnessMethod="ITU-R BS.1770">
+            <integratedLoudness>-23.0</integratedLoudness>
+            <renderer uri="urn:itu:bs:2127:0:itu_adm_renderer" name="Rec. ITU-R BS.2127" version="1.0.0" coordinateMode="polar">
+              <audioPackFormatIDRef>AP_00010002</audioPackFormatIDRef>
+              <audioObjectIDRef>AO_1001</audioObjectIDRef>
+              <audioObjectIDRef>AO_1002</audioObjectIDRef>
+            </renderer>
+          </loudnessMetadata>
+        </audioProgramme>
+        <audioObject audioObjectID="AO_1001" audioObjectName="Object 1"/>
+        <audioObject audioObjectID="AO_1002" audioObjectName="Object 2"/>
+      </audioFormatExtended>
+    </format>
+  </coreMetadata>
+</ebuCoreMain>
diff --git a/tests/test_data/xml_parser/loudness_renderer_forward_refs.xml b/tests/test_data/xml_parser/loudness_renderer_forward_refs.xml
new file mode 100644
index 00000000..0882cb3f
--- /dev/null
+++ b/tests/test_data/xml_parser/loudness_renderer_forward_refs.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ebuCoreMain>
+  <coreMetadata>
+    <format>
+      <audioFormatExtended>
+        <audioProgramme audioProgrammeID="APR_1001" audioProgrammeName="MyProgramme">
+          <loudnessMetadata loudnessMethod="ITU-R BS.1770">
+            <renderer uri="urn:itu:bs:2127:0:itu_adm_renderer" name="Forward Renderer" version="1.0.0" coordinateMode="polar">
+              <audioPackFormatIDRef>AP_00031001</audioPackFormatIDRef>
+              <audioPackFormatIDRef>AP_00031002</audioPackFormatIDRef>
+              <audioObjectIDRef>AO_1001</audioObjectIDRef>
+              <audioObjectIDRef>AO_1002</audioObjectIDRef>
+            </renderer>
+          </loudnessMetadata>
+        </audioProgramme>
+
+        <audioContent audioContentID="ACO_1001" audioContentName="MyContent">
+          <loudnessMetadata loudnessMethod="ITU-R BS.1770">
+            <renderer uri="urn:itu:bs:2127:0:itu_adm_renderer" name="Forward Renderer" version="1.0.0" coordinateMode="polar">
+              <audioPackFormatIDRef>AP_00031001</audioPackFormatIDRef>
+              <audioPackFormatIDRef>AP_00031002</audioPackFormatIDRef>
+              <audioObjectIDRef>AO_1001</audioObjectIDRef>
+              <audioObjectIDRef>AO_1002</audioObjectIDRef>
+            </renderer>
+          </loudnessMetadata>
+        </audioContent>
+
+        <audioObject audioObjectID="AO_1001" audioObjectName="Object A"/>
+        <audioObject audioObjectID="AO_1002" audioObjectName="Object B"/>
+        <audioPackFormat audioPackFormatID="AP_00031001" audioPackFormatName="Pack A"/>
+        <audioPackFormat audioPackFormatID="AP_00031002" audioPackFormatName="Pack B"/>
+      </audioFormatExtended>
+    </format>
+  </coreMetadata>
+</ebuCoreMain>
diff --git a/tests/xml_authoring_information_tests.cpp b/tests/xml_authoring_information_tests.cpp
new file mode 100644
index 00000000..a406dd20
--- /dev/null
+++ b/tests/xml_authoring_information_tests.cpp
@@ -0,0 +1,115 @@
+#include <catch2/catch.hpp>
+#include <sstream>
+#include "adm/document.hpp"
+#include "adm/elements/audio_programme.hpp"
+#include "adm/elements/audio_programme_ref_screen.hpp"
+#include "adm/elements/authoring_information.hpp"
+#include "adm/elements/coordinate_mode.hpp"
+#include "adm/parse.hpp"
+#include "adm/write.hpp"
+#include "helper/file_comparator.hpp"
+
+using namespace adm;
+
+TEST_CASE("xml/authoring_information") {
+  auto document = parseXml("xml_parser/authoring_information.xml");
+
+  auto programme = document->lookup(parseAudioProgrammeId("APR_1001"));
+  REQUIRE(programme->has<AuthoringInformation>());
+  auto info = programme->get<AuthoringInformation>();
+  auto layouts = info.get<ReferenceLayouts>();
+  REQUIRE(layouts.size() == 1);
+  auto layoutPack = layouts.at(0).get();
+  REQUIRE(layoutPack->get<AudioPackFormatId>() ==
+          parseAudioPackFormatId("AP_00010003"));
+  auto renderers = info.get<Renderers>();
+  REQUIRE(renderers.size() == 1);
+  auto const& r = renderers.at(0);
+  REQUIRE(r.get<RendererUri>() ==
+          std::string{"urn:itu:bs:2127:0:itu_adm_renderer"});
+  REQUIRE(r.get<CoordinateMode>() == std::string{"polar"});
+  REQUIRE(r.get<RendererPackFormatIdRefs>().size() == 2);
+
+  REQUIRE(programme->has<AudioProgrammeReferenceScreen>());
+  auto screen = programme->get<AudioProgrammeReferenceScreen>();
+  REQUIRE(screen.has<CoordinateMode>());
+  REQUIRE(screen.get<CoordinateMode>() == std::string{"cartesian"});
+
+  std::stringstream xml;
+  writeXml(xml, document);
+  CHECK_THAT(xml.str(), EqualsXmlFile("authoring_information"));
+}
+
+TEST_CASE("xml/authoring_information_forward_pack_refs") {
+  auto document =
+      parseXml("xml_parser/authoring_information_forward_pack_refs.xml");
+
+  auto programme = document->lookup(parseAudioProgrammeId("APR_1001"));
+  REQUIRE(programme->has<AuthoringInformation>());
+  auto info = programme->get<AuthoringInformation>();
+  REQUIRE(info.has<ReferenceLayouts>());
+  auto layouts = info.get<ReferenceLayouts>();
+  REQUIRE(layouts.size() == 1);
+  auto layoutPack = layouts.at(0).get();
+  REQUIRE(layoutPack->get<AudioPackFormatId>() ==
+          parseAudioPackFormatId("AP_00031001"));
+
+  auto renderers = info.get<Renderers>();
+  REQUIRE(renderers.size() == 1);
+
+  auto const& renderer = renderers.at(0);
+  REQUIRE(renderer.has<RendererPackFormatIdRefs>());
+  auto packRefs = renderer.get<RendererPackFormatIdRefs>();
+  REQUIRE(packRefs.size() == 2);
+
+  auto packA = document->lookup(parseAudioPackFormatId("AP_00031001"));
+  REQUIRE(packA);
+  auto packB = document->lookup(parseAudioPackFormatId("AP_00031002"));
+  REQUIRE(packB);
+
+  auto refA = packRefs.at(0);
+  auto refB = packRefs.at(1);
+  REQUIRE(refA == packA);
+  REQUIRE(refB == packB);
+
+  std::stringstream xml;
+  writeXml(xml, document);
+  REQUIRE(xml.str().find(
+              "<audioPackFormatIDRef>AP_00031001</audioPackFormatIDRef>") !=
+          std::string::npos);
+}
+
+TEST_CASE("xml/authoring_information_multiple_renderers") {
+  auto document =
+      parseXml("xml_parser/authoring_information_multiple_renderers.xml");
+
+  auto programme = document->lookup(parseAudioProgrammeId("APR_1001"));
+  REQUIRE(programme->has<AuthoringInformation>());
+  auto renderers = programme->get<AuthoringInformation>().get<Renderers>();
+  REQUIRE(renderers.size() == 2);
+
+  auto firstPackRefs = renderers.at(0).get<RendererPackFormatIdRefs>();
+  REQUIRE(firstPackRefs.size() == 1);
+  REQUIRE(firstPackRefs.at(0) ==
+          document->lookup(parseAudioPackFormatId("AP_00010001")));
+
+  auto secondPackRefs = renderers.at(1).get<RendererPackFormatIdRefs>();
+  REQUIRE(secondPackRefs.size() == 1);
+  REQUIRE(secondPackRefs.at(0) ==
+          document->lookup(parseAudioPackFormatId("AP_00010002")));
+}
+
+TEST_CASE("xml/authoring_information_identical_renderers") {
+  auto document =
+      parseXml("xml_parser/authoring_information_identical_renderers.xml");
+
+  auto programme = document->lookup(parseAudioProgrammeId("APR_1001"));
+  REQUIRE(programme->has<AuthoringInformation>());
+  auto renderers = programme->get<AuthoringInformation>().get<Renderers>();
+  REQUIRE(renderers.size() == 1);
+
+  auto packRefs = renderers.at(0).get<RendererPackFormatIdRefs>();
+  REQUIRE(packRefs.size() == 1);
+  REQUIRE(packRefs.at(0) ==
+          document->lookup(parseAudioPackFormatId("AP_00010001")));
+}
diff --git a/tests/xml_loudness_renderer_tests.cpp b/tests/xml_loudness_renderer_tests.cpp
new file mode 100644
index 00000000..986dd6d0
--- /dev/null
+++ b/tests/xml_loudness_renderer_tests.cpp
@@ -0,0 +1,72 @@
+#include <catch2/catch.hpp>
+#include <sstream>
+#include "adm/document.hpp"
+#include "adm/elements/audio_content.hpp"
+#include "adm/elements/audio_programme.hpp"
+#include "adm/elements/loudness_metadata.hpp"
+#include "adm/elements/loudness_renderer.hpp"
+#include "adm/parse.hpp"
+#include "adm/write.hpp"
+#include "helper/file_comparator.hpp"
+
+using namespace adm;
+
+TEST_CASE("xml/loudness_renderer") {
+  auto document = parseXml("xml_parser/loudness_renderer.xml");
+
+  auto programme = document->lookup(parseAudioProgrammeId("APR_1001"));
+  REQUIRE(programme->has<LoudnessMetadatas>());
+  auto const& lms = programme->get<LoudnessMetadatas>();
+  REQUIRE(lms.size() == 1);
+  auto const& lm = lms.at(0);
+  REQUIRE(lm.has<LoudnessRenderer>());
+  auto renderer = lm.get<LoudnessRenderer>();
+  REQUIRE(renderer.get<RendererUri>() ==
+          std::string{"urn:itu:bs:2127:0:itu_adm_renderer"});
+  REQUIRE(renderer.get<RendererName>() == std::string{"Rec. ITU-R BS.2127"});
+  REQUIRE(renderer.get<RendererVersion>() == std::string{"1.0.0"});
+  REQUIRE(renderer.get<CoordinateMode>() == std::string{"polar"});
+  REQUIRE(renderer.get<RendererPackFormatIdRefs>().size() == 1);
+  REQUIRE(renderer.get<RendererObjectIdRefs>().size() == 2);
+
+  std::stringstream xml;
+  writeXml(xml, document);
+  CHECK_THAT(xml.str(), EqualsXmlFile("loudness_renderer"));
+}
+
+TEST_CASE("xml/loudness_renderer_forward_refs") {
+  auto document = parseXml("xml_parser/loudness_renderer_forward_refs.xml");
+
+  auto packA = document->lookup(parseAudioPackFormatId("AP_00031001"));
+  auto packB = document->lookup(parseAudioPackFormatId("AP_00031002"));
+  auto objectA = document->lookup(parseAudioObjectId("AO_1001"));
+  auto objectB = document->lookup(parseAudioObjectId("AO_1002"));
+
+  auto verifyRendererRefs = [&](LoudnessRenderer const& renderer) {
+    REQUIRE(renderer.has<RendererPackFormatIdRefs>());
+    auto packRefs = renderer.get<RendererPackFormatIdRefs>();
+    REQUIRE(packRefs.size() == 2);
+    REQUIRE(packRefs.at(0) == packA);
+    REQUIRE(packRefs.at(1) == packB);
+
+    REQUIRE(renderer.has<RendererObjectIdRefs>());
+    auto objectRefs = renderer.get<RendererObjectIdRefs>();
+    REQUIRE(objectRefs.size() == 2);
+    REQUIRE(objectRefs.at(0) == objectA);
+    REQUIRE(objectRefs.at(1) == objectB);
+  };
+
+  auto programme = document->lookup(parseAudioProgrammeId("APR_1001"));
+  REQUIRE(programme->has<LoudnessMetadatas>());
+  auto programmeLms = programme->get<LoudnessMetadatas>();
+  REQUIRE(programmeLms.size() == 1);
+  REQUIRE(programmeLms.at(0).has<LoudnessRenderer>());
+  verifyRendererRefs(programmeLms.at(0).get<LoudnessRenderer>());
+
+  auto content = document->lookup(parseAudioContentId("ACO_1001"));
+  REQUIRE(content->has<LoudnessMetadatas>());
+  auto contentLms = content->get<LoudnessMetadatas>();
+  REQUIRE(contentLms.size() == 1);
+  REQUIRE(contentLms.at(0).has<LoudnessRenderer>());
+  verifyRendererRefs(contentLms.at(0).get<LoudnessRenderer>());
+}
diff --git a/tests/xml_parser_audio_block_format_direct_speakers_tests.cpp b/tests/xml_parser_audio_block_format_direct_speakers_tests.cpp
index 6d3b8151..6e5b266a 100644
--- a/tests/xml_parser_audio_block_format_direct_speakers_tests.cpp
+++ b/tests/xml_parser_audio_block_format_direct_speakers_tests.cpp
@@ -27,6 +27,8 @@ TEST_CASE("xml_parser/audio_block_format_direct_speakers") {
           30.0f);
   REQUIRE(firstBlockFormat.get<SphericalSpeakerPosition>().get<Elevation>() ==
           0.0f);
+  REQUIRE(firstBlockFormat.get<Cartesian>() == false);
+  REQUIRE(firstBlockFormat.isDefault<Cartesian>() == true);
   REQUIRE(firstBlockFormat.get<HeadphoneVirtualise>().get<Bypass>() == false);
   REQUIRE(firstBlockFormat.get<HeadphoneVirtualise>()
               .get<DirectToReverberantRatio>() == Approx(60));
@@ -84,9 +86,58 @@ TEST_CASE("xml_parser/audio_block_format_direct_speakers_cartesian") {
     REQUIRE(speakerPosition.has<ScreenEdgeLock>());
     auto edgeLock = speakerPosition.get<ScreenEdgeLock>();
     REQUIRE(edgeLock.get<HorizontalEdge>().get() == "left");
+    REQUIRE(firstBlockFormat.get<Cartesian>() == true);
+    REQUIRE(firstBlockFormat.isDefault<Cartesian>() == false);
   }
 }
 
+TEST_CASE(
+    "xml_parser/"
+    "audio_block_format_direct_speakers_spherical_cartesian_mismatch") {
+  using namespace adm;
+  auto document = parseXml(
+      "xml_parser/audio_block_format_direct_speakers_spherical_cartesian_"
+      "mismatch.xml");
+  auto channelFormat =
+      document->lookup(parseAudioChannelFormatId("AC_00011001"));
+  REQUIRE(channelFormat);
+
+  auto firstBlockFormat =
+      *(channelFormat->getElements<AudioBlockFormatDirectSpeakers>().begin());
+  REQUIRE(firstBlockFormat.has<SphericalSpeakerPosition>() == true);
+  REQUIRE(firstBlockFormat.has<CartesianSpeakerPosition>() == false);
+  auto speakerPosition = firstBlockFormat.get<SphericalSpeakerPosition>();
+  REQUIRE(speakerPosition.get<Azimuth>() == Approx(30.0f));
+  REQUIRE(speakerPosition.get<Elevation>() == Approx(0.0f));
+  REQUIRE(speakerPosition.get<Distance>() == Approx(1.0f));
+  REQUIRE(firstBlockFormat.get<Cartesian>() == false);
+  REQUIRE(firstBlockFormat.isDefault<Cartesian>() == false);
+}
+
+TEST_CASE(
+    "xml_parser/"
+    "audio_block_format_direct_speakers_cartesian_spherical_mismatch") {
+  using namespace adm;
+  auto document = parseXml(
+      "xml_parser/audio_block_format_direct_speakers_cartesian_spherical_"
+      "mismatch.xml");
+  auto channelFormat =
+      document->lookup(parseAudioChannelFormatId("AC_00011001"));
+  REQUIRE(channelFormat);
+
+  auto firstBlockFormat =
+      *(channelFormat->getElements<AudioBlockFormatDirectSpeakers>().begin());
+  REQUIRE(firstBlockFormat.has<CartesianSpeakerPosition>() == true);
+  REQUIRE(firstBlockFormat.has<SphericalSpeakerPosition>() == false);
+  auto speakerPosition = firstBlockFormat.get<CartesianSpeakerPosition>();
+  REQUIRE(speakerPosition.get<X>() == Approx(0.0f));
+  REQUIRE(speakerPosition.get<Y>() == Approx(0.0f));
+  REQUIRE(speakerPosition.has<Z>());
+  REQUIRE(speakerPosition.get<Z>() == Approx(0.5f));
+  REQUIRE(firstBlockFormat.get<Cartesian>() == true);
+  REQUIRE(firstBlockFormat.isDefault<Cartesian>() == false);
+}
+
 TEST_CASE("xml_parser/audio_block_format_direct_speakers_cartesian_bad_bound") {
   using namespace adm;
   REQUIRE_THROWS_AS(
diff --git a/tests/xml_parser_audio_stream_format_tests.cpp b/tests/xml_parser_audio_stream_format_tests.cpp
index 384e151b..f4b6f579 100644
--- a/tests/xml_parser_audio_stream_format_tests.cpp
+++ b/tests/xml_parser_audio_stream_format_tests.cpp
@@ -23,3 +23,18 @@ TEST_CASE("xml_parser/audio_stream_format_duplicate_id") {
       adm::parseXml("xml_parser/audio_stream_format_duplicate_id.xml"),
       adm::error::XmlParsingDuplicateId);
 }
+
+TEST_CASE("xml_parser/audio_stream_format_forward_track_format_references") {
+  using namespace adm;
+  auto document =
+      parseXml("xml_parser/audio_stream_format_forward_track_refs.xml");
+  auto streamFormat = document->lookup(parseAudioStreamFormatId("AS_00031001"));
+
+  auto trackA = document->lookup(parseAudioTrackFormatId("AT_00031001_01"));
+  auto trackB = document->lookup(parseAudioTrackFormatId("AT_00031002_01"));
+
+  auto trackRefs = streamFormat->getAudioTrackFormatReferences();
+  REQUIRE(trackRefs.size() == 2);
+  REQUIRE(trackRefs[0].lock() == trackA);
+  REQUIRE(trackRefs[1].lock() == trackB);
+}
diff --git a/vcpkg.json b/vcpkg.json
new file mode 100644
index 00000000..9f9482f0
--- /dev/null
+++ b/vcpkg.json
@@ -0,0 +1,15 @@
+{
+  "name": "libadm",
+  "version": "0.14.0",
+  "homepage": "https://github.com/ebu/libadm",
+  "license": "Apache-2.0",
+  "dependencies": [
+    "boost-variant",
+    "boost-optional",
+    "boost-format",
+    "boost-functional",
+    "boost-range",
+    "boost-iterator",
+    "boost-rational"
+  ]
+}
\ No newline at end of file