From af82fb814ead9bb0e7337e4090809007565c45d2 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:49:14 +0000
Subject: [PATCH 01/39] Add FlatBuffers schema and dependency-free C#
 FlatBuffers writer/reader

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 .../FlatBufferFormatException.cs              |  33 ++
 source/CompDataFlatbuffer/FlatBufferTable.cs  | 325 +++++++++++
 source/CompDataFlatbuffer/FlatBufferWriter.cs | 474 ++++++++++++++++
 source/CompDataFlatbuffer/Schema.cs           | 385 +++++++++++++
 source/CompDataFlatbuffer/SchemaEnums.cs      | 139 +++++
 source/LottieFlatbuffer/lottie_comp.fbs       | 529 ++++++++++++++++++
 6 files changed, 1885 insertions(+)
 create mode 100644 source/CompDataFlatbuffer/FlatBufferFormatException.cs
 create mode 100644 source/CompDataFlatbuffer/FlatBufferTable.cs
 create mode 100644 source/CompDataFlatbuffer/FlatBufferWriter.cs
 create mode 100644 source/CompDataFlatbuffer/Schema.cs
 create mode 100644 source/CompDataFlatbuffer/SchemaEnums.cs
 create mode 100644 source/LottieFlatbuffer/lottie_comp.fbs

diff --git a/source/CompDataFlatbuffer/FlatBufferFormatException.cs b/source/CompDataFlatbuffer/FlatBufferFormatException.cs
new file mode 100644
index 00000000..62756e2c
--- /dev/null
+++ b/source/CompDataFlatbuffer/FlatBufferFormatException.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
+{
+    /// <summary>
+    /// Thrown when a buffer is not a valid serialized composition.
+    /// </summary>
+#if PUBLIC_CompDataFlatbuffer
+    public
+#endif
+    sealed class FlatBufferFormatException : Exception
+    {
+        public FlatBufferFormatException()
+        {
+        }
+
+        public FlatBufferFormatException(string message)
+            : base(message)
+        {
+        }
+
+        public FlatBufferFormatException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}
diff --git a/source/CompDataFlatbuffer/FlatBufferTable.cs b/source/CompDataFlatbuffer/FlatBufferTable.cs
new file mode 100644
index 00000000..8338ac78
--- /dev/null
+++ b/source/CompDataFlatbuffer/FlatBufferTable.cs
@@ -0,0 +1,325 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Text;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
+{
+    /// <summary>
+    /// A minimal reader for the FlatBuffers binary wire format. All accesses are
+    /// bounds checked; a malformed buffer causes a <see cref="FlatBufferFormatException"/>
+    /// rather than undefined behavior.
+    /// </summary>
+    readonly struct FlatBufferTable
+    {
+        readonly byte[] _buffer;
+        readonly int _position;
+
+        internal FlatBufferTable(byte[] buffer, int position)
+        {
+            _buffer = buffer;
+            _position = position;
+        }
+
+        internal bool IsNull => _buffer is null;
+
+        /// <summary>
+        /// Gets the root table of a buffer, checking its file identifier.
+        /// </summary>
+        /// <param name="buffer">The buffer.</param>
+        /// <param name="fileIdentifier">The expected 4 character file identifier.</param>
+        /// <returns>The root table.</returns>
+        internal static FlatBufferTable GetRoot(byte[] buffer, string fileIdentifier)
+        {
+            if (buffer is null)
+            {
+                throw new ArgumentNullException(nameof(buffer));
+            }
+
+            if (buffer.Length < 8)
+            {
+                throw new FlatBufferFormatException("Buffer is too small.");
+            }
+
+            for (var i = 0; i < 4; i++)
+            {
+                if (buffer[4 + i] != (byte)fileIdentifier[i])
+                {
+                    throw new FlatBufferFormatException("Unrecognized file identifier.");
+                }
+            }
+
+            var rootOffset = ReadInt32(buffer, 0);
+            return new FlatBufferTable(buffer, CheckedAdd(buffer, 0, rootOffset));
+        }
+
+        /// <summary>
+        /// Returns the absolute position of the data of the field with the given
+        /// id, or 0 if the field is not present.
+        /// </summary>
+        /// <param name="field">The id of the field.</param>
+        /// <returns>The position of the field's data, or 0.</returns>
+        internal int FieldPosition(int field)
+        {
+            var vtable = _position - ReadInt32(_buffer, _position);
+            if (vtable < 0 || vtable + 4 > _buffer.Length)
+            {
+                throw new FlatBufferFormatException("Invalid vtable offset.");
+            }
+
+            var vtableSize = ReadUInt16(_buffer, vtable);
+            var fieldIndex = 4 + (field * 2);
+            if (fieldIndex + 2 > vtableSize)
+            {
+                return 0;
+            }
+
+            var fieldOffset = ReadUInt16(_buffer, vtable + fieldIndex);
+            if (fieldOffset == 0)
+            {
+                return 0;
+            }
+
+            var result = _position + fieldOffset;
+            if (result < 0 || result >= _buffer.Length)
+            {
+                throw new FlatBufferFormatException("Field is outside the buffer.");
+            }
+
+            return result;
+        }
+
+        internal byte GetUInt8(int field, byte defaultValue)
+        {
+            var position = FieldPosition(field);
+            return position == 0 ? defaultValue : _buffer[position];
+        }
+
+        internal byte? GetOptionalUInt8(int field)
+        {
+            var position = FieldPosition(field);
+            return position == 0 ? (byte?)null : _buffer[position];
+        }
+
+        internal bool GetBool(int field, bool defaultValue)
+            => GetUInt8(field, (byte)(defaultValue ? 1 : 0)) != 0;
+
+        internal bool? GetOptionalBool(int field)
+        {
+            var value = GetOptionalUInt8(field);
+            return value.HasValue ? value.Value != 0 : (bool?)null;
+        }
+
+        internal ushort GetUInt16(int field, ushort defaultValue)
+        {
+            var position = FieldPosition(field);
+            return position == 0 ? defaultValue : ReadUInt16(_buffer, position);
+        }
+
+        internal int GetInt32(int field, int defaultValue)
+        {
+            var position = FieldPosition(field);
+            return position == 0 ? defaultValue : ReadInt32(_buffer, position);
+        }
+
+        internal int? GetOptionalInt32(int field)
+        {
+            var position = FieldPosition(field);
+            return position == 0 ? (int?)null : ReadInt32(_buffer, position);
+        }
+
+        internal uint GetUInt32(int field, uint defaultValue)
+        {
+            var position = FieldPosition(field);
+            return position == 0 ? defaultValue : unchecked((uint)ReadInt32(_buffer, position));
+        }
+
+        internal long GetInt64(int field, long defaultValue)
+        {
+            var position = FieldPosition(field);
+            if (position == 0)
+            {
+                return defaultValue;
+            }
+
+            var low = unchecked((uint)ReadInt32(_buffer, position));
+            var high = ReadInt32(_buffer, position + 4);
+            return unchecked((long)(((ulong)(uint)high << 32) | low));
+        }
+
+        internal float GetFloat(int field, float defaultValue)
+        {
+            var position = FieldPosition(field);
+            return position == 0 ? defaultValue : BitConverter.Int32BitsToSingle(ReadInt32(_buffer, position));
+        }
+
+        internal float? GetOptionalFloat(int field)
+        {
+            var position = FieldPosition(field);
+            return position == 0 ? (float?)null : BitConverter.Int32BitsToSingle(ReadInt32(_buffer, position));
+        }
+
+        /// <summary>
+        /// Returns the position of an inline struct field, or 0 if not present.
+        /// Use the ReadStructFloat and ReadStructUInt8 methods to read its fields.
+        /// </summary>
+        /// <param name="field">The id of the field.</param>
+        /// <returns>The position of the struct, or 0.</returns>
+        internal int GetStructPosition(int field) => FieldPosition(field);
+
+        internal float ReadStructFloat(int structPosition, int offset)
+            => BitConverter.Int32BitsToSingle(ReadInt32(_buffer, structPosition + offset));
+
+        internal byte ReadStructUInt8(int structPosition, int offset)
+        {
+            if (structPosition + offset >= _buffer.Length)
+            {
+                throw new FlatBufferFormatException("Struct is outside the buffer.");
+            }
+
+            return _buffer[structPosition + offset];
+        }
+
+        internal FlatBufferTable GetTable(int field)
+        {
+            var position = FieldPosition(field);
+            return position == 0
+                ? default
+                : new FlatBufferTable(_buffer, CheckedAdd(_buffer, position, ReadInt32(_buffer, position)));
+        }
+
+        internal string? GetString(int field)
+        {
+            var position = FieldPosition(field);
+            if (position == 0)
+            {
+                return null;
+            }
+
+            var stringPosition = CheckedAdd(_buffer, position, ReadInt32(_buffer, position));
+            var length = ReadInt32(_buffer, stringPosition);
+            if (length < 0 || stringPosition + 4 + length > _buffer.Length)
+            {
+                throw new FlatBufferFormatException("String is outside the buffer.");
+            }
+
+            return Encoding.UTF8.GetString(_buffer, stringPosition + 4, length);
+        }
+
+        /// <summary>
+        /// Returns the number of elements in a vector field.
+        /// </summary>
+        /// <param name="field">The id of the field.</param>
+        /// <returns>The number of elements, or 0 if the field is not present.</returns>
+        internal int VectorLength(int field)
+        {
+            var position = FieldPosition(field);
+            if (position == 0)
+            {
+                return 0;
+            }
+
+            var vector = CheckedAdd(_buffer, position, ReadInt32(_buffer, position));
+            var length = ReadInt32(_buffer, vector);
+            if (length < 0)
+            {
+                throw new FlatBufferFormatException("Invalid vector length.");
+            }
+
+            return length;
+        }
+
+        internal byte GetVectorUInt8(int field, int index)
+        {
+            var position = VectorElementPosition(field, index, sizeof(byte));
+            return _buffer[position];
+        }
+
+        internal float GetVectorFloat(int field, int index)
+            => BitConverter.Int32BitsToSingle(ReadInt32(_buffer, VectorElementPosition(field, index, sizeof(float))));
+
+        internal uint GetVectorUInt32(int field, int index)
+            => unchecked((uint)ReadInt32(_buffer, VectorElementPosition(field, index, sizeof(uint))));
+
+        internal FlatBufferTable GetVectorTable(int field, int index)
+        {
+            var position = VectorElementPosition(field, index, sizeof(int));
+            return new FlatBufferTable(_buffer, CheckedAdd(_buffer, position, ReadInt32(_buffer, position)));
+        }
+
+        internal string GetVectorString(int field, int index)
+        {
+            var position = VectorElementPosition(field, index, sizeof(int));
+            var stringPosition = CheckedAdd(_buffer, position, ReadInt32(_buffer, position));
+            var length = ReadInt32(_buffer, stringPosition);
+            if (length < 0 || stringPosition + 4 + length > _buffer.Length)
+            {
+                throw new FlatBufferFormatException("String is outside the buffer.");
+            }
+
+            return Encoding.UTF8.GetString(_buffer, stringPosition + 4, length);
+        }
+
+        static int ReadInt32(byte[] buffer, int position)
+        {
+            if (position < 0 || position + 4 > buffer.Length)
+            {
+                throw new FlatBufferFormatException("Read is outside the buffer.");
+            }
+
+            return buffer[position] |
+                   (buffer[position + 1] << 8) |
+                   (buffer[position + 2] << 16) |
+                   (buffer[position + 3] << 24);
+        }
+
+        static ushort ReadUInt16(byte[] buffer, int position)
+        {
+            if (position < 0 || position + 2 > buffer.Length)
+            {
+                throw new FlatBufferFormatException("Read is outside the buffer.");
+            }
+
+            return unchecked((ushort)(buffer[position] | (buffer[position + 1] << 8)));
+        }
+
+        static int CheckedAdd(byte[] buffer, int position, int offset)
+        {
+            var result = (long)position + offset;
+            if (result < 0 || result >= buffer.Length)
+            {
+                throw new FlatBufferFormatException("Offset is outside the buffer.");
+            }
+
+            return (int)result;
+        }
+
+        int VectorElementPosition(int field, int index, int elementSize)
+        {
+            var position = FieldPosition(field);
+            if (position == 0)
+            {
+                throw new FlatBufferFormatException("Vector is not present.");
+            }
+
+            var vector = CheckedAdd(_buffer, position, ReadInt32(_buffer, position));
+            var length = ReadInt32(_buffer, vector);
+            if (index < 0 || index >= length)
+            {
+                throw new FlatBufferFormatException("Vector index is out of range.");
+            }
+
+            var result = vector + 4 + (index * elementSize);
+            if (result < 0 || result + elementSize > _buffer.Length)
+            {
+                throw new FlatBufferFormatException("Vector element is outside the buffer.");
+            }
+
+            return result;
+        }
+    }
+}
diff --git a/source/CompDataFlatbuffer/FlatBufferWriter.cs b/source/CompDataFlatbuffer/FlatBufferWriter.cs
new file mode 100644
index 00000000..e4fbbc4e
--- /dev/null
+++ b/source/CompDataFlatbuffer/FlatBufferWriter.cs
@@ -0,0 +1,474 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
+{
+    /// <summary>
+    /// A minimal writer for the FlatBuffers binary wire format. Buffers produced
+    /// by this writer are readable by any FlatBuffers implementation, including
+    /// the C++ code generated from lottie_comp.fbs.
+    /// </summary>
+    /// <remarks>
+    /// The wire format is described at https://flatbuffers.dev/flatbuffers_internals.html.
+    /// Data is written from the end of the buffer towards its start, so all
+    /// offsets returned by this class are measured backwards from the end of the
+    /// buffer.
+    /// </remarks>
+    sealed class FlatBufferWriter
+    {
+        // The offsets of the vtables that have been written so far. Used to
+        // share identical vtables between tables.
+        readonly List<int> _vtables = new List<int>();
+
+        // The field offsets of the table that is currently being built.
+        readonly List<int> _currentVTable = new List<int>();
+
+        byte[] _buffer;
+
+        // The number of bytes at the end of _buffer that contain data.
+        int _used;
+
+        // The offset of the start of the table that is currently being built,
+        // or -1 if no table is being built.
+        int _tableStart = -1;
+
+        int _minAlign = 1;
+
+        internal FlatBufferWriter(int initialSize = 4096)
+        {
+            _buffer = new byte[Math.Max(initialSize, 32)];
+        }
+
+        /// <summary>
+        /// Starts a table with the given number of fields. Fields are added with
+        /// the Add methods, then the table is completed by calling <see cref="EndTable"/>.
+        /// </summary>
+        /// <param name="fieldCount">The number of fields declared by the table in the schema.</param>
+        internal void StartTable(int fieldCount)
+        {
+            if (_tableStart >= 0)
+            {
+                throw new InvalidOperationException("Nested table construction is not supported.");
+            }
+
+            _currentVTable.Clear();
+            for (var i = 0; i < fieldCount; i++)
+            {
+                _currentVTable.Add(0);
+            }
+
+            _tableStart = _used;
+        }
+
+        /// <summary>
+        /// Completes the table that is being built and returns its offset.
+        /// </summary>
+        /// <returns>The offset of the table.</returns>
+        internal int EndTable()
+        {
+            if (_tableStart < 0)
+            {
+                throw new InvalidOperationException("No table is being built.");
+            }
+
+            // Reserve space for the offset to the vtable.
+            Prep(sizeof(int), 0);
+            EnsureSpace(sizeof(int));
+            _used += sizeof(int);
+            var tableEnd = _used;
+
+            // Trailing empty fields are implied by the length of the vtable.
+            var fieldCount = _currentVTable.Count;
+            while (fieldCount > 0 && _currentVTable[fieldCount - 1] == 0)
+            {
+                fieldCount--;
+            }
+
+            // Write the vtable: the size of the vtable, the size of the table,
+            // then the offset of each field within the table.
+            var vtableSize = (fieldCount + 2) * sizeof(short);
+            Prep(sizeof(short), vtableSize);
+            for (var i = fieldCount - 1; i >= 0; i--)
+            {
+                var fieldOffset = _currentVTable[i];
+                WriteInt16(checked((short)(fieldOffset == 0 ? 0 : tableEnd - fieldOffset)));
+            }
+
+            WriteInt16(checked((short)(tableEnd - _tableStart)));
+            WriteInt16(checked((short)vtableSize));
+
+            var vtableOffset = _used;
+
+            // Share an identical vtable if one has already been written.
+            var sharedVTableOffset = FindMatchingVTable(vtableOffset, vtableSize);
+            if (sharedVTableOffset >= 0)
+            {
+                _used = vtableOffset - vtableSize;
+                vtableOffset = sharedVTableOffset;
+            }
+            else
+            {
+                _vtables.Add(vtableOffset);
+            }
+
+            // Patch the signed offset from the table to its vtable.
+            WriteInt32At(tableEnd, vtableOffset - tableEnd);
+
+            _tableStart = -1;
+            return tableEnd;
+        }
+
+        internal void AddUInt8(int field, byte value, byte defaultValue)
+        {
+            if (value != defaultValue)
+            {
+                Prep(sizeof(byte), 0);
+                WriteByte(value);
+                Slot(field);
+            }
+        }
+
+        internal void AddUInt8(int field, byte? value)
+        {
+            if (value.HasValue)
+            {
+                Prep(sizeof(byte), 0);
+                WriteByte(value.Value);
+                Slot(field);
+            }
+        }
+
+        internal void AddBool(int field, bool value, bool defaultValue)
+            => AddUInt8(field, (byte)(value ? 1 : 0), (byte)(defaultValue ? 1 : 0));
+
+        internal void AddBool(int field, bool? value)
+            => AddUInt8(field, value.HasValue ? (byte)(value.Value ? 1 : 0) : (byte?)null);
+
+        internal void AddUInt16(int field, ushort value, ushort defaultValue)
+        {
+            if (value != defaultValue)
+            {
+                Prep(sizeof(short), 0);
+                WriteInt16(unchecked((short)value));
+                Slot(field);
+            }
+        }
+
+        internal void AddInt32(int field, int value, int defaultValue)
+        {
+            if (value != defaultValue)
+            {
+                Prep(sizeof(int), 0);
+                WriteInt32(value);
+                Slot(field);
+            }
+        }
+
+        internal void AddInt32(int field, int? value)
+        {
+            if (value.HasValue)
+            {
+                Prep(sizeof(int), 0);
+                WriteInt32(value.Value);
+                Slot(field);
+            }
+        }
+
+        internal void AddUInt32(int field, uint value, uint defaultValue)
+            => AddInt32(field, unchecked((int)value), unchecked((int)defaultValue));
+
+        internal void AddInt64(int field, long value, long defaultValue)
+        {
+            if (value != defaultValue)
+            {
+                Prep(sizeof(long), 0);
+                WriteInt64(value);
+                Slot(field);
+            }
+        }
+
+        internal void AddFloat(int field, float value, float defaultValue)
+        {
+            if (!value.Equals(defaultValue))
+            {
+                Prep(sizeof(float), 0);
+                WriteInt32(BitConverter.SingleToInt32Bits(value));
+                Slot(field);
+            }
+        }
+
+        internal void AddFloat(int field, float? value)
+        {
+            if (value.HasValue)
+            {
+                Prep(sizeof(float), 0);
+                WriteInt32(BitConverter.SingleToInt32Bits(value.Value));
+                Slot(field);
+            }
+        }
+
+        /// <summary>
+        /// Adds a reference to a previously created table, vector or string.
+        /// An <paramref name="offset"/> of 0 means "not present".
+        /// </summary>
+        /// <param name="field">The id of the field.</param>
+        /// <param name="offset">The offset of the referenced data.</param>
+        internal void AddOffset(int field, int offset)
+        {
+            if (offset != 0)
+            {
+                Prep(sizeof(int), 0);
+                WriteInt32(_used + sizeof(int) - offset);
+                Slot(field);
+            }
+        }
+
+        /// <summary>
+        /// Prepares to write an inline struct of the given size and alignment.
+        /// The struct's fields must then be written in reverse declaration order
+        /// using the Write methods, followed by <see cref="AddStruct"/>.
+        /// </summary>
+        /// <param name="alignment">The alignment of the struct.</param>
+        /// <param name="size">The size of the struct.</param>
+        internal void StartStruct(int alignment, int size) => Prep(alignment, size);
+
+        /// <summary>
+        /// Adds an inline struct field whose data was just written by
+        /// <see cref="StartStruct"/> and the Write methods.
+        /// </summary>
+        /// <param name="field">The id of the field.</param>
+        internal void AddStruct(int field) => Slot(field);
+
+        internal void WriteFloat(float value) => WriteInt32(BitConverter.SingleToInt32Bits(value));
+
+        internal void WriteUInt8(byte value) => WriteByte(value);
+
+        internal int CreateString(string value)
+        {
+            var bytes = Encoding.UTF8.GetBytes(value);
+
+            // Strings are null terminated for the convenience of C++ readers.
+            Prep(sizeof(int), bytes.Length + 1);
+            WriteByte(0);
+            EnsureSpace(bytes.Length);
+            _used += bytes.Length;
+            Array.Copy(bytes, 0, _buffer, _buffer.Length - _used, bytes.Length);
+            WriteInt32(bytes.Length);
+            return _used;
+        }
+
+        internal int CreateByteVector(IReadOnlyList<byte> values)
+        {
+            StartVector(sizeof(byte), values.Count, sizeof(byte));
+            for (var i = values.Count - 1; i >= 0; i--)
+            {
+                WriteByte(values[i]);
+            }
+
+            return EndVector(values.Count);
+        }
+
+        internal int CreateFloatVector(IReadOnlyList<float> values)
+        {
+            StartVector(sizeof(float), values.Count, sizeof(float));
+            for (var i = values.Count - 1; i >= 0; i--)
+            {
+                WriteInt32(BitConverter.SingleToInt32Bits(values[i]));
+            }
+
+            return EndVector(values.Count);
+        }
+
+        internal int CreateUInt32Vector(IReadOnlyList<uint> values)
+        {
+            StartVector(sizeof(uint), values.Count, sizeof(uint));
+            for (var i = values.Count - 1; i >= 0; i--)
+            {
+                WriteInt32(unchecked((int)values[i]));
+            }
+
+            return EndVector(values.Count);
+        }
+
+        /// <summary>
+        /// Creates a vector of offsets to previously created tables or strings.
+        /// </summary>
+        /// <param name="offsets">The offsets of the referenced data.</param>
+        /// <returns>The offset of the vector.</returns>
+        internal int CreateOffsetVector(IReadOnlyList<int> offsets)
+        {
+            StartVector(sizeof(int), offsets.Count, sizeof(int));
+            for (var i = offsets.Count - 1; i >= 0; i--)
+            {
+                Prep(sizeof(int), 0);
+                WriteInt32(_used + sizeof(int) - offsets[i]);
+            }
+
+            return EndVector(offsets.Count);
+        }
+
+        /// <summary>
+        /// Completes the buffer, making <paramref name="rootTable"/> its root.
+        /// </summary>
+        /// <param name="rootTable">The offset of the root table.</param>
+        /// <param name="fileIdentifier">The 4 character file identifier.</param>
+        /// <returns>The completed buffer.</returns>
+        internal byte[] Finish(int rootTable, string fileIdentifier)
+        {
+            if (fileIdentifier is null || fileIdentifier.Length != 4)
+            {
+                throw new ArgumentException("File identifier must be 4 characters.", nameof(fileIdentifier));
+            }
+
+            Prep(_minAlign, sizeof(int) + 4);
+            for (var i = 3; i >= 0; i--)
+            {
+                WriteByte((byte)fileIdentifier[i]);
+            }
+
+            WriteInt32(_used + sizeof(int) - rootTable);
+
+            var result = new byte[_used];
+            Array.Copy(_buffer, _buffer.Length - _used, result, 0, _used);
+            return result;
+        }
+
+        void StartVector(int elementSize, int count, int alignment)
+        {
+            Prep(sizeof(int), elementSize * count);
+            Prep(alignment, elementSize * count);
+        }
+
+        int EndVector(int count)
+        {
+            WriteInt32(count);
+            return _used;
+        }
+
+        // Records the offset of the field that was just written.
+        void Slot(int field)
+        {
+            if (field >= _currentVTable.Count)
+            {
+                throw new ArgumentOutOfRangeException(nameof(field));
+            }
+
+            _currentVTable[field] = _used;
+        }
+
+        // Pads so that, after writing additionalBytes more bytes, the write
+        // position will be aligned to the given alignment.
+        void Prep(int alignment, int additionalBytes)
+        {
+            if (alignment > _minAlign)
+            {
+                _minAlign = alignment;
+            }
+
+            var alignSize = ((~(_used + additionalBytes)) + 1) & (alignment - 1);
+            EnsureSpace(alignSize + additionalBytes);
+            for (var i = 0; i < alignSize; i++)
+            {
+                WriteByte(0);
+            }
+        }
+
+        int FindMatchingVTable(int vtableOffset, int vtableSize)
+        {
+            foreach (var candidate in _vtables)
+            {
+                if (ReadInt16At(candidate) != vtableSize)
+                {
+                    continue;
+                }
+
+                var match = true;
+                for (var i = sizeof(short); i < vtableSize; i += sizeof(short))
+                {
+                    if (ReadInt16At(candidate - i) != ReadInt16At(vtableOffset - i))
+                    {
+                        match = false;
+                        break;
+                    }
+                }
+
+                if (match)
+                {
+                    return candidate;
+                }
+            }
+
+            return -1;
+        }
+
+        void EnsureSpace(int size)
+        {
+            if (_used + size <= _buffer.Length)
+            {
+                return;
+            }
+
+            var newSize = _buffer.Length;
+            while (newSize < _used + size)
+            {
+                newSize *= 2;
+            }
+
+            var newBuffer = new byte[newSize];
+            Array.Copy(_buffer, _buffer.Length - _used, newBuffer, newSize - _used, _used);
+            _buffer = newBuffer;
+        }
+
+        void WriteByte(byte value)
+        {
+            EnsureSpace(sizeof(byte));
+            _used += sizeof(byte);
+            _buffer[_buffer.Length - _used] = value;
+        }
+
+        void WriteInt16(short value)
+        {
+            EnsureSpace(sizeof(short));
+            _used += sizeof(short);
+            var index = _buffer.Length - _used;
+            _buffer[index] = unchecked((byte)value);
+            _buffer[index + 1] = unchecked((byte)(value >> 8));
+        }
+
+        void WriteInt32(int value)
+        {
+            EnsureSpace(sizeof(int));
+            _used += sizeof(int);
+            WriteInt32At(_used, value);
+        }
+
+        void WriteInt64(long value)
+        {
+            // The buffer is written backwards, so the high word is written first.
+            WriteInt32(unchecked((int)(value >> 32)));
+            WriteInt32(unchecked((int)value));
+        }
+
+        void WriteInt32At(int offset, int value)
+        {
+            var index = _buffer.Length - offset;
+            _buffer[index] = unchecked((byte)value);
+            _buffer[index + 1] = unchecked((byte)(value >> 8));
+            _buffer[index + 2] = unchecked((byte)(value >> 16));
+            _buffer[index + 3] = unchecked((byte)(value >> 24));
+        }
+
+        short ReadInt16At(int offset)
+        {
+            var index = _buffer.Length - offset;
+            return unchecked((short)(_buffer[index] | (_buffer[index + 1] << 8)));
+        }
+    }
+}
diff --git a/source/CompDataFlatbuffer/Schema.cs b/source/CompDataFlatbuffer/Schema.cs
new file mode 100644
index 00000000..84b3451a
--- /dev/null
+++ b/source/CompDataFlatbuffer/Schema.cs
@@ -0,0 +1,385 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
+{
+    /// <summary>
+    /// Field ids, enum values and constants of the lottie_comp.fbs schema.
+    /// These must be kept in sync with lottie_comp.fbs; field ids are the
+    /// 0-based declaration order of the fields of each table.
+    /// </summary>
+    static class Schema
+    {
+        /// <summary>
+        /// The version of the schema that this code reads and writes. Bumped for
+        /// every additive change to lottie_comp.fbs.
+        /// </summary>
+        internal const ushort Version = 1;
+
+        /// <summary>
+        /// The 4 character identifier stored at offset 4 of every buffer.
+        /// </summary>
+        internal const string FileIdentifier = "LCMP";
+
+        /// <summary>
+        /// The file extension used for serialized compositions.
+        /// </summary>
+        internal const string FileExtension = ".lcomp";
+
+        /// <summary>
+        /// The value of an index or reference field that refers to nothing.
+        /// </summary>
+        internal const uint NullIndex = 0xFFFFFFFF;
+
+        /// <summary>
+        /// The number of bits used to store the index part of an object reference.
+        /// </summary>
+        internal const int ObjectReferenceIndexBits = 28;
+
+        internal static uint PackObjectReference(ObjectCategory category, int index)
+            => ((uint)category << ObjectReferenceIndexBits) | (uint)index;
+
+        internal static ObjectCategory UnpackCategory(uint reference)
+            => (ObjectCategory)(reference >> ObjectReferenceIndexBits);
+
+        internal static int UnpackIndex(uint reference)
+            => (int)(reference & ((1u << ObjectReferenceIndexBits) - 1));
+
+        internal static class Animator
+        {
+            internal const int FieldCount = 3;
+            internal const int Property = 0;
+            internal const int Animation = 1;
+            internal const int Controller = 2;
+        }
+
+        internal static class CompObj
+        {
+            internal const int FieldCount = 3;
+            internal const int Comment = 0;
+            internal const int Animators = 1;
+            internal const int Properties = 2;
+        }
+
+        internal static class PropertyValue
+        {
+            internal const int FieldCount = 5;
+            internal const int Name = 0;
+            internal const int Type = 1;
+            internal const int Scalar = 2;
+            internal const int Vector = 3;
+            internal const int Color = 4;
+        }
+
+        internal static class ReferenceParameter
+        {
+            internal const int FieldCount = 2;
+            internal const int Name = 0;
+            internal const int Target = 1;
+        }
+
+        internal static class SourceParameter
+        {
+            internal const int FieldCount = 2;
+            internal const int Name = 0;
+            internal const int Brush = 1;
+        }
+
+        internal static class KeyFrame
+        {
+            internal const int FieldCount = 8;
+            internal const int Progress = 0;
+            internal const int Easing = 1;
+            internal const int Kind = 2;
+            internal const int Expression = 3;
+            internal const int Scalar = 4;
+            internal const int Vector = 5;
+            internal const int Color = 6;
+            internal const int Path = 7;
+        }
+
+        internal static class Visual
+        {
+            internal const int FieldCount = 18;
+            internal const int Base = 0;
+            internal const int Kind = 1;
+            internal const int BorderMode = 2;
+            internal const int CenterPoint = 3;
+            internal const int Clip = 4;
+            internal const int IsVisible = 5;
+            internal const int Offset = 6;
+            internal const int Opacity = 7;
+            internal const int RotationAngleInDegrees = 8;
+            internal const int RotationAxis = 9;
+            internal const int Scale = 10;
+            internal const int Size = 11;
+            internal const int TransformMatrix = 12;
+            internal const int Children = 13;
+            internal const int Shapes = 14;
+            internal const int ViewBox = 15;
+            internal const int Brush = 16;
+            internal const int Shadow = 17;
+        }
+
+        internal static class Shape
+        {
+            internal const int FieldCount = 20;
+            internal const int Base = 0;
+            internal const int Kind = 1;
+            internal const int CenterPoint = 2;
+            internal const int Offset = 3;
+            internal const int RotationAngleInDegrees = 4;
+            internal const int Scale = 5;
+            internal const int TransformMatrix = 6;
+            internal const int Shapes = 7;
+            internal const int FillBrush = 8;
+            internal const int StrokeBrush = 9;
+            internal const int Geometry = 10;
+            internal const int IsStrokeNonScaling = 11;
+            internal const int StrokeDashOffset = 12;
+            internal const int StrokeDashArray = 13;
+            internal const int StrokeDashCap = 14;
+            internal const int StrokeStartCap = 15;
+            internal const int StrokeEndCap = 16;
+            internal const int StrokeLineJoin = 17;
+            internal const int StrokeMiterLimit = 18;
+            internal const int StrokeThickness = 19;
+        }
+
+        internal static class Geometry
+        {
+            internal const int FieldCount = 11;
+            internal const int Base = 0;
+            internal const int Kind = 1;
+            internal const int TrimStart = 2;
+            internal const int TrimEnd = 3;
+            internal const int TrimOffset = 4;
+            internal const int Path = 5;
+            internal const int Offset = 6;
+            internal const int Size = 7;
+            internal const int CornerRadius = 8;
+            internal const int Center = 9;
+            internal const int Radius = 10;
+        }
+
+        internal static class Brush
+        {
+            internal const int FieldCount = 23;
+            internal const int Base = 0;
+            internal const int Kind = 1;
+            internal const int Color = 2;
+            internal const int AnchorPoint = 3;
+            internal const int CenterPoint = 4;
+            internal const int ColorStops = 5;
+            internal const int ExtendMode = 6;
+            internal const int InterpolationSpace = 7;
+            internal const int MappingMode = 8;
+            internal const int Offset = 9;
+            internal const int RotationAngleInDegrees = 10;
+            internal const int Scale = 11;
+            internal const int TransformMatrix = 12;
+            internal const int StartPoint = 13;
+            internal const int EndPoint = 14;
+            internal const int EllipseCenter = 15;
+            internal const int EllipseRadius = 16;
+            internal const int GradientOriginOffset = 17;
+            internal const int Surface = 18;
+            internal const int Source = 19;
+            internal const int Mask = 20;
+            internal const int Effect = 21;
+            internal const int SourceParameters = 22;
+        }
+
+        internal static class GradientStop
+        {
+            internal const int FieldCount = 3;
+            internal const int Base = 0;
+            internal const int Color = 1;
+            internal const int Offset = 2;
+        }
+
+        internal static class ViewBox
+        {
+            internal const int FieldCount = 2;
+            internal const int Base = 0;
+            internal const int Size = 1;
+        }
+
+        internal static class Clip
+        {
+            internal const int FieldCount = 9;
+            internal const int Base = 0;
+            internal const int Kind = 1;
+            internal const int CenterPoint = 2;
+            internal const int Scale = 3;
+            internal const int LeftInset = 4;
+            internal const int RightInset = 5;
+            internal const int TopInset = 6;
+            internal const int BottomInset = 7;
+            internal const int Geometry = 8;
+        }
+
+        internal static class Shadow
+        {
+            internal const int FieldCount = 8;
+            internal const int Base = 0;
+            internal const int Kind = 1;
+            internal const int BlurRadius = 2;
+            internal const int Color = 3;
+            internal const int Mask = 4;
+            internal const int Offset = 5;
+            internal const int Opacity = 6;
+            internal const int SourcePolicy = 7;
+        }
+
+        internal static class Surface
+        {
+            internal const int FieldCount = 7;
+            internal const int Base = 0;
+            internal const int Kind = 1;
+            internal const int SourceVisual = 2;
+            internal const int SourceSize = 3;
+            internal const int SourceOffset = 4;
+            internal const int Uri = 5;
+            internal const int Bytes = 6;
+        }
+
+        internal static class Effect
+        {
+            internal const int FieldCount = 5;
+            internal const int Base = 0;
+            internal const int Kind = 1;
+            internal const int Sources = 2;
+            internal const int Mode = 3;
+            internal const int BlurAmount = 4;
+        }
+
+        internal static class Easing
+        {
+            internal const int FieldCount = 9;
+            internal const int Base = 0;
+            internal const int Kind = 1;
+            internal const int ControlPoint1 = 2;
+            internal const int ControlPoint2 = 3;
+            internal const int StepCount = 4;
+            internal const int InitialStep = 5;
+            internal const int FinalStep = 6;
+            internal const int IsInitialStepSingleFrame = 7;
+            internal const int IsFinalStepSingleFrame = 8;
+        }
+
+        internal static class Animation
+        {
+            internal const int FieldCount = 8;
+            internal const int Base = 0;
+            internal const int Kind = 1;
+            internal const int Target = 2;
+            internal const int ReferenceParameters = 3;
+            internal const int Expression = 4;
+            internal const int DurationTicks = 5;
+            internal const int KeyFrames = 6;
+            internal const int InterpolationColorSpace = 7;
+        }
+
+        internal static class PropertySet
+        {
+            internal const int FieldCount = 3;
+            internal const int Base = 0;
+            internal const int Owner = 1;
+            internal const int Values = 2;
+        }
+
+        internal static class Controller
+        {
+            internal const int FieldCount = 5;
+            internal const int Base = 0;
+            internal const int TargetObject = 1;
+            internal const int TargetProperty = 2;
+            internal const int IsPaused = 3;
+            internal const int IsCustom = 4;
+        }
+
+        internal static class PropertyBinding
+        {
+            internal const int FieldCount = 7;
+            internal const int Name = 0;
+            internal const int DisplayName = 1;
+            internal const int ActualType = 2;
+            internal const int ExposedType = 3;
+            internal const int DefaultScalar = 4;
+            internal const int DefaultVector = 5;
+            internal const int DefaultColor = 6;
+        }
+
+        internal static class Marker
+        {
+            internal const int FieldCount = 3;
+            internal const int Name = 0;
+            internal const int Progress = 1;
+            internal const int DurationProgress = 2;
+        }
+
+        internal static class Metadata
+        {
+            internal const int FieldCount = 8;
+            internal const int Name = 0;
+            internal const int Width = 1;
+            internal const int Height = 2;
+            internal const int DurationTicks = 3;
+            internal const int FramesPerSecond = 4;
+            internal const int PropertyBindings = 5;
+            internal const int Markers = 6;
+            internal const int ThemingPropertySet = 7;
+        }
+
+        internal static class Composition
+        {
+            internal const int FieldCount = 21;
+            internal const int SchemaVersion = 0;
+            internal const int RequiredUapVersion = 1;
+            internal const int Metadata = 2;
+            internal const int RootVisual = 3;
+            internal const int Strings = 4;
+            internal const int Visuals = 5;
+            internal const int Shapes = 6;
+            internal const int Geometries = 7;
+            internal const int CanvasGeometries = 8;
+            internal const int Brushes = 9;
+            internal const int GradientStops = 10;
+            internal const int ViewBoxes = 11;
+            internal const int Clips = 12;
+            internal const int Shadows = 13;
+            internal const int Surfaces = 14;
+            internal const int Effects = 15;
+            internal const int Easings = 16;
+            internal const int Animations = 17;
+            internal const int PropertySets = 18;
+            internal const int Controllers = 19;
+            internal const int CustomControllers = 20;
+        }
+
+        internal static class CanvasGeometry
+        {
+            internal const int FieldCount = 16;
+            internal const int Kind = 0;
+            internal const int A = 1;
+            internal const int B = 2;
+            internal const int CombineMode = 3;
+            internal const int Matrix = 4;
+            internal const int Source = 5;
+            internal const int Geometries = 6;
+            internal const int FillRule = 7;
+            internal const int Ops = 8;
+            internal const int Operands = 9;
+            internal const int X = 10;
+            internal const int Y = 11;
+            internal const int W = 12;
+            internal const int H = 13;
+            internal const int RadiusX = 14;
+            internal const int RadiusY = 15;
+        }
+    }
+}
diff --git a/source/CompDataFlatbuffer/SchemaEnums.cs b/source/CompDataFlatbuffer/SchemaEnums.cs
new file mode 100644
index 00000000..ddafef6d
--- /dev/null
+++ b/source/CompDataFlatbuffer/SchemaEnums.cs
@@ -0,0 +1,139 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
+{
+    /// <summary>
+    /// Identifies the node vector that a packed object reference points into.
+    /// Must be kept in sync with the ObjectCategory enum in lottie_comp.fbs.
+    /// </summary>
+    enum ObjectCategory : byte
+    {
+        Visual = 0,
+        Shape = 1,
+        Geometry = 2,
+        Brush = 3,
+        Animation = 4,
+        Easing = 5,
+        PropertySet = 6,
+        Surface = 7,
+        Clip = 8,
+        Controller = 9,
+        Shadow = 10,
+        Effect = 11,
+        GradientStop = 12,
+        ViewBox = 13,
+    }
+
+    enum VisualKind : byte
+    {
+        Container = 0,
+        Sprite = 1,
+        Shape = 2,
+        Layer = 3,
+    }
+
+    enum ShapeKind : byte
+    {
+        Container = 0,
+        Sprite = 1,
+    }
+
+    enum GeometryKind : byte
+    {
+        Path = 0,
+        Rectangle = 1,
+        RoundedRectangle = 2,
+        Ellipse = 3,
+    }
+
+    enum BrushKind : byte
+    {
+        Color = 0,
+        LinearGradient = 1,
+        RadialGradient = 2,
+        Surface = 3,
+        Mask = 4,
+        Effect = 5,
+    }
+
+    enum ClipKind : byte
+    {
+        Inset = 0,
+        Geometric = 1,
+    }
+
+    enum ShadowKind : byte
+    {
+        Drop = 0,
+    }
+
+    enum SurfaceKind : byte
+    {
+        VisualSurface = 0,
+        LoadedImageFromUri = 1,
+        LoadedImageFromStream = 2,
+    }
+
+    enum EffectKind : byte
+    {
+        Composite = 0,
+        GaussianBlur = 1,
+    }
+
+    enum EasingKind : byte
+    {
+        Linear = 0,
+        CubicBezier = 1,
+        Step = 2,
+    }
+
+    enum AnimationKind : byte
+    {
+        Scalar = 0,
+        Vector2 = 1,
+        Vector3 = 2,
+        Vector4 = 3,
+        Color = 4,
+        Boolean = 5,
+        Path = 6,
+        Expression = 7,
+    }
+
+    enum KeyFrameKind : byte
+    {
+        Value = 0,
+        Expression = 1,
+    }
+
+    enum CanvasGeometryKind : byte
+    {
+        Combination = 0,
+        Ellipse = 1,
+        Group = 2,
+        Path = 3,
+        RoundedRectangle = 4,
+        TransformedGeometry = 5,
+    }
+
+    /// <summary>
+    /// The opcodes of the flattened CanvasPathBuilder command stream.
+    /// </summary>
+    enum PathOp : byte
+    {
+        /// <summary>Consumes 2 operands: x, y.</summary>
+        BeginFigure = 0,
+
+        /// <summary>Consumes 1 operand: the CanvasFigureLoop.</summary>
+        EndFigure = 1,
+
+        /// <summary>Consumes 2 operands: x, y.</summary>
+        AddLine = 2,
+
+        /// <summary>Consumes 6 operands: cp1.x, cp1.y, cp2.x, cp2.y, end.x, end.y.</summary>
+        AddCubicBezier = 3,
+    }
+}
diff --git a/source/LottieFlatbuffer/lottie_comp.fbs b/source/LottieFlatbuffer/lottie_comp.fbs
new file mode 100644
index 00000000..1aa8d4dc
--- /dev/null
+++ b/source/LottieFlatbuffer/lottie_comp.fbs
@@ -0,0 +1,529 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+//
+// Serialized form of a translated Lottie animation (a WinCompData object graph).
+//
+// Design notes
+// ------------
+// * The graph is stored as a set of flat node vectors - one per node category -
+//   and all references between nodes are indices into those vectors rather than
+//   FlatBuffers offsets. This lets an interpreter keep a single realization cache
+//   per category that is indexed identically to the serialized data, so
+//   reference-identity caching is an array lookup rather than a hash lookup.
+// * Each category is a single table with a "kind" discriminator rather than a
+//   union of per-kind tables. This keeps the interpreter to one switch per
+//   category and lets the shared property-application code be written once.
+// * Absent fields mean "property was never set", exactly matching the nullable
+//   properties of the WinCompData object model.
+//
+// Versioning rules
+// ----------------
+// Changes MUST be additive: new fields are appended to the end of a table, and
+// new enum values are appended to the end of an enum. SCHEMA_VERSION is bumped
+// for every additive change; readers reject buffers whose schema_version is
+// greater than the version they were built against.
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema;
+
+// ---------------------------------------------------------------------------
+// Value types.
+// ---------------------------------------------------------------------------
+
+struct Vec2 { x: float; y: float; }
+struct Vec3 { x: float; y: float; z: float; }
+struct Vec4 { x: float; y: float; z: float; w: float; }
+struct Mat3x2 { m11: float; m12: float; m21: float; m22: float; m31: float; m32: float; }
+struct Mat4x4 {
+  m11: float; m12: float; m13: float; m14: float;
+  m21: float; m22: float; m23: float; m24: float;
+  m31: float; m32: float; m33: float; m34: float;
+  m41: float; m42: float; m43: float; m44: float;
+}
+struct Color { a: ubyte; r: ubyte; g: ubyte; b: ubyte; }
+
+// ---------------------------------------------------------------------------
+// Enums. Values match the corresponding WinCompData enums.
+// ---------------------------------------------------------------------------
+
+// Identifies the node vector that an object reference points into.
+// An object reference is packed into a uint as (category << 28) | index.
+// The value 0xFFFFFFFF means "no reference".
+enum ObjectCategory : ubyte {
+  Visual = 0,
+  Shape = 1,
+  Geometry = 2,
+  Brush = 3,
+  Animation = 4,
+  Easing = 5,
+  PropertySet = 6,
+  Surface = 7,
+  Clip = 8,
+  Controller = 9,
+  Shadow = 10,
+  Effect = 11,
+  GradientStop = 12,
+  ViewBox = 13,
+}
+
+enum VisualKind : ubyte { Container = 0, Sprite = 1, Shape = 2, Layer = 3 }
+enum ShapeKind : ubyte { Container = 0, Sprite = 1 }
+enum GeometryKind : ubyte { Path = 0, Rectangle = 1, RoundedRectangle = 2, Ellipse = 3 }
+enum BrushKind : ubyte { Color = 0, LinearGradient = 1, RadialGradient = 2, Surface = 3, Mask = 4, Effect = 5 }
+enum ClipKind : ubyte { Inset = 0, Geometric = 1 }
+enum ShadowKind : ubyte { Drop = 0 }
+enum SurfaceKind : ubyte { VisualSurface = 0, LoadedImageFromUri = 1, LoadedImageFromStream = 2 }
+enum EffectKind : ubyte { Composite = 0, GaussianBlur = 1 }
+enum EasingKind : ubyte { Linear = 0, CubicBezier = 1, Step = 2 }
+
+enum AnimationKind : ubyte {
+  Scalar = 0,
+  Vector2 = 1,
+  Vector3 = 2,
+  Vector4 = 3,
+  Color = 4,
+  Boolean = 5,
+  Path = 6,
+  Expression = 7,
+}
+
+enum KeyFrameKind : ubyte { Value = 0, Expression = 1 }
+
+enum CanvasGeometryKind : ubyte {
+  Combination = 0,
+  Ellipse = 1,
+  Group = 2,
+  Path = 3,
+  RoundedRectangle = 4,
+  TransformedGeometry = 5,
+}
+
+// Opcodes of the flattened CanvasPathBuilder command stream. Each opcode
+// consumes a fixed number of floats from the operand vector.
+enum PathOp : ubyte {
+  BeginFigure = 0,    // 2 operands: x, y
+  EndFigure = 1,      // 1 operand: CanvasFigureLoop as a float
+  AddLine = 2,        // 2 operands: x, y
+  AddCubicBezier = 3, // 6 operands: cp1.x, cp1.y, cp2.x, cp2.y, end.x, end.y
+}
+
+// Mirrors WinCompData.MetaData.PropertySetValueType.
+enum PropertyValueType : ubyte {
+  None = 0,
+  Color = 1,
+  Scalar = 2,
+  Vector2 = 3,
+  Vector3 = 4,
+  Vector4 = 5,
+}
+
+// ---------------------------------------------------------------------------
+// Shared structures.
+// ---------------------------------------------------------------------------
+
+// An animation bound to a property of an object.
+table Animator {
+  property: uint;    // string index of the animated property name
+  animation: uint;   // index into LottieComposition.animations
+  controller: uint = 0xFFFFFFFF; // index into LottieComposition.controllers
+}
+
+// State common to every CompositionObject. Omitted when empty.
+table CompObj {
+  comment: uint = 0xFFFFFFFF;    // string index
+  animators: [Animator];
+
+  // The CompositionPropertySet of the object, if it has any values or
+  // animations. Index into LottieComposition.property_sets.
+  properties: uint = 0xFFFFFFFF;
+}
+
+// A named value in a CompositionPropertySet.
+table PropertyValue {
+  name: uint;                    // string index
+  type: PropertyValueType;
+  scalar: float;
+  vector: Vec4;
+  color: Color;
+}
+
+// A named reference parameter of a CompositionAnimation.
+table ReferenceParameter {
+  name: uint;                    // string index
+  target: uint;                  // packed object reference
+}
+
+// A named source of a CompositionEffectBrush.
+table SourceParameter {
+  name: uint;                    // string index
+  brush: uint;                   // index into LottieComposition.brushes
+}
+
+table KeyFrame {
+  progress: float;
+  easing: uint = 0xFFFFFFFF;     // index into LottieComposition.easings
+  kind: KeyFrameKind;
+  expression: uint = 0xFFFFFFFF; // string index, for expression key frames
+  scalar: float;                 // Scalar and Boolean values
+  vector: Vec4;                  // Vector2, Vector3 and Vector4 values
+  color: Color;
+  path: uint = 0xFFFFFFFF;       // index into LottieComposition.canvas_geometries
+}
+
+// ---------------------------------------------------------------------------
+// Node tables.
+// ---------------------------------------------------------------------------
+
+table Visual {
+  base: CompObj;
+  kind: VisualKind;
+
+  // Visual.
+  border_mode: ubyte = null;
+  center_point: Vec3;
+  clip: uint = 0xFFFFFFFF;
+  is_visible: bool = null;
+  offset: Vec3;
+  opacity: float = null;
+  rotation_angle_in_degrees: float = null;
+  rotation_axis: Vec3;
+  scale: Vec3;
+  size: Vec2;
+  transform_matrix: Mat4x4;
+
+  // ContainerVisual and LayerVisual.
+  children: [uint];
+
+  // ShapeVisual.
+  shapes: [uint];
+  view_box: uint = 0xFFFFFFFF;
+
+  // SpriteVisual.
+  brush: uint = 0xFFFFFFFF;
+
+  // SpriteVisual and LayerVisual.
+  shadow: uint = 0xFFFFFFFF;
+}
+
+table Shape {
+  base: CompObj;
+  kind: ShapeKind;
+
+  // CompositionShape.
+  center_point: Vec2;
+  offset: Vec2;
+  rotation_angle_in_degrees: float = null;
+  scale: Vec2;
+  transform_matrix: Mat3x2;
+
+  // CompositionContainerShape.
+  shapes: [uint];
+
+  // CompositionSpriteShape.
+  fill_brush: uint = 0xFFFFFFFF;
+  stroke_brush: uint = 0xFFFFFFFF;
+  geometry: uint = 0xFFFFFFFF;
+  is_stroke_non_scaling: bool = null;
+  stroke_dash_offset: float = null;
+  stroke_dash_array: [float];
+  stroke_dash_cap: ubyte = null;
+  stroke_start_cap: ubyte = null;
+  stroke_end_cap: ubyte = null;
+  stroke_line_join: ubyte = null;
+  stroke_miter_limit: float = null;
+  stroke_thickness: float = null;
+}
+
+table Geometry {
+  base: CompObj;
+  kind: GeometryKind;
+
+  // CompositionGeometry.
+  trim_start: float = null;
+  trim_end: float = null;
+  trim_offset: float = null;
+
+  // CompositionPathGeometry.
+  path: uint = 0xFFFFFFFF;       // index into canvas_geometries
+
+  // CompositionRectangleGeometry and CompositionRoundedRectangleGeometry.
+  offset: Vec2;
+  size: Vec2;
+
+  // CompositionRoundedRectangleGeometry.
+  corner_radius: Vec2;
+
+  // CompositionEllipseGeometry.
+  center: Vec2;
+  radius: Vec2;
+}
+
+table Brush {
+  base: CompObj;
+  kind: BrushKind;
+
+  // CompositionColorBrush.
+  color: Color;
+
+  // CompositionGradientBrush.
+  anchor_point: Vec2;
+  center_point: Vec2;
+  color_stops: [uint];
+  extend_mode: ubyte = null;
+  interpolation_space: ubyte = null;
+  mapping_mode: ubyte = null;
+  offset: Vec2;
+  rotation_angle_in_degrees: float = null;
+  scale: Vec2;
+  transform_matrix: Mat3x2;
+
+  // CompositionLinearGradientBrush.
+  start_point: Vec2;
+  end_point: Vec2;
+
+  // CompositionRadialGradientBrush.
+  ellipse_center: Vec2;
+  ellipse_radius: Vec2;
+  gradient_origin_offset: Vec2;
+
+  // CompositionSurfaceBrush.
+  surface: uint = 0xFFFFFFFF;
+
+  // CompositionMaskBrush.
+  source: uint = 0xFFFFFFFF;
+  mask: uint = 0xFFFFFFFF;
+
+  // CompositionEffectBrush.
+  effect: uint = 0xFFFFFFFF;
+  source_parameters: [SourceParameter];
+}
+
+table GradientStop {
+  base: CompObj;
+  color: Color;
+  offset: float;
+}
+
+table ViewBox {
+  base: CompObj;
+  size: Vec2;
+}
+
+table Clip {
+  base: CompObj;
+  kind: ClipKind;
+
+  // CompositionClip.
+  center_point: Vec2;
+  scale: Vec2;
+
+  // InsetClip.
+  left_inset: float = null;
+  right_inset: float = null;
+  top_inset: float = null;
+  bottom_inset: float = null;
+
+  // CompositionGeometricClip.
+  geometry: uint = 0xFFFFFFFF;
+}
+
+table Shadow {
+  base: CompObj;
+  kind: ShadowKind;
+
+  // DropShadow.
+  blur_radius: float = null;
+  color: Color;
+  mask: uint = 0xFFFFFFFF;
+  offset: Vec3;
+  opacity: float = null;
+  source_policy: ubyte = null;
+}
+
+table Surface {
+  base: CompObj;
+  kind: SurfaceKind;
+
+  // CompositionVisualSurface.
+  source_visual: uint = 0xFFFFFFFF;
+  source_size: Vec2;
+  source_offset: Vec2;
+
+  // LoadedImageSurfaceFromUri.
+  uri: uint = 0xFFFFFFFF;        // string index
+
+  // LoadedImageSurfaceFromStream.
+  bytes: [ubyte];
+}
+
+table Effect {
+  base: CompObj;
+  kind: EffectKind;
+
+  // Names (string indices) of the CompositionEffectSourceParameters.
+  sources: [uint];
+
+  // CompositeEffect.
+  mode: ubyte;                   // CanvasComposite
+
+  // GaussianBlurEffect.
+  blur_amount: float;
+}
+
+table Easing {
+  base: CompObj;
+  kind: EasingKind;
+
+  // CubicBezierEasingFunction.
+  control_point_1: Vec2;
+  control_point_2: Vec2;
+
+  // StepEasingFunction.
+  step_count: int = null;
+  initial_step: int = null;
+  final_step: int = null;
+  is_initial_step_single_frame: bool = null;
+  is_final_step_single_frame: bool = null;
+}
+
+table Animation {
+  base: CompObj;
+  kind: AnimationKind;
+  target: uint = 0xFFFFFFFF;     // string index
+  reference_parameters: [ReferenceParameter];
+
+  // ExpressionAnimation.
+  expression: uint = 0xFFFFFFFF; // string index
+
+  // KeyFrameAnimation.
+  duration_ticks: long;
+  key_frames: [KeyFrame];
+
+  // ColorKeyFrameAnimation.
+  interpolation_color_space: ubyte = null;
+}
+
+table PropertySet {
+  base: CompObj;
+
+  // The object that owns this property set, or 0xFFFFFFFF if the property set
+  // is standalone (created by Compositor.CreatePropertySet).
+  owner: uint = 0xFFFFFFFF;      // packed object reference
+  values: [PropertyValue];
+}
+
+table Controller {
+  base: CompObj;
+
+  // The object and property that this controller controls. Absent for a
+  // custom controller.
+  target_object: uint = 0xFFFFFFFF; // packed object reference
+  target_property: uint = 0xFFFFFFFF; // string index
+  is_paused: bool;
+  is_custom: bool;
+}
+
+// ---------------------------------------------------------------------------
+// Metadata.
+// ---------------------------------------------------------------------------
+
+table PropertyBinding {
+  name: uint;                    // string index of the binding name
+  display_name: uint;            // string index
+  actual_type: PropertyValueType;
+  exposed_type: PropertyValueType;
+  default_scalar: float;
+  default_vector: Vec4;
+  default_color: Color;
+}
+
+table Marker {
+  name: uint;                    // string index
+  progress: float;               // start of the marker, 0..1
+  duration_progress: float;      // duration of the marker, 0..1
+}
+
+table Metadata {
+  name: uint = 0xFFFFFFFF;       // string index of the composition name
+  width: float;
+  height: float;
+  duration_ticks: long;
+  frames_per_second: float;
+  property_bindings: [PropertyBinding];
+  markers: [Marker];
+
+  // The property set that holds the theming properties, or 0xFFFFFFFF.
+  theming_property_set: uint = 0xFFFFFFFF; // index into property_sets
+}
+
+// ---------------------------------------------------------------------------
+// Root.
+// ---------------------------------------------------------------------------
+
+table LottieComposition {
+  schema_version: ushort;
+  required_uap_version: ushort;
+  metadata: Metadata;
+
+  // Index into visuals of the root of the tree.
+  root_visual: uint = 0xFFFFFFFF;
+
+  strings: [string];
+  visuals: [Visual];
+  shapes: [Shape];
+  geometries: [Geometry];
+  canvas_geometries: [CanvasGeometry];
+  brushes: [Brush];
+  gradient_stops: [GradientStop];
+  view_boxes: [ViewBox];
+  clips: [Clip];
+  shadows: [Shadow];
+  surfaces: [Surface];
+  effects: [Effect];
+  easings: [Easing];
+  animations: [Animation];
+  property_sets: [PropertySet];
+  controllers: [Controller];
+
+  // Indices into controllers of the custom animation controllers, in the order
+  // that a host should expose them.
+  custom_controllers: [uint];
+}
+
+table CanvasGeometry {
+  kind: CanvasGeometryKind;
+
+  // Combination.
+  a: uint = 0xFFFFFFFF;
+  b: uint = 0xFFFFFFFF;
+  combine_mode: ubyte;
+
+  // Combination and TransformedGeometry.
+  matrix: Mat3x2;
+
+  // TransformedGeometry.
+  source: uint = 0xFFFFFFFF;
+
+  // Group.
+  geometries: [uint];
+
+  // Group and Path.
+  fill_rule: ubyte;              // CanvasFilledRegionDetermination
+
+  // Path.
+  ops: [ubyte];
+  operands: [float];
+
+  // Ellipse (x, y, radius_x, radius_y) and
+  // RoundedRectangle (x, y, w, h, radius_x, radius_y).
+  x: float;
+  y: float;
+  w: float;
+  h: float;
+  radius_x: float;
+  radius_y: float;
+}
+
+root_type LottieComposition;
+file_identifier "LCMP";
+file_extension "lcomp";

From 720203b7d19a14ecffa8c5d52b30d518368e8ef0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:54:30 +0000
Subject: [PATCH 02/39] Use official Google.FlatBuffers tooling instead of
 hand-rolled reader/writer

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 build/RegenerateFlatbuffers.ps1               |   45 +
 .../CompDataFlatbuffer.dll.csproj             |   24 +
 .../CompDataFlatbuffer.projitems              |   19 +
 .../CompDataFlatbuffer.shproj                 |   13 +
 .../FlatBufferFormatException.cs              |   33 -
 source/CompDataFlatbuffer/FlatBufferTable.cs  |  325 ---
 source/CompDataFlatbuffer/FlatBufferWriter.cs |  474 ----
 source/CompDataFlatbuffer/Format.cs           |   79 +
 .../Generated/lottie_comp_generated.cs        | 2051 +++++++++++++++++
 source/CompDataFlatbuffer/Schema.cs           |  385 ----
 source/CompDataFlatbuffer/SchemaEnums.cs      |  139 --
 11 files changed, 2231 insertions(+), 1356 deletions(-)
 create mode 100644 build/RegenerateFlatbuffers.ps1
 create mode 100644 dlls/CompDataFlatbuffer/CompDataFlatbuffer.dll.csproj
 create mode 100644 source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
 create mode 100644 source/CompDataFlatbuffer/CompDataFlatbuffer.shproj
 delete mode 100644 source/CompDataFlatbuffer/FlatBufferFormatException.cs
 delete mode 100644 source/CompDataFlatbuffer/FlatBufferTable.cs
 delete mode 100644 source/CompDataFlatbuffer/FlatBufferWriter.cs
 create mode 100644 source/CompDataFlatbuffer/Format.cs
 create mode 100644 source/CompDataFlatbuffer/Generated/lottie_comp_generated.cs
 delete mode 100644 source/CompDataFlatbuffer/Schema.cs
 delete mode 100644 source/CompDataFlatbuffer/SchemaEnums.cs

diff --git a/build/RegenerateFlatbuffers.ps1 b/build/RegenerateFlatbuffers.ps1
new file mode 100644
index 00000000..8cc52934
--- /dev/null
+++ b/build/RegenerateFlatbuffers.ps1
@@ -0,0 +1,45 @@
+# Regenerates the FlatBuffers code for lottie_comp.fbs.
+#
+# The generated C# and C++ sources are checked in so that contributors do not
+# need flatc installed in order to build. Run this script after any change to
+# source/LottieFlatbuffer/lottie_comp.fbs, and check in the result.
+#
+# The version of flatc MUST match the version of the Google.FlatBuffers NuGet
+# package referenced by dlls/CompDataFlatbuffer/CompDataFlatbuffer.dll.csproj,
+# because the generated C# calls a version-stamped validation method
+# (FlatBufferConstants.FLATBUFFERS_<version>) that only exists in the matching
+# package.
+#
+# Download flatc from https://github.com/google/flatbuffers/releases/tag/v25.2.10
+
+[CmdletBinding()]
+param(
+    # Path to the flatc executable. Defaults to whatever is on the PATH.
+    [string]$Flatc = "flatc"
+)
+
+$ErrorActionPreference = "Stop"
+
+$expectedVersion = "25.2.10"
+
+$repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..")
+$schema = Join-Path $repoRoot "source/LottieFlatbuffer/lottie_comp.fbs"
+$csharpOut = Join-Path $repoRoot "source/CompDataFlatbuffer/Generated"
+$cppOut = Join-Path $repoRoot "dlls/LottieRuntime/Generated"
+
+$actualVersion = (& $Flatc --version) -replace '^flatc version ', ''
+if ($actualVersion.Trim() -ne $expectedVersion) {
+    throw "flatc version $expectedVersion is required, but '$Flatc' is version $($actualVersion.Trim())."
+}
+
+New-Item -ItemType Directory -Force -Path $csharpOut, $cppOut | Out-Null
+
+# --gen-onefile keeps the checked in C# to a single file rather than one file
+# per type spread over a namespace directory tree.
+& $Flatc --csharp --gen-onefile -o $csharpOut $schema
+if ($LASTEXITCODE -ne 0) { throw "flatc failed to generate C#." }
+
+& $Flatc --cpp --scoped-enums -o $cppOut $schema
+if ($LASTEXITCODE -ne 0) { throw "flatc failed to generate C++." }
+
+Write-Host "Generated FlatBuffers code from $schema"
diff --git a/dlls/CompDataFlatbuffer/CompDataFlatbuffer.dll.csproj b/dlls/CompDataFlatbuffer/CompDataFlatbuffer.dll.csproj
new file mode 100644
index 00000000..cb3d2170
--- /dev/null
+++ b/dlls/CompDataFlatbuffer/CompDataFlatbuffer.dll.csproj
@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Configurations>Debug;Release</Configurations>
+    <LangVersion>latest</LangVersion>
+    <DefineConstants>PUBLIC_CompDataFlatbuffer</DefineConstants>
+  </PropertyGroup>
+
+  <Import Project="..\..\source\CompDataFlatbuffer\CompDataFlatbuffer.projitems" Label="Shared" />
+
+  <ItemGroup>
+    <!-- The version here must match the version of flatc used by
+         build/RegenerateFlatbuffers.ps1 to produce the checked in generated code. -->
+    <PackageReference Include="Google.FlatBuffers" Version="25.2.10" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CompMetadata\CompMetadata.dll.csproj" />
+    <ProjectReference Include="..\LottieMetadata\LottieMetadata.dll.csproj" />
+    <ProjectReference Include="..\WinCompData\WinCompData.dll.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems b/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
new file mode 100644
index 00000000..add80aa3
--- /dev/null
+++ b/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <SharedGUID>5a3f2c41-9a2e-4c2d-9f4a-1d1a0f6b3c77</SharedGUID>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration">
+    <Import_RootNamespace>CompDataFlatbuffer</Import_RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)Format.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <!-- Generated by build/RegenerateFlatbuffers.ps1 from source/LottieFlatbuffer/lottie_comp.fbs.
+         Checked in so that contributors do not need flatc installed. -->
+    <Compile Include="$(MSBuildThisFileDirectory)Generated\lottie_comp_generated.cs" />
+  </ItemGroup>
+</Project>
diff --git a/source/CompDataFlatbuffer/CompDataFlatbuffer.shproj b/source/CompDataFlatbuffer/CompDataFlatbuffer.shproj
new file mode 100644
index 00000000..5a214f6b
--- /dev/null
+++ b/source/CompDataFlatbuffer/CompDataFlatbuffer.shproj
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>5a3f2c41-9a2e-4c2d-9f4a-1d1a0f6b3c77</ProjectGuid>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.Default.props" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.props" />
+  <PropertyGroup />
+  <Import Project="CompDataFlatbuffer.projitems" Label="Shared" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.CSharp.targets" />
+</Project>
diff --git a/source/CompDataFlatbuffer/FlatBufferFormatException.cs b/source/CompDataFlatbuffer/FlatBufferFormatException.cs
deleted file mode 100644
index 62756e2c..00000000
--- a/source/CompDataFlatbuffer/FlatBufferFormatException.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#nullable enable
-
-using System;
-
-namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
-{
-    /// <summary>
-    /// Thrown when a buffer is not a valid serialized composition.
-    /// </summary>
-#if PUBLIC_CompDataFlatbuffer
-    public
-#endif
-    sealed class FlatBufferFormatException : Exception
-    {
-        public FlatBufferFormatException()
-        {
-        }
-
-        public FlatBufferFormatException(string message)
-            : base(message)
-        {
-        }
-
-        public FlatBufferFormatException(string message, Exception innerException)
-            : base(message, innerException)
-        {
-        }
-    }
-}
diff --git a/source/CompDataFlatbuffer/FlatBufferTable.cs b/source/CompDataFlatbuffer/FlatBufferTable.cs
deleted file mode 100644
index 8338ac78..00000000
--- a/source/CompDataFlatbuffer/FlatBufferTable.cs
+++ /dev/null
@@ -1,325 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#nullable enable
-
-using System;
-using System.Text;
-
-namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
-{
-    /// <summary>
-    /// A minimal reader for the FlatBuffers binary wire format. All accesses are
-    /// bounds checked; a malformed buffer causes a <see cref="FlatBufferFormatException"/>
-    /// rather than undefined behavior.
-    /// </summary>
-    readonly struct FlatBufferTable
-    {
-        readonly byte[] _buffer;
-        readonly int _position;
-
-        internal FlatBufferTable(byte[] buffer, int position)
-        {
-            _buffer = buffer;
-            _position = position;
-        }
-
-        internal bool IsNull => _buffer is null;
-
-        /// <summary>
-        /// Gets the root table of a buffer, checking its file identifier.
-        /// </summary>
-        /// <param name="buffer">The buffer.</param>
-        /// <param name="fileIdentifier">The expected 4 character file identifier.</param>
-        /// <returns>The root table.</returns>
-        internal static FlatBufferTable GetRoot(byte[] buffer, string fileIdentifier)
-        {
-            if (buffer is null)
-            {
-                throw new ArgumentNullException(nameof(buffer));
-            }
-
-            if (buffer.Length < 8)
-            {
-                throw new FlatBufferFormatException("Buffer is too small.");
-            }
-
-            for (var i = 0; i < 4; i++)
-            {
-                if (buffer[4 + i] != (byte)fileIdentifier[i])
-                {
-                    throw new FlatBufferFormatException("Unrecognized file identifier.");
-                }
-            }
-
-            var rootOffset = ReadInt32(buffer, 0);
-            return new FlatBufferTable(buffer, CheckedAdd(buffer, 0, rootOffset));
-        }
-
-        /// <summary>
-        /// Returns the absolute position of the data of the field with the given
-        /// id, or 0 if the field is not present.
-        /// </summary>
-        /// <param name="field">The id of the field.</param>
-        /// <returns>The position of the field's data, or 0.</returns>
-        internal int FieldPosition(int field)
-        {
-            var vtable = _position - ReadInt32(_buffer, _position);
-            if (vtable < 0 || vtable + 4 > _buffer.Length)
-            {
-                throw new FlatBufferFormatException("Invalid vtable offset.");
-            }
-
-            var vtableSize = ReadUInt16(_buffer, vtable);
-            var fieldIndex = 4 + (field * 2);
-            if (fieldIndex + 2 > vtableSize)
-            {
-                return 0;
-            }
-
-            var fieldOffset = ReadUInt16(_buffer, vtable + fieldIndex);
-            if (fieldOffset == 0)
-            {
-                return 0;
-            }
-
-            var result = _position + fieldOffset;
-            if (result < 0 || result >= _buffer.Length)
-            {
-                throw new FlatBufferFormatException("Field is outside the buffer.");
-            }
-
-            return result;
-        }
-
-        internal byte GetUInt8(int field, byte defaultValue)
-        {
-            var position = FieldPosition(field);
-            return position == 0 ? defaultValue : _buffer[position];
-        }
-
-        internal byte? GetOptionalUInt8(int field)
-        {
-            var position = FieldPosition(field);
-            return position == 0 ? (byte?)null : _buffer[position];
-        }
-
-        internal bool GetBool(int field, bool defaultValue)
-            => GetUInt8(field, (byte)(defaultValue ? 1 : 0)) != 0;
-
-        internal bool? GetOptionalBool(int field)
-        {
-            var value = GetOptionalUInt8(field);
-            return value.HasValue ? value.Value != 0 : (bool?)null;
-        }
-
-        internal ushort GetUInt16(int field, ushort defaultValue)
-        {
-            var position = FieldPosition(field);
-            return position == 0 ? defaultValue : ReadUInt16(_buffer, position);
-        }
-
-        internal int GetInt32(int field, int defaultValue)
-        {
-            var position = FieldPosition(field);
-            return position == 0 ? defaultValue : ReadInt32(_buffer, position);
-        }
-
-        internal int? GetOptionalInt32(int field)
-        {
-            var position = FieldPosition(field);
-            return position == 0 ? (int?)null : ReadInt32(_buffer, position);
-        }
-
-        internal uint GetUInt32(int field, uint defaultValue)
-        {
-            var position = FieldPosition(field);
-            return position == 0 ? defaultValue : unchecked((uint)ReadInt32(_buffer, position));
-        }
-
-        internal long GetInt64(int field, long defaultValue)
-        {
-            var position = FieldPosition(field);
-            if (position == 0)
-            {
-                return defaultValue;
-            }
-
-            var low = unchecked((uint)ReadInt32(_buffer, position));
-            var high = ReadInt32(_buffer, position + 4);
-            return unchecked((long)(((ulong)(uint)high << 32) | low));
-        }
-
-        internal float GetFloat(int field, float defaultValue)
-        {
-            var position = FieldPosition(field);
-            return position == 0 ? defaultValue : BitConverter.Int32BitsToSingle(ReadInt32(_buffer, position));
-        }
-
-        internal float? GetOptionalFloat(int field)
-        {
-            var position = FieldPosition(field);
-            return position == 0 ? (float?)null : BitConverter.Int32BitsToSingle(ReadInt32(_buffer, position));
-        }
-
-        /// <summary>
-        /// Returns the position of an inline struct field, or 0 if not present.
-        /// Use the ReadStructFloat and ReadStructUInt8 methods to read its fields.
-        /// </summary>
-        /// <param name="field">The id of the field.</param>
-        /// <returns>The position of the struct, or 0.</returns>
-        internal int GetStructPosition(int field) => FieldPosition(field);
-
-        internal float ReadStructFloat(int structPosition, int offset)
-            => BitConverter.Int32BitsToSingle(ReadInt32(_buffer, structPosition + offset));
-
-        internal byte ReadStructUInt8(int structPosition, int offset)
-        {
-            if (structPosition + offset >= _buffer.Length)
-            {
-                throw new FlatBufferFormatException("Struct is outside the buffer.");
-            }
-
-            return _buffer[structPosition + offset];
-        }
-
-        internal FlatBufferTable GetTable(int field)
-        {
-            var position = FieldPosition(field);
-            return position == 0
-                ? default
-                : new FlatBufferTable(_buffer, CheckedAdd(_buffer, position, ReadInt32(_buffer, position)));
-        }
-
-        internal string? GetString(int field)
-        {
-            var position = FieldPosition(field);
-            if (position == 0)
-            {
-                return null;
-            }
-
-            var stringPosition = CheckedAdd(_buffer, position, ReadInt32(_buffer, position));
-            var length = ReadInt32(_buffer, stringPosition);
-            if (length < 0 || stringPosition + 4 + length > _buffer.Length)
-            {
-                throw new FlatBufferFormatException("String is outside the buffer.");
-            }
-
-            return Encoding.UTF8.GetString(_buffer, stringPosition + 4, length);
-        }
-
-        /// <summary>
-        /// Returns the number of elements in a vector field.
-        /// </summary>
-        /// <param name="field">The id of the field.</param>
-        /// <returns>The number of elements, or 0 if the field is not present.</returns>
-        internal int VectorLength(int field)
-        {
-            var position = FieldPosition(field);
-            if (position == 0)
-            {
-                return 0;
-            }
-
-            var vector = CheckedAdd(_buffer, position, ReadInt32(_buffer, position));
-            var length = ReadInt32(_buffer, vector);
-            if (length < 0)
-            {
-                throw new FlatBufferFormatException("Invalid vector length.");
-            }
-
-            return length;
-        }
-
-        internal byte GetVectorUInt8(int field, int index)
-        {
-            var position = VectorElementPosition(field, index, sizeof(byte));
-            return _buffer[position];
-        }
-
-        internal float GetVectorFloat(int field, int index)
-            => BitConverter.Int32BitsToSingle(ReadInt32(_buffer, VectorElementPosition(field, index, sizeof(float))));
-
-        internal uint GetVectorUInt32(int field, int index)
-            => unchecked((uint)ReadInt32(_buffer, VectorElementPosition(field, index, sizeof(uint))));
-
-        internal FlatBufferTable GetVectorTable(int field, int index)
-        {
-            var position = VectorElementPosition(field, index, sizeof(int));
-            return new FlatBufferTable(_buffer, CheckedAdd(_buffer, position, ReadInt32(_buffer, position)));
-        }
-
-        internal string GetVectorString(int field, int index)
-        {
-            var position = VectorElementPosition(field, index, sizeof(int));
-            var stringPosition = CheckedAdd(_buffer, position, ReadInt32(_buffer, position));
-            var length = ReadInt32(_buffer, stringPosition);
-            if (length < 0 || stringPosition + 4 + length > _buffer.Length)
-            {
-                throw new FlatBufferFormatException("String is outside the buffer.");
-            }
-
-            return Encoding.UTF8.GetString(_buffer, stringPosition + 4, length);
-        }
-
-        static int ReadInt32(byte[] buffer, int position)
-        {
-            if (position < 0 || position + 4 > buffer.Length)
-            {
-                throw new FlatBufferFormatException("Read is outside the buffer.");
-            }
-
-            return buffer[position] |
-                   (buffer[position + 1] << 8) |
-                   (buffer[position + 2] << 16) |
-                   (buffer[position + 3] << 24);
-        }
-
-        static ushort ReadUInt16(byte[] buffer, int position)
-        {
-            if (position < 0 || position + 2 > buffer.Length)
-            {
-                throw new FlatBufferFormatException("Read is outside the buffer.");
-            }
-
-            return unchecked((ushort)(buffer[position] | (buffer[position + 1] << 8)));
-        }
-
-        static int CheckedAdd(byte[] buffer, int position, int offset)
-        {
-            var result = (long)position + offset;
-            if (result < 0 || result >= buffer.Length)
-            {
-                throw new FlatBufferFormatException("Offset is outside the buffer.");
-            }
-
-            return (int)result;
-        }
-
-        int VectorElementPosition(int field, int index, int elementSize)
-        {
-            var position = FieldPosition(field);
-            if (position == 0)
-            {
-                throw new FlatBufferFormatException("Vector is not present.");
-            }
-
-            var vector = CheckedAdd(_buffer, position, ReadInt32(_buffer, position));
-            var length = ReadInt32(_buffer, vector);
-            if (index < 0 || index >= length)
-            {
-                throw new FlatBufferFormatException("Vector index is out of range.");
-            }
-
-            var result = vector + 4 + (index * elementSize);
-            if (result < 0 || result + elementSize > _buffer.Length)
-            {
-                throw new FlatBufferFormatException("Vector element is outside the buffer.");
-            }
-
-            return result;
-        }
-    }
-}
diff --git a/source/CompDataFlatbuffer/FlatBufferWriter.cs b/source/CompDataFlatbuffer/FlatBufferWriter.cs
deleted file mode 100644
index e4fbbc4e..00000000
--- a/source/CompDataFlatbuffer/FlatBufferWriter.cs
+++ /dev/null
@@ -1,474 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#nullable enable
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
-{
-    /// <summary>
-    /// A minimal writer for the FlatBuffers binary wire format. Buffers produced
-    /// by this writer are readable by any FlatBuffers implementation, including
-    /// the C++ code generated from lottie_comp.fbs.
-    /// </summary>
-    /// <remarks>
-    /// The wire format is described at https://flatbuffers.dev/flatbuffers_internals.html.
-    /// Data is written from the end of the buffer towards its start, so all
-    /// offsets returned by this class are measured backwards from the end of the
-    /// buffer.
-    /// </remarks>
-    sealed class FlatBufferWriter
-    {
-        // The offsets of the vtables that have been written so far. Used to
-        // share identical vtables between tables.
-        readonly List<int> _vtables = new List<int>();
-
-        // The field offsets of the table that is currently being built.
-        readonly List<int> _currentVTable = new List<int>();
-
-        byte[] _buffer;
-
-        // The number of bytes at the end of _buffer that contain data.
-        int _used;
-
-        // The offset of the start of the table that is currently being built,
-        // or -1 if no table is being built.
-        int _tableStart = -1;
-
-        int _minAlign = 1;
-
-        internal FlatBufferWriter(int initialSize = 4096)
-        {
-            _buffer = new byte[Math.Max(initialSize, 32)];
-        }
-
-        /// <summary>
-        /// Starts a table with the given number of fields. Fields are added with
-        /// the Add methods, then the table is completed by calling <see cref="EndTable"/>.
-        /// </summary>
-        /// <param name="fieldCount">The number of fields declared by the table in the schema.</param>
-        internal void StartTable(int fieldCount)
-        {
-            if (_tableStart >= 0)
-            {
-                throw new InvalidOperationException("Nested table construction is not supported.");
-            }
-
-            _currentVTable.Clear();
-            for (var i = 0; i < fieldCount; i++)
-            {
-                _currentVTable.Add(0);
-            }
-
-            _tableStart = _used;
-        }
-
-        /// <summary>
-        /// Completes the table that is being built and returns its offset.
-        /// </summary>
-        /// <returns>The offset of the table.</returns>
-        internal int EndTable()
-        {
-            if (_tableStart < 0)
-            {
-                throw new InvalidOperationException("No table is being built.");
-            }
-
-            // Reserve space for the offset to the vtable.
-            Prep(sizeof(int), 0);
-            EnsureSpace(sizeof(int));
-            _used += sizeof(int);
-            var tableEnd = _used;
-
-            // Trailing empty fields are implied by the length of the vtable.
-            var fieldCount = _currentVTable.Count;
-            while (fieldCount > 0 && _currentVTable[fieldCount - 1] == 0)
-            {
-                fieldCount--;
-            }
-
-            // Write the vtable: the size of the vtable, the size of the table,
-            // then the offset of each field within the table.
-            var vtableSize = (fieldCount + 2) * sizeof(short);
-            Prep(sizeof(short), vtableSize);
-            for (var i = fieldCount - 1; i >= 0; i--)
-            {
-                var fieldOffset = _currentVTable[i];
-                WriteInt16(checked((short)(fieldOffset == 0 ? 0 : tableEnd - fieldOffset)));
-            }
-
-            WriteInt16(checked((short)(tableEnd - _tableStart)));
-            WriteInt16(checked((short)vtableSize));
-
-            var vtableOffset = _used;
-
-            // Share an identical vtable if one has already been written.
-            var sharedVTableOffset = FindMatchingVTable(vtableOffset, vtableSize);
-            if (sharedVTableOffset >= 0)
-            {
-                _used = vtableOffset - vtableSize;
-                vtableOffset = sharedVTableOffset;
-            }
-            else
-            {
-                _vtables.Add(vtableOffset);
-            }
-
-            // Patch the signed offset from the table to its vtable.
-            WriteInt32At(tableEnd, vtableOffset - tableEnd);
-
-            _tableStart = -1;
-            return tableEnd;
-        }
-
-        internal void AddUInt8(int field, byte value, byte defaultValue)
-        {
-            if (value != defaultValue)
-            {
-                Prep(sizeof(byte), 0);
-                WriteByte(value);
-                Slot(field);
-            }
-        }
-
-        internal void AddUInt8(int field, byte? value)
-        {
-            if (value.HasValue)
-            {
-                Prep(sizeof(byte), 0);
-                WriteByte(value.Value);
-                Slot(field);
-            }
-        }
-
-        internal void AddBool(int field, bool value, bool defaultValue)
-            => AddUInt8(field, (byte)(value ? 1 : 0), (byte)(defaultValue ? 1 : 0));
-
-        internal void AddBool(int field, bool? value)
-            => AddUInt8(field, value.HasValue ? (byte)(value.Value ? 1 : 0) : (byte?)null);
-
-        internal void AddUInt16(int field, ushort value, ushort defaultValue)
-        {
-            if (value != defaultValue)
-            {
-                Prep(sizeof(short), 0);
-                WriteInt16(unchecked((short)value));
-                Slot(field);
-            }
-        }
-
-        internal void AddInt32(int field, int value, int defaultValue)
-        {
-            if (value != defaultValue)
-            {
-                Prep(sizeof(int), 0);
-                WriteInt32(value);
-                Slot(field);
-            }
-        }
-
-        internal void AddInt32(int field, int? value)
-        {
-            if (value.HasValue)
-            {
-                Prep(sizeof(int), 0);
-                WriteInt32(value.Value);
-                Slot(field);
-            }
-        }
-
-        internal void AddUInt32(int field, uint value, uint defaultValue)
-            => AddInt32(field, unchecked((int)value), unchecked((int)defaultValue));
-
-        internal void AddInt64(int field, long value, long defaultValue)
-        {
-            if (value != defaultValue)
-            {
-                Prep(sizeof(long), 0);
-                WriteInt64(value);
-                Slot(field);
-            }
-        }
-
-        internal void AddFloat(int field, float value, float defaultValue)
-        {
-            if (!value.Equals(defaultValue))
-            {
-                Prep(sizeof(float), 0);
-                WriteInt32(BitConverter.SingleToInt32Bits(value));
-                Slot(field);
-            }
-        }
-
-        internal void AddFloat(int field, float? value)
-        {
-            if (value.HasValue)
-            {
-                Prep(sizeof(float), 0);
-                WriteInt32(BitConverter.SingleToInt32Bits(value.Value));
-                Slot(field);
-            }
-        }
-
-        /// <summary>
-        /// Adds a reference to a previously created table, vector or string.
-        /// An <paramref name="offset"/> of 0 means "not present".
-        /// </summary>
-        /// <param name="field">The id of the field.</param>
-        /// <param name="offset">The offset of the referenced data.</param>
-        internal void AddOffset(int field, int offset)
-        {
-            if (offset != 0)
-            {
-                Prep(sizeof(int), 0);
-                WriteInt32(_used + sizeof(int) - offset);
-                Slot(field);
-            }
-        }
-
-        /// <summary>
-        /// Prepares to write an inline struct of the given size and alignment.
-        /// The struct's fields must then be written in reverse declaration order
-        /// using the Write methods, followed by <see cref="AddStruct"/>.
-        /// </summary>
-        /// <param name="alignment">The alignment of the struct.</param>
-        /// <param name="size">The size of the struct.</param>
-        internal void StartStruct(int alignment, int size) => Prep(alignment, size);
-
-        /// <summary>
-        /// Adds an inline struct field whose data was just written by
-        /// <see cref="StartStruct"/> and the Write methods.
-        /// </summary>
-        /// <param name="field">The id of the field.</param>
-        internal void AddStruct(int field) => Slot(field);
-
-        internal void WriteFloat(float value) => WriteInt32(BitConverter.SingleToInt32Bits(value));
-
-        internal void WriteUInt8(byte value) => WriteByte(value);
-
-        internal int CreateString(string value)
-        {
-            var bytes = Encoding.UTF8.GetBytes(value);
-
-            // Strings are null terminated for the convenience of C++ readers.
-            Prep(sizeof(int), bytes.Length + 1);
-            WriteByte(0);
-            EnsureSpace(bytes.Length);
-            _used += bytes.Length;
-            Array.Copy(bytes, 0, _buffer, _buffer.Length - _used, bytes.Length);
-            WriteInt32(bytes.Length);
-            return _used;
-        }
-
-        internal int CreateByteVector(IReadOnlyList<byte> values)
-        {
-            StartVector(sizeof(byte), values.Count, sizeof(byte));
-            for (var i = values.Count - 1; i >= 0; i--)
-            {
-                WriteByte(values[i]);
-            }
-
-            return EndVector(values.Count);
-        }
-
-        internal int CreateFloatVector(IReadOnlyList<float> values)
-        {
-            StartVector(sizeof(float), values.Count, sizeof(float));
-            for (var i = values.Count - 1; i >= 0; i--)
-            {
-                WriteInt32(BitConverter.SingleToInt32Bits(values[i]));
-            }
-
-            return EndVector(values.Count);
-        }
-
-        internal int CreateUInt32Vector(IReadOnlyList<uint> values)
-        {
-            StartVector(sizeof(uint), values.Count, sizeof(uint));
-            for (var i = values.Count - 1; i >= 0; i--)
-            {
-                WriteInt32(unchecked((int)values[i]));
-            }
-
-            return EndVector(values.Count);
-        }
-
-        /// <summary>
-        /// Creates a vector of offsets to previously created tables or strings.
-        /// </summary>
-        /// <param name="offsets">The offsets of the referenced data.</param>
-        /// <returns>The offset of the vector.</returns>
-        internal int CreateOffsetVector(IReadOnlyList<int> offsets)
-        {
-            StartVector(sizeof(int), offsets.Count, sizeof(int));
-            for (var i = offsets.Count - 1; i >= 0; i--)
-            {
-                Prep(sizeof(int), 0);
-                WriteInt32(_used + sizeof(int) - offsets[i]);
-            }
-
-            return EndVector(offsets.Count);
-        }
-
-        /// <summary>
-        /// Completes the buffer, making <paramref name="rootTable"/> its root.
-        /// </summary>
-        /// <param name="rootTable">The offset of the root table.</param>
-        /// <param name="fileIdentifier">The 4 character file identifier.</param>
-        /// <returns>The completed buffer.</returns>
-        internal byte[] Finish(int rootTable, string fileIdentifier)
-        {
-            if (fileIdentifier is null || fileIdentifier.Length != 4)
-            {
-                throw new ArgumentException("File identifier must be 4 characters.", nameof(fileIdentifier));
-            }
-
-            Prep(_minAlign, sizeof(int) + 4);
-            for (var i = 3; i >= 0; i--)
-            {
-                WriteByte((byte)fileIdentifier[i]);
-            }
-
-            WriteInt32(_used + sizeof(int) - rootTable);
-
-            var result = new byte[_used];
-            Array.Copy(_buffer, _buffer.Length - _used, result, 0, _used);
-            return result;
-        }
-
-        void StartVector(int elementSize, int count, int alignment)
-        {
-            Prep(sizeof(int), elementSize * count);
-            Prep(alignment, elementSize * count);
-        }
-
-        int EndVector(int count)
-        {
-            WriteInt32(count);
-            return _used;
-        }
-
-        // Records the offset of the field that was just written.
-        void Slot(int field)
-        {
-            if (field >= _currentVTable.Count)
-            {
-                throw new ArgumentOutOfRangeException(nameof(field));
-            }
-
-            _currentVTable[field] = _used;
-        }
-
-        // Pads so that, after writing additionalBytes more bytes, the write
-        // position will be aligned to the given alignment.
-        void Prep(int alignment, int additionalBytes)
-        {
-            if (alignment > _minAlign)
-            {
-                _minAlign = alignment;
-            }
-
-            var alignSize = ((~(_used + additionalBytes)) + 1) & (alignment - 1);
-            EnsureSpace(alignSize + additionalBytes);
-            for (var i = 0; i < alignSize; i++)
-            {
-                WriteByte(0);
-            }
-        }
-
-        int FindMatchingVTable(int vtableOffset, int vtableSize)
-        {
-            foreach (var candidate in _vtables)
-            {
-                if (ReadInt16At(candidate) != vtableSize)
-                {
-                    continue;
-                }
-
-                var match = true;
-                for (var i = sizeof(short); i < vtableSize; i += sizeof(short))
-                {
-                    if (ReadInt16At(candidate - i) != ReadInt16At(vtableOffset - i))
-                    {
-                        match = false;
-                        break;
-                    }
-                }
-
-                if (match)
-                {
-                    return candidate;
-                }
-            }
-
-            return -1;
-        }
-
-        void EnsureSpace(int size)
-        {
-            if (_used + size <= _buffer.Length)
-            {
-                return;
-            }
-
-            var newSize = _buffer.Length;
-            while (newSize < _used + size)
-            {
-                newSize *= 2;
-            }
-
-            var newBuffer = new byte[newSize];
-            Array.Copy(_buffer, _buffer.Length - _used, newBuffer, newSize - _used, _used);
-            _buffer = newBuffer;
-        }
-
-        void WriteByte(byte value)
-        {
-            EnsureSpace(sizeof(byte));
-            _used += sizeof(byte);
-            _buffer[_buffer.Length - _used] = value;
-        }
-
-        void WriteInt16(short value)
-        {
-            EnsureSpace(sizeof(short));
-            _used += sizeof(short);
-            var index = _buffer.Length - _used;
-            _buffer[index] = unchecked((byte)value);
-            _buffer[index + 1] = unchecked((byte)(value >> 8));
-        }
-
-        void WriteInt32(int value)
-        {
-            EnsureSpace(sizeof(int));
-            _used += sizeof(int);
-            WriteInt32At(_used, value);
-        }
-
-        void WriteInt64(long value)
-        {
-            // The buffer is written backwards, so the high word is written first.
-            WriteInt32(unchecked((int)(value >> 32)));
-            WriteInt32(unchecked((int)value));
-        }
-
-        void WriteInt32At(int offset, int value)
-        {
-            var index = _buffer.Length - offset;
-            _buffer[index] = unchecked((byte)value);
-            _buffer[index + 1] = unchecked((byte)(value >> 8));
-            _buffer[index + 2] = unchecked((byte)(value >> 16));
-            _buffer[index + 3] = unchecked((byte)(value >> 24));
-        }
-
-        short ReadInt16At(int offset)
-        {
-            var index = _buffer.Length - offset;
-            return unchecked((short)(_buffer[index] | (_buffer[index + 1] << 8)));
-        }
-    }
-}
diff --git a/source/CompDataFlatbuffer/Format.cs b/source/CompDataFlatbuffer/Format.cs
new file mode 100644
index 00000000..b019590c
--- /dev/null
+++ b/source/CompDataFlatbuffer/Format.cs
@@ -0,0 +1,79 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
+{
+    /// <summary>
+    /// Constants and helpers that describe the lottie_comp.fbs wire format but
+    /// which are not expressible in the schema itself, and so are not produced
+    /// by the FlatBuffers compiler.
+    /// </summary>
+#if PUBLIC_CompDataFlatbuffer
+    public
+#endif
+    static class Format
+    {
+        /// <summary>
+        /// The version of the schema that this code reads and writes. This is stored in
+        /// the schema_version field of every buffer. It is incremented for every change
+        /// to lottie_comp.fbs. Only additive changes are permitted, so a reader can load
+        /// any buffer whose schema_version is less than or equal to its own.
+        /// </summary>
+        public const ushort Version = 1;
+
+        /// <summary>
+        /// The 4 character identifier stored at offset 4 of every buffer. This is the
+        /// file_identifier declared in lottie_comp.fbs.
+        /// </summary>
+        public const string FileIdentifier = "LCMP";
+
+        /// <summary>
+        /// The file extension used for serialized compositions. This is the
+        /// file_extension declared in lottie_comp.fbs.
+        /// </summary>
+        public const string FileExtension = ".lcomp";
+
+        /// <summary>
+        /// The value of an index or object reference field that refers to nothing.
+        /// </summary>
+        public const uint NullIndex = 0xFFFFFFFF;
+
+        /// <summary>
+        /// The number of low bits of an object reference that store the index. The
+        /// remaining high bits store the <see cref="Schema.ObjectCategory"/>, i.e. which
+        /// of the root table's node vectors the index refers to.
+        /// </summary>
+        const int ObjectReferenceIndexBits = 28;
+
+        const uint ObjectReferenceIndexMask = (1u << ObjectReferenceIndexBits) - 1;
+
+        /// <summary>
+        /// Combines a category and an index into the single uint used by object
+        /// reference fields.
+        /// </summary>
+        /// <param name="category">The vector that <paramref name="index"/> indexes.</param>
+        /// <param name="index">The index of the node within that vector.</param>
+        /// <returns>The packed object reference.</returns>
+        public static uint PackObjectReference(Schema.ObjectCategory category, int index)
+            => ((uint)category << ObjectReferenceIndexBits) | ((uint)index & ObjectReferenceIndexMask);
+
+        /// <summary>
+        /// Returns the category part of an object reference.
+        /// </summary>
+        /// <param name="reference">A packed object reference.</param>
+        /// <returns>The category of the referenced node.</returns>
+        public static Schema.ObjectCategory UnpackCategory(uint reference)
+            => (Schema.ObjectCategory)(reference >> ObjectReferenceIndexBits);
+
+        /// <summary>
+        /// Returns the index part of an object reference.
+        /// </summary>
+        /// <param name="reference">A packed object reference.</param>
+        /// <returns>The index of the referenced node within its category's vector.</returns>
+        public static int UnpackIndex(uint reference)
+            => (int)(reference & ObjectReferenceIndexMask);
+    }
+}
diff --git a/source/CompDataFlatbuffer/Generated/lottie_comp_generated.cs b/source/CompDataFlatbuffer/Generated/lottie_comp_generated.cs
new file mode 100644
index 00000000..1c33450d
--- /dev/null
+++ b/source/CompDataFlatbuffer/Generated/lottie_comp_generated.cs
@@ -0,0 +1,2051 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+public enum ObjectCategory : byte
+{
+  Visual = 0,
+  Shape = 1,
+  Geometry = 2,
+  Brush = 3,
+  Animation = 4,
+  Easing = 5,
+  PropertySet = 6,
+  Surface = 7,
+  Clip = 8,
+  Controller = 9,
+  Shadow = 10,
+  Effect = 11,
+  GradientStop = 12,
+  ViewBox = 13,
+};
+
+public enum VisualKind : byte
+{
+  Container = 0,
+  Sprite = 1,
+  Shape = 2,
+  Layer = 3,
+};
+
+public enum ShapeKind : byte
+{
+  Container = 0,
+  Sprite = 1,
+};
+
+public enum GeometryKind : byte
+{
+  Path = 0,
+  Rectangle = 1,
+  RoundedRectangle = 2,
+  Ellipse = 3,
+};
+
+public enum BrushKind : byte
+{
+  Color = 0,
+  LinearGradient = 1,
+  RadialGradient = 2,
+  Surface = 3,
+  Mask = 4,
+  Effect = 5,
+};
+
+public enum ClipKind : byte
+{
+  Inset = 0,
+  Geometric = 1,
+};
+
+public enum ShadowKind : byte
+{
+  Drop = 0,
+};
+
+public enum SurfaceKind : byte
+{
+  VisualSurface = 0,
+  LoadedImageFromUri = 1,
+  LoadedImageFromStream = 2,
+};
+
+public enum EffectKind : byte
+{
+  Composite = 0,
+  GaussianBlur = 1,
+};
+
+public enum EasingKind : byte
+{
+  Linear = 0,
+  CubicBezier = 1,
+  Step = 2,
+};
+
+public enum AnimationKind : byte
+{
+  Scalar = 0,
+  Vector2 = 1,
+  Vector3 = 2,
+  Vector4 = 3,
+  Color = 4,
+  Boolean = 5,
+  Path = 6,
+  Expression = 7,
+};
+
+public enum KeyFrameKind : byte
+{
+  Value = 0,
+  Expression = 1,
+};
+
+public enum CanvasGeometryKind : byte
+{
+  Combination = 0,
+  Ellipse = 1,
+  Group = 2,
+  Path = 3,
+  RoundedRectangle = 4,
+  TransformedGeometry = 5,
+};
+
+public enum PathOp : byte
+{
+  BeginFigure = 0,
+  EndFigure = 1,
+  AddLine = 2,
+  AddCubicBezier = 3,
+};
+
+public enum PropertyValueType : byte
+{
+  None = 0,
+  Color = 1,
+  Scalar = 2,
+  Vector2 = 3,
+  Vector3 = 4,
+  Vector4 = 5,
+};
+
+public struct Vec2 : IFlatbufferObject
+{
+  private Struct __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
+  public Vec2 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public float X { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
+  public float Y { get { return __p.bb.GetFloat(__p.bb_pos + 4); } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> CreateVec2(FlatBufferBuilder builder, float X, float Y) {
+    builder.Prep(4, 8);
+    builder.PutFloat(Y);
+    builder.PutFloat(X);
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2>(builder.Offset);
+  }
+}
+
+public struct Vec3 : IFlatbufferObject
+{
+  private Struct __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
+  public Vec3 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public float X { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
+  public float Y { get { return __p.bb.GetFloat(__p.bb_pos + 4); } }
+  public float Z { get { return __p.bb.GetFloat(__p.bb_pos + 8); } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3> CreateVec3(FlatBufferBuilder builder, float X, float Y, float Z) {
+    builder.Prep(4, 12);
+    builder.PutFloat(Z);
+    builder.PutFloat(Y);
+    builder.PutFloat(X);
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3>(builder.Offset);
+  }
+}
+
+public struct Vec4 : IFlatbufferObject
+{
+  private Struct __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
+  public Vec4 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public float X { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
+  public float Y { get { return __p.bb.GetFloat(__p.bb_pos + 4); } }
+  public float Z { get { return __p.bb.GetFloat(__p.bb_pos + 8); } }
+  public float W { get { return __p.bb.GetFloat(__p.bb_pos + 12); } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4> CreateVec4(FlatBufferBuilder builder, float X, float Y, float Z, float W) {
+    builder.Prep(4, 16);
+    builder.PutFloat(W);
+    builder.PutFloat(Z);
+    builder.PutFloat(Y);
+    builder.PutFloat(X);
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4>(builder.Offset);
+  }
+}
+
+public struct Mat3x2 : IFlatbufferObject
+{
+  private Struct __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
+  public Mat3x2 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public float M11 { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
+  public float M12 { get { return __p.bb.GetFloat(__p.bb_pos + 4); } }
+  public float M21 { get { return __p.bb.GetFloat(__p.bb_pos + 8); } }
+  public float M22 { get { return __p.bb.GetFloat(__p.bb_pos + 12); } }
+  public float M31 { get { return __p.bb.GetFloat(__p.bb_pos + 16); } }
+  public float M32 { get { return __p.bb.GetFloat(__p.bb_pos + 20); } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2> CreateMat3x2(FlatBufferBuilder builder, float M11, float M12, float M21, float M22, float M31, float M32) {
+    builder.Prep(4, 24);
+    builder.PutFloat(M32);
+    builder.PutFloat(M31);
+    builder.PutFloat(M22);
+    builder.PutFloat(M21);
+    builder.PutFloat(M12);
+    builder.PutFloat(M11);
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2>(builder.Offset);
+  }
+}
+
+public struct Mat4x4 : IFlatbufferObject
+{
+  private Struct __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
+  public Mat4x4 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public float M11 { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
+  public float M12 { get { return __p.bb.GetFloat(__p.bb_pos + 4); } }
+  public float M13 { get { return __p.bb.GetFloat(__p.bb_pos + 8); } }
+  public float M14 { get { return __p.bb.GetFloat(__p.bb_pos + 12); } }
+  public float M21 { get { return __p.bb.GetFloat(__p.bb_pos + 16); } }
+  public float M22 { get { return __p.bb.GetFloat(__p.bb_pos + 20); } }
+  public float M23 { get { return __p.bb.GetFloat(__p.bb_pos + 24); } }
+  public float M24 { get { return __p.bb.GetFloat(__p.bb_pos + 28); } }
+  public float M31 { get { return __p.bb.GetFloat(__p.bb_pos + 32); } }
+  public float M32 { get { return __p.bb.GetFloat(__p.bb_pos + 36); } }
+  public float M33 { get { return __p.bb.GetFloat(__p.bb_pos + 40); } }
+  public float M34 { get { return __p.bb.GetFloat(__p.bb_pos + 44); } }
+  public float M41 { get { return __p.bb.GetFloat(__p.bb_pos + 48); } }
+  public float M42 { get { return __p.bb.GetFloat(__p.bb_pos + 52); } }
+  public float M43 { get { return __p.bb.GetFloat(__p.bb_pos + 56); } }
+  public float M44 { get { return __p.bb.GetFloat(__p.bb_pos + 60); } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat4x4> CreateMat4x4(FlatBufferBuilder builder, float M11, float M12, float M13, float M14, float M21, float M22, float M23, float M24, float M31, float M32, float M33, float M34, float M41, float M42, float M43, float M44) {
+    builder.Prep(4, 64);
+    builder.PutFloat(M44);
+    builder.PutFloat(M43);
+    builder.PutFloat(M42);
+    builder.PutFloat(M41);
+    builder.PutFloat(M34);
+    builder.PutFloat(M33);
+    builder.PutFloat(M32);
+    builder.PutFloat(M31);
+    builder.PutFloat(M24);
+    builder.PutFloat(M23);
+    builder.PutFloat(M22);
+    builder.PutFloat(M21);
+    builder.PutFloat(M14);
+    builder.PutFloat(M13);
+    builder.PutFloat(M12);
+    builder.PutFloat(M11);
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat4x4>(builder.Offset);
+  }
+}
+
+public struct Color : IFlatbufferObject
+{
+  private Struct __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
+  public Color __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public byte A { get { return __p.bb.Get(__p.bb_pos + 0); } }
+  public byte R { get { return __p.bb.Get(__p.bb_pos + 1); } }
+  public byte G { get { return __p.bb.Get(__p.bb_pos + 2); } }
+  public byte B { get { return __p.bb.Get(__p.bb_pos + 3); } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color> CreateColor(FlatBufferBuilder builder, byte A, byte R, byte G, byte B) {
+    builder.Prep(1, 4);
+    builder.PutByte(B);
+    builder.PutByte(G);
+    builder.PutByte(R);
+    builder.PutByte(A);
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color>(builder.Offset);
+  }
+}
+
+public struct Animator : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Animator GetRootAsAnimator(ByteBuffer _bb) { return GetRootAsAnimator(_bb, new Animator()); }
+  public static Animator GetRootAsAnimator(ByteBuffer _bb, Animator obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Animator __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public uint Property { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public uint Animation { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public uint Controller { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animator> CreateAnimator(FlatBufferBuilder builder,
+      uint property = 0,
+      uint animation = 0,
+      uint controller = 4294967295) {
+    builder.StartTable(3);
+    Animator.AddController(builder, controller);
+    Animator.AddAnimation(builder, animation);
+    Animator.AddProperty(builder, property);
+    return Animator.EndAnimator(builder);
+  }
+
+  public static void StartAnimator(FlatBufferBuilder builder) { builder.StartTable(3); }
+  public static void AddProperty(FlatBufferBuilder builder, uint property) { builder.AddUint(0, property, 0); }
+  public static void AddAnimation(FlatBufferBuilder builder, uint animation) { builder.AddUint(1, animation, 0); }
+  public static void AddController(FlatBufferBuilder builder, uint controller) { builder.AddUint(2, controller, 4294967295); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animator> EndAnimator(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animator>(o);
+  }
+}
+
+
+static public class AnimatorVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Property*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*Animation*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*Controller*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct CompObj : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static CompObj GetRootAsCompObj(ByteBuffer _bb) { return GetRootAsCompObj(_bb, new CompObj()); }
+  public static CompObj GetRootAsCompObj(ByteBuffer _bb, CompObj obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CompObj __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public uint Comment { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animator? Animators(int j) { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animator?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animator()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int AnimatorsLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public uint Properties { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> CreateCompObj(FlatBufferBuilder builder,
+      uint comment = 4294967295,
+      VectorOffset animatorsOffset = default(VectorOffset),
+      uint properties = 4294967295) {
+    builder.StartTable(3);
+    CompObj.AddProperties(builder, properties);
+    CompObj.AddAnimators(builder, animatorsOffset);
+    CompObj.AddComment(builder, comment);
+    return CompObj.EndCompObj(builder);
+  }
+
+  public static void StartCompObj(FlatBufferBuilder builder) { builder.StartTable(3); }
+  public static void AddComment(FlatBufferBuilder builder, uint comment) { builder.AddUint(0, comment, 4294967295); }
+  public static void AddAnimators(FlatBufferBuilder builder, VectorOffset animatorsOffset) { builder.AddOffset(1, animatorsOffset.Value, 0); }
+  public static VectorOffset CreateAnimatorsVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animator>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateAnimatorsVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animator>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateAnimatorsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animator>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateAnimatorsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animator>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartAnimatorsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddProperties(FlatBufferBuilder builder, uint properties) { builder.AddUint(2, properties, 4294967295); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> EndCompObj(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj>(o);
+  }
+}
+
+
+static public class CompObjVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Comment*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyVectorOfTables(tablePos, 6 /*Animators*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.AnimatorVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 8 /*Properties*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct PropertyValue : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static PropertyValue GetRootAsPropertyValue(ByteBuffer _bb) { return GetRootAsPropertyValue(_bb, new PropertyValue()); }
+  public static PropertyValue GetRootAsPropertyValue(ByteBuffer _bb, PropertyValue obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public PropertyValue __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public uint Name { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType Type { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType.None; } }
+  public float Scalar { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4? Vector { get { int o = __p.__offset(10); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color? Color { get { int o = __p.__offset(12); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+
+  public static void StartPropertyValue(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddName(FlatBufferBuilder builder, uint name) { builder.AddUint(0, name, 0); }
+  public static void AddType(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType type) { builder.AddByte(1, (byte)type, 0); }
+  public static void AddScalar(FlatBufferBuilder builder, float scalar) { builder.AddFloat(2, scalar, 0.0f); }
+  public static void AddVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4> vectorOffset) { builder.AddStruct(3, vectorOffset.Value, 0); }
+  public static void AddColor(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color> colorOffset) { builder.AddStruct(4, colorOffset.Value, 0); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValue> EndPropertyValue(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValue>(o);
+  }
+}
+
+
+static public class PropertyValueVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Name*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*Type*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*Scalar*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*Vector*/, 16 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*Color*/, 4 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct ReferenceParameter : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static ReferenceParameter GetRootAsReferenceParameter(ByteBuffer _bb) { return GetRootAsReferenceParameter(_bb, new ReferenceParameter()); }
+  public static ReferenceParameter GetRootAsReferenceParameter(ByteBuffer _bb, ReferenceParameter obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ReferenceParameter __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public uint Name { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public uint Target { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameter> CreateReferenceParameter(FlatBufferBuilder builder,
+      uint name = 0,
+      uint target = 0) {
+    builder.StartTable(2);
+    ReferenceParameter.AddTarget(builder, target);
+    ReferenceParameter.AddName(builder, name);
+    return ReferenceParameter.EndReferenceParameter(builder);
+  }
+
+  public static void StartReferenceParameter(FlatBufferBuilder builder) { builder.StartTable(2); }
+  public static void AddName(FlatBufferBuilder builder, uint name) { builder.AddUint(0, name, 0); }
+  public static void AddTarget(FlatBufferBuilder builder, uint target) { builder.AddUint(1, target, 0); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameter> EndReferenceParameter(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameter>(o);
+  }
+}
+
+
+static public class ReferenceParameterVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Name*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*Target*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct SourceParameter : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static SourceParameter GetRootAsSourceParameter(ByteBuffer _bb) { return GetRootAsSourceParameter(_bb, new SourceParameter()); }
+  public static SourceParameter GetRootAsSourceParameter(ByteBuffer _bb, SourceParameter obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public SourceParameter __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public uint Name { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public uint Brush { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameter> CreateSourceParameter(FlatBufferBuilder builder,
+      uint name = 0,
+      uint brush = 0) {
+    builder.StartTable(2);
+    SourceParameter.AddBrush(builder, brush);
+    SourceParameter.AddName(builder, name);
+    return SourceParameter.EndSourceParameter(builder);
+  }
+
+  public static void StartSourceParameter(FlatBufferBuilder builder) { builder.StartTable(2); }
+  public static void AddName(FlatBufferBuilder builder, uint name) { builder.AddUint(0, name, 0); }
+  public static void AddBrush(FlatBufferBuilder builder, uint brush) { builder.AddUint(1, brush, 0); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameter> EndSourceParameter(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameter>(o);
+  }
+}
+
+
+static public class SourceParameterVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Name*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*Brush*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct KeyFrame : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static KeyFrame GetRootAsKeyFrame(ByteBuffer _bb) { return GetRootAsKeyFrame(_bb, new KeyFrame()); }
+  public static KeyFrame GetRootAsKeyFrame(ByteBuffer _bb, KeyFrame obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public KeyFrame __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public float Progress { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public uint Easing { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrameKind Kind { get { int o = __p.__offset(8); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrameKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrameKind.Value; } }
+  public uint Expression { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public float Scalar { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4? Vector { get { int o = __p.__offset(14); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color? Color { get { int o = __p.__offset(16); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public uint Path { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+
+  public static void StartKeyFrame(FlatBufferBuilder builder) { builder.StartTable(8); }
+  public static void AddProgress(FlatBufferBuilder builder, float progress) { builder.AddFloat(0, progress, 0.0f); }
+  public static void AddEasing(FlatBufferBuilder builder, uint easing) { builder.AddUint(1, easing, 4294967295); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrameKind kind) { builder.AddByte(2, (byte)kind, 0); }
+  public static void AddExpression(FlatBufferBuilder builder, uint expression) { builder.AddUint(3, expression, 4294967295); }
+  public static void AddScalar(FlatBufferBuilder builder, float scalar) { builder.AddFloat(4, scalar, 0.0f); }
+  public static void AddVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4> vectorOffset) { builder.AddStruct(5, vectorOffset.Value, 0); }
+  public static void AddColor(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color> colorOffset) { builder.AddStruct(6, colorOffset.Value, 0); }
+  public static void AddPath(FlatBufferBuilder builder, uint path) { builder.AddUint(7, path, 4294967295); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrame> EndKeyFrame(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrame>(o);
+  }
+}
+
+
+static public class KeyFrameVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Progress*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*Easing*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrameKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 10 /*Expression*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*Scalar*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*Vector*/, 16 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*Color*/, 4 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color*/, 1, false)
+      && verifier.VerifyField(tablePos, 18 /*Path*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Visual : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Visual GetRootAsVisual(ByteBuffer _bb) { return GetRootAsVisual(_bb, new Visual()); }
+  public static Visual GetRootAsVisual(ByteBuffer _bb, Visual obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Visual __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.VisualKind Kind { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.VisualKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.VisualKind.Container; } }
+  public byte? BorderMode { get { int o = __p.__offset(8); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3? CenterPoint { get { int o = __p.__offset(10); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public uint Clip { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public bool? IsVisible { get { int o = __p.__offset(14); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool?)null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3? Offset { get { int o = __p.__offset(16); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public float? Opacity { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public float? RotationAngleInDegrees { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3? RotationAxis { get { int o = __p.__offset(22); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3? Scale { get { int o = __p.__offset(24); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Size { get { int o = __p.__offset(26); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat4x4? TransformMatrix { get { int o = __p.__offset(28); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat4x4?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat4x4()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public uint Children(int j) { int o = __p.__offset(30); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+  public int ChildrenLength { get { int o = __p.__offset(30); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<uint> GetChildrenBytes() { return __p.__vector_as_span<uint>(30, 4); }
+#else
+  public ArraySegment<byte>? GetChildrenBytes() { return __p.__vector_as_arraysegment(30); }
+#endif
+  public uint[] GetChildrenArray() { return __p.__vector_as_array<uint>(30); }
+  public uint Shapes(int j) { int o = __p.__offset(32); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+  public int ShapesLength { get { int o = __p.__offset(32); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<uint> GetShapesBytes() { return __p.__vector_as_span<uint>(32, 4); }
+#else
+  public ArraySegment<byte>? GetShapesBytes() { return __p.__vector_as_arraysegment(32); }
+#endif
+  public uint[] GetShapesArray() { return __p.__vector_as_array<uint>(32); }
+  public uint ViewBox { get { int o = __p.__offset(34); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public uint Brush { get { int o = __p.__offset(36); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public uint Shadow { get { int o = __p.__offset(38); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+
+  public static void StartVisual(FlatBufferBuilder builder) { builder.StartTable(18); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.VisualKind kind) { builder.AddByte(1, (byte)kind, 0); }
+  public static void AddBorderMode(FlatBufferBuilder builder, byte? borderMode) { builder.AddByte(2, borderMode); }
+  public static void AddCenterPoint(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3> centerPointOffset) { builder.AddStruct(3, centerPointOffset.Value, 0); }
+  public static void AddClip(FlatBufferBuilder builder, uint clip) { builder.AddUint(4, clip, 4294967295); }
+  public static void AddIsVisible(FlatBufferBuilder builder, bool? isVisible) { builder.AddBool(5, isVisible); }
+  public static void AddOffset(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3> offsetOffset) { builder.AddStruct(6, offsetOffset.Value, 0); }
+  public static void AddOpacity(FlatBufferBuilder builder, float? opacity) { builder.AddFloat(7, opacity); }
+  public static void AddRotationAngleInDegrees(FlatBufferBuilder builder, float? rotationAngleInDegrees) { builder.AddFloat(8, rotationAngleInDegrees); }
+  public static void AddRotationAxis(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3> rotationAxisOffset) { builder.AddStruct(9, rotationAxisOffset.Value, 0); }
+  public static void AddScale(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3> scaleOffset) { builder.AddStruct(10, scaleOffset.Value, 0); }
+  public static void AddSize(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> sizeOffset) { builder.AddStruct(11, sizeOffset.Value, 0); }
+  public static void AddTransformMatrix(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat4x4> transformMatrixOffset) { builder.AddStruct(12, transformMatrixOffset.Value, 0); }
+  public static void AddChildren(FlatBufferBuilder builder, VectorOffset childrenOffset) { builder.AddOffset(13, childrenOffset.Value, 0); }
+  public static VectorOffset CreateChildrenVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateChildrenVectorBlock(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateChildrenVectorBlock(FlatBufferBuilder builder, ArraySegment<uint> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateChildrenVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<uint>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartChildrenVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddShapes(FlatBufferBuilder builder, VectorOffset shapesOffset) { builder.AddOffset(14, shapesOffset.Value, 0); }
+  public static VectorOffset CreateShapesVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateShapesVectorBlock(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapesVectorBlock(FlatBufferBuilder builder, ArraySegment<uint> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<uint>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartShapesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddViewBox(FlatBufferBuilder builder, uint viewBox) { builder.AddUint(15, viewBox, 4294967295); }
+  public static void AddBrush(FlatBufferBuilder builder, uint brush) { builder.AddUint(16, brush, 4294967295); }
+  public static void AddShadow(FlatBufferBuilder builder, uint shadow) { builder.AddUint(17, shadow, 4294967295); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Visual> EndVisual(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Visual>(o);
+  }
+}
+
+
+static public class VisualVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.VisualKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*BorderMode*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 10 /*CenterPoint*/, 12 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*Clip*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*IsVisible*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 16 /*Offset*/, 12 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*Opacity*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 20 /*RotationAngleInDegrees*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 22 /*RotationAxis*/, 12 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3*/, 4, false)
+      && verifier.VerifyField(tablePos, 24 /*Scale*/, 12 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3*/, 4, false)
+      && verifier.VerifyField(tablePos, 26 /*Size*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 28 /*TransformMatrix*/, 64 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat4x4*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 30 /*Children*/, 4 /*uint*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 32 /*Shapes*/, 4 /*uint*/, false)
+      && verifier.VerifyField(tablePos, 34 /*ViewBox*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 36 /*Brush*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 38 /*Shadow*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Shape : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Shape GetRootAsShape(ByteBuffer _bb) { return GetRootAsShape(_bb, new Shape()); }
+  public static Shape GetRootAsShape(ByteBuffer _bb, Shape obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Shape __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShapeKind Kind { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShapeKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShapeKind.Container; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? CenterPoint { get { int o = __p.__offset(8); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Offset { get { int o = __p.__offset(10); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public float? RotationAngleInDegrees { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Scale { get { int o = __p.__offset(14); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2? TransformMatrix { get { int o = __p.__offset(16); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public uint Shapes(int j) { int o = __p.__offset(18); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+  public int ShapesLength { get { int o = __p.__offset(18); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<uint> GetShapesBytes() { return __p.__vector_as_span<uint>(18, 4); }
+#else
+  public ArraySegment<byte>? GetShapesBytes() { return __p.__vector_as_arraysegment(18); }
+#endif
+  public uint[] GetShapesArray() { return __p.__vector_as_array<uint>(18); }
+  public uint FillBrush { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public uint StrokeBrush { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public uint Geometry { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public bool? IsStrokeNonScaling { get { int o = __p.__offset(26); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool?)null; } }
+  public float? StrokeDashOffset { get { int o = __p.__offset(28); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public float StrokeDashArray(int j) { int o = __p.__offset(30); return o != 0 ? __p.bb.GetFloat(__p.__vector(o) + j * 4) : (float)0; }
+  public int StrokeDashArrayLength { get { int o = __p.__offset(30); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<float> GetStrokeDashArrayBytes() { return __p.__vector_as_span<float>(30, 4); }
+#else
+  public ArraySegment<byte>? GetStrokeDashArrayBytes() { return __p.__vector_as_arraysegment(30); }
+#endif
+  public float[] GetStrokeDashArrayArray() { return __p.__vector_as_array<float>(30); }
+  public byte? StrokeDashCap { get { int o = __p.__offset(32); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
+  public byte? StrokeStartCap { get { int o = __p.__offset(34); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
+  public byte? StrokeEndCap { get { int o = __p.__offset(36); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
+  public byte? StrokeLineJoin { get { int o = __p.__offset(38); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
+  public float? StrokeMiterLimit { get { int o = __p.__offset(40); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public float? StrokeThickness { get { int o = __p.__offset(42); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+
+  public static void StartShape(FlatBufferBuilder builder) { builder.StartTable(20); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShapeKind kind) { builder.AddByte(1, (byte)kind, 0); }
+  public static void AddCenterPoint(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> centerPointOffset) { builder.AddStruct(2, centerPointOffset.Value, 0); }
+  public static void AddOffset(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> offsetOffset) { builder.AddStruct(3, offsetOffset.Value, 0); }
+  public static void AddRotationAngleInDegrees(FlatBufferBuilder builder, float? rotationAngleInDegrees) { builder.AddFloat(4, rotationAngleInDegrees); }
+  public static void AddScale(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> scaleOffset) { builder.AddStruct(5, scaleOffset.Value, 0); }
+  public static void AddTransformMatrix(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2> transformMatrixOffset) { builder.AddStruct(6, transformMatrixOffset.Value, 0); }
+  public static void AddShapes(FlatBufferBuilder builder, VectorOffset shapesOffset) { builder.AddOffset(7, shapesOffset.Value, 0); }
+  public static VectorOffset CreateShapesVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateShapesVectorBlock(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapesVectorBlock(FlatBufferBuilder builder, ArraySegment<uint> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<uint>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartShapesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddFillBrush(FlatBufferBuilder builder, uint fillBrush) { builder.AddUint(8, fillBrush, 4294967295); }
+  public static void AddStrokeBrush(FlatBufferBuilder builder, uint strokeBrush) { builder.AddUint(9, strokeBrush, 4294967295); }
+  public static void AddGeometry(FlatBufferBuilder builder, uint geometry) { builder.AddUint(10, geometry, 4294967295); }
+  public static void AddIsStrokeNonScaling(FlatBufferBuilder builder, bool? isStrokeNonScaling) { builder.AddBool(11, isStrokeNonScaling); }
+  public static void AddStrokeDashOffset(FlatBufferBuilder builder, float? strokeDashOffset) { builder.AddFloat(12, strokeDashOffset); }
+  public static void AddStrokeDashArray(FlatBufferBuilder builder, VectorOffset strokeDashArrayOffset) { builder.AddOffset(13, strokeDashArrayOffset.Value, 0); }
+  public static VectorOffset CreateStrokeDashArrayVector(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddFloat(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateStrokeDashArrayVectorBlock(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStrokeDashArrayVectorBlock(FlatBufferBuilder builder, ArraySegment<float> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStrokeDashArrayVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<float>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartStrokeDashArrayVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddStrokeDashCap(FlatBufferBuilder builder, byte? strokeDashCap) { builder.AddByte(14, strokeDashCap); }
+  public static void AddStrokeStartCap(FlatBufferBuilder builder, byte? strokeStartCap) { builder.AddByte(15, strokeStartCap); }
+  public static void AddStrokeEndCap(FlatBufferBuilder builder, byte? strokeEndCap) { builder.AddByte(16, strokeEndCap); }
+  public static void AddStrokeLineJoin(FlatBufferBuilder builder, byte? strokeLineJoin) { builder.AddByte(17, strokeLineJoin); }
+  public static void AddStrokeMiterLimit(FlatBufferBuilder builder, float? strokeMiterLimit) { builder.AddFloat(18, strokeMiterLimit); }
+  public static void AddStrokeThickness(FlatBufferBuilder builder, float? strokeThickness) { builder.AddFloat(19, strokeThickness); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shape> EndShape(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shape>(o);
+  }
+}
+
+
+static public class ShapeVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShapeKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*CenterPoint*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*Offset*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*RotationAngleInDegrees*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*Scale*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*TransformMatrix*/, 24 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 18 /*Shapes*/, 4 /*uint*/, false)
+      && verifier.VerifyField(tablePos, 20 /*FillBrush*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 22 /*StrokeBrush*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 24 /*Geometry*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 26 /*IsStrokeNonScaling*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 28 /*StrokeDashOffset*/, 4 /*float*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 30 /*StrokeDashArray*/, 4 /*float*/, false)
+      && verifier.VerifyField(tablePos, 32 /*StrokeDashCap*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 34 /*StrokeStartCap*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 36 /*StrokeEndCap*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 38 /*StrokeLineJoin*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 40 /*StrokeMiterLimit*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 42 /*StrokeThickness*/, 4 /*float*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Geometry : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Geometry GetRootAsGeometry(ByteBuffer _bb) { return GetRootAsGeometry(_bb, new Geometry()); }
+  public static Geometry GetRootAsGeometry(ByteBuffer _bb, Geometry obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Geometry __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GeometryKind Kind { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GeometryKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GeometryKind.Path; } }
+  public float? TrimStart { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public float? TrimEnd { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public float? TrimOffset { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public uint Path { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Offset { get { int o = __p.__offset(16); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Size { get { int o = __p.__offset(18); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? CornerRadius { get { int o = __p.__offset(20); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Center { get { int o = __p.__offset(22); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Radius { get { int o = __p.__offset(24); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+
+  public static void StartGeometry(FlatBufferBuilder builder) { builder.StartTable(11); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GeometryKind kind) { builder.AddByte(1, (byte)kind, 0); }
+  public static void AddTrimStart(FlatBufferBuilder builder, float? trimStart) { builder.AddFloat(2, trimStart); }
+  public static void AddTrimEnd(FlatBufferBuilder builder, float? trimEnd) { builder.AddFloat(3, trimEnd); }
+  public static void AddTrimOffset(FlatBufferBuilder builder, float? trimOffset) { builder.AddFloat(4, trimOffset); }
+  public static void AddPath(FlatBufferBuilder builder, uint path) { builder.AddUint(5, path, 4294967295); }
+  public static void AddOffset(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> offsetOffset) { builder.AddStruct(6, offsetOffset.Value, 0); }
+  public static void AddSize(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> sizeOffset) { builder.AddStruct(7, sizeOffset.Value, 0); }
+  public static void AddCornerRadius(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> cornerRadiusOffset) { builder.AddStruct(8, cornerRadiusOffset.Value, 0); }
+  public static void AddCenter(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> centerOffset) { builder.AddStruct(9, centerOffset.Value, 0); }
+  public static void AddRadius(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> radiusOffset) { builder.AddStruct(10, radiusOffset.Value, 0); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Geometry> EndGeometry(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Geometry>(o);
+  }
+}
+
+
+static public class GeometryVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GeometryKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*TrimStart*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*TrimEnd*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*TrimOffset*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*Path*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*Offset*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*Size*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 20 /*CornerRadius*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 22 /*Center*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 24 /*Radius*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Brush : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Brush GetRootAsBrush(ByteBuffer _bb) { return GetRootAsBrush(_bb, new Brush()); }
+  public static Brush GetRootAsBrush(ByteBuffer _bb, Brush obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Brush __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.BrushKind Kind { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.BrushKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.BrushKind.Color; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color? Color { get { int o = __p.__offset(8); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? AnchorPoint { get { int o = __p.__offset(10); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? CenterPoint { get { int o = __p.__offset(12); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public uint ColorStops(int j) { int o = __p.__offset(14); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+  public int ColorStopsLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<uint> GetColorStopsBytes() { return __p.__vector_as_span<uint>(14, 4); }
+#else
+  public ArraySegment<byte>? GetColorStopsBytes() { return __p.__vector_as_arraysegment(14); }
+#endif
+  public uint[] GetColorStopsArray() { return __p.__vector_as_array<uint>(14); }
+  public byte? ExtendMode { get { int o = __p.__offset(16); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
+  public byte? InterpolationSpace { get { int o = __p.__offset(18); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
+  public byte? MappingMode { get { int o = __p.__offset(20); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Offset { get { int o = __p.__offset(22); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public float? RotationAngleInDegrees { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Scale { get { int o = __p.__offset(26); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2? TransformMatrix { get { int o = __p.__offset(28); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? StartPoint { get { int o = __p.__offset(30); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? EndPoint { get { int o = __p.__offset(32); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? EllipseCenter { get { int o = __p.__offset(34); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? EllipseRadius { get { int o = __p.__offset(36); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? GradientOriginOffset { get { int o = __p.__offset(38); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public uint Surface { get { int o = __p.__offset(40); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public uint Source { get { int o = __p.__offset(42); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public uint Mask { get { int o = __p.__offset(44); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public uint Effect { get { int o = __p.__offset(46); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameter? SourceParameters(int j) { int o = __p.__offset(48); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameter?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameter()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int SourceParametersLength { get { int o = __p.__offset(48); return o != 0 ? __p.__vector_len(o) : 0; } }
+
+  public static void StartBrush(FlatBufferBuilder builder) { builder.StartTable(23); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.BrushKind kind) { builder.AddByte(1, (byte)kind, 0); }
+  public static void AddColor(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color> colorOffset) { builder.AddStruct(2, colorOffset.Value, 0); }
+  public static void AddAnchorPoint(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> anchorPointOffset) { builder.AddStruct(3, anchorPointOffset.Value, 0); }
+  public static void AddCenterPoint(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> centerPointOffset) { builder.AddStruct(4, centerPointOffset.Value, 0); }
+  public static void AddColorStops(FlatBufferBuilder builder, VectorOffset colorStopsOffset) { builder.AddOffset(5, colorStopsOffset.Value, 0); }
+  public static VectorOffset CreateColorStopsVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateColorStopsVectorBlock(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateColorStopsVectorBlock(FlatBufferBuilder builder, ArraySegment<uint> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateColorStopsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<uint>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartColorStopsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddExtendMode(FlatBufferBuilder builder, byte? extendMode) { builder.AddByte(6, extendMode); }
+  public static void AddInterpolationSpace(FlatBufferBuilder builder, byte? interpolationSpace) { builder.AddByte(7, interpolationSpace); }
+  public static void AddMappingMode(FlatBufferBuilder builder, byte? mappingMode) { builder.AddByte(8, mappingMode); }
+  public static void AddOffset(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> offsetOffset) { builder.AddStruct(9, offsetOffset.Value, 0); }
+  public static void AddRotationAngleInDegrees(FlatBufferBuilder builder, float? rotationAngleInDegrees) { builder.AddFloat(10, rotationAngleInDegrees); }
+  public static void AddScale(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> scaleOffset) { builder.AddStruct(11, scaleOffset.Value, 0); }
+  public static void AddTransformMatrix(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2> transformMatrixOffset) { builder.AddStruct(12, transformMatrixOffset.Value, 0); }
+  public static void AddStartPoint(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> startPointOffset) { builder.AddStruct(13, startPointOffset.Value, 0); }
+  public static void AddEndPoint(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> endPointOffset) { builder.AddStruct(14, endPointOffset.Value, 0); }
+  public static void AddEllipseCenter(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> ellipseCenterOffset) { builder.AddStruct(15, ellipseCenterOffset.Value, 0); }
+  public static void AddEllipseRadius(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> ellipseRadiusOffset) { builder.AddStruct(16, ellipseRadiusOffset.Value, 0); }
+  public static void AddGradientOriginOffset(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> gradientOriginOffsetOffset) { builder.AddStruct(17, gradientOriginOffsetOffset.Value, 0); }
+  public static void AddSurface(FlatBufferBuilder builder, uint surface) { builder.AddUint(18, surface, 4294967295); }
+  public static void AddSource(FlatBufferBuilder builder, uint source) { builder.AddUint(19, source, 4294967295); }
+  public static void AddMask(FlatBufferBuilder builder, uint mask) { builder.AddUint(20, mask, 4294967295); }
+  public static void AddEffect(FlatBufferBuilder builder, uint effect) { builder.AddUint(21, effect, 4294967295); }
+  public static void AddSourceParameters(FlatBufferBuilder builder, VectorOffset sourceParametersOffset) { builder.AddOffset(22, sourceParametersOffset.Value, 0); }
+  public static VectorOffset CreateSourceParametersVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameter>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateSourceParametersVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameter>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateSourceParametersVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameter>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateSourceParametersVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameter>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartSourceParametersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Brush> EndBrush(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Brush>(o);
+  }
+}
+
+
+static public class BrushVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.BrushKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*Color*/, 4 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color*/, 1, false)
+      && verifier.VerifyField(tablePos, 10 /*AnchorPoint*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*CenterPoint*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 14 /*ColorStops*/, 4 /*uint*/, false)
+      && verifier.VerifyField(tablePos, 16 /*ExtendMode*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 18 /*InterpolationSpace*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 20 /*MappingMode*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 22 /*Offset*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 24 /*RotationAngleInDegrees*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 26 /*Scale*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 28 /*TransformMatrix*/, 24 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2*/, 4, false)
+      && verifier.VerifyField(tablePos, 30 /*StartPoint*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 32 /*EndPoint*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 34 /*EllipseCenter*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 36 /*EllipseRadius*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 38 /*GradientOriginOffset*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 40 /*Surface*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 42 /*Source*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 44 /*Mask*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 46 /*Effect*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyVectorOfTables(tablePos, 48 /*SourceParameters*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SourceParameterVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct GradientStop : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static GradientStop GetRootAsGradientStop(ByteBuffer _bb) { return GetRootAsGradientStop(_bb, new GradientStop()); }
+  public static GradientStop GetRootAsGradientStop(ByteBuffer _bb, GradientStop obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public GradientStop __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color? Color { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public float Offset { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+
+  public static void StartGradientStop(FlatBufferBuilder builder) { builder.StartTable(3); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddColor(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color> colorOffset) { builder.AddStruct(1, colorOffset.Value, 0); }
+  public static void AddOffset(FlatBufferBuilder builder, float offset) { builder.AddFloat(2, offset, 0.0f); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GradientStop> EndGradientStop(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GradientStop>(o);
+  }
+}
+
+
+static public class GradientStopVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Color*/, 4 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*Offset*/, 4 /*float*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct ViewBox : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static ViewBox GetRootAsViewBox(ByteBuffer _bb) { return GetRootAsViewBox(_bb, new ViewBox()); }
+  public static ViewBox GetRootAsViewBox(ByteBuffer _bb, ViewBox obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ViewBox __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Size { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+
+  public static void StartViewBox(FlatBufferBuilder builder) { builder.StartTable(2); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddSize(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> sizeOffset) { builder.AddStruct(1, sizeOffset.Value, 0); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ViewBox> EndViewBox(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ViewBox>(o);
+  }
+}
+
+
+static public class ViewBoxVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Size*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Clip : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Clip GetRootAsClip(ByteBuffer _bb) { return GetRootAsClip(_bb, new Clip()); }
+  public static Clip GetRootAsClip(ByteBuffer _bb, Clip obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Clip __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ClipKind Kind { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ClipKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ClipKind.Inset; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? CenterPoint { get { int o = __p.__offset(8); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? Scale { get { int o = __p.__offset(10); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public float? LeftInset { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public float? RightInset { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public float? TopInset { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public float? BottomInset { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public uint Geometry { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+
+  public static void StartClip(FlatBufferBuilder builder) { builder.StartTable(9); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ClipKind kind) { builder.AddByte(1, (byte)kind, 0); }
+  public static void AddCenterPoint(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> centerPointOffset) { builder.AddStruct(2, centerPointOffset.Value, 0); }
+  public static void AddScale(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> scaleOffset) { builder.AddStruct(3, scaleOffset.Value, 0); }
+  public static void AddLeftInset(FlatBufferBuilder builder, float? leftInset) { builder.AddFloat(4, leftInset); }
+  public static void AddRightInset(FlatBufferBuilder builder, float? rightInset) { builder.AddFloat(5, rightInset); }
+  public static void AddTopInset(FlatBufferBuilder builder, float? topInset) { builder.AddFloat(6, topInset); }
+  public static void AddBottomInset(FlatBufferBuilder builder, float? bottomInset) { builder.AddFloat(7, bottomInset); }
+  public static void AddGeometry(FlatBufferBuilder builder, uint geometry) { builder.AddUint(8, geometry, 4294967295); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Clip> EndClip(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Clip>(o);
+  }
+}
+
+
+static public class ClipVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ClipKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*CenterPoint*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*Scale*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*LeftInset*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*RightInset*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*TopInset*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*BottomInset*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 20 /*Geometry*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Shadow : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Shadow GetRootAsShadow(ByteBuffer _bb) { return GetRootAsShadow(_bb, new Shadow()); }
+  public static Shadow GetRootAsShadow(ByteBuffer _bb, Shadow obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Shadow __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShadowKind Kind { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShadowKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShadowKind.Drop; } }
+  public float? BlurRadius { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color? Color { get { int o = __p.__offset(10); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public uint Mask { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3? Offset { get { int o = __p.__offset(14); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public float? Opacity { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
+  public byte? SourcePolicy { get { int o = __p.__offset(18); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
+
+  public static void StartShadow(FlatBufferBuilder builder) { builder.StartTable(8); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShadowKind kind) { builder.AddByte(1, (byte)kind, 0); }
+  public static void AddBlurRadius(FlatBufferBuilder builder, float? blurRadius) { builder.AddFloat(2, blurRadius); }
+  public static void AddColor(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color> colorOffset) { builder.AddStruct(3, colorOffset.Value, 0); }
+  public static void AddMask(FlatBufferBuilder builder, uint mask) { builder.AddUint(4, mask, 4294967295); }
+  public static void AddOffset(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3> offsetOffset) { builder.AddStruct(5, offsetOffset.Value, 0); }
+  public static void AddOpacity(FlatBufferBuilder builder, float? opacity) { builder.AddFloat(6, opacity); }
+  public static void AddSourcePolicy(FlatBufferBuilder builder, byte? sourcePolicy) { builder.AddByte(7, sourcePolicy); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shadow> EndShadow(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shadow>(o);
+  }
+}
+
+
+static public class ShadowVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShadowKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*BlurRadius*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*Color*/, 4 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color*/, 1, false)
+      && verifier.VerifyField(tablePos, 12 /*Mask*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*Offset*/, 12 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec3*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*Opacity*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*SourcePolicy*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Surface : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Surface GetRootAsSurface(ByteBuffer _bb) { return GetRootAsSurface(_bb, new Surface()); }
+  public static Surface GetRootAsSurface(ByteBuffer _bb, Surface obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Surface __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SurfaceKind Kind { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SurfaceKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SurfaceKind.VisualSurface; } }
+  public uint SourceVisual { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? SourceSize { get { int o = __p.__offset(10); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? SourceOffset { get { int o = __p.__offset(12); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public uint Uri { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public byte Bytes(int j) { int o = __p.__offset(16); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; }
+  public int BytesLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetBytesBytes() { return __p.__vector_as_span<byte>(16, 1); }
+#else
+  public ArraySegment<byte>? GetBytesBytes() { return __p.__vector_as_arraysegment(16); }
+#endif
+  public byte[] GetBytesArray() { return __p.__vector_as_array<byte>(16); }
+
+  public static void StartSurface(FlatBufferBuilder builder) { builder.StartTable(7); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SurfaceKind kind) { builder.AddByte(1, (byte)kind, 0); }
+  public static void AddSourceVisual(FlatBufferBuilder builder, uint sourceVisual) { builder.AddUint(2, sourceVisual, 4294967295); }
+  public static void AddSourceSize(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> sourceSizeOffset) { builder.AddStruct(3, sourceSizeOffset.Value, 0); }
+  public static void AddSourceOffset(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> sourceOffsetOffset) { builder.AddStruct(4, sourceOffsetOffset.Value, 0); }
+  public static void AddUri(FlatBufferBuilder builder, uint uri) { builder.AddUint(5, uri, 4294967295); }
+  public static void AddBytes(FlatBufferBuilder builder, VectorOffset bytesOffset) { builder.AddOffset(6, bytesOffset.Value, 0); }
+  public static VectorOffset CreateBytesVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateBytesVectorBlock(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateBytesVectorBlock(FlatBufferBuilder builder, ArraySegment<byte> data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateBytesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<byte>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartBytesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Surface> EndSurface(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Surface>(o);
+  }
+}
+
+
+static public class SurfaceVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SurfaceKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*SourceVisual*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*SourceSize*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*SourceOffset*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*Uri*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 16 /*Bytes*/, 1 /*byte*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Effect : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Effect GetRootAsEffect(ByteBuffer _bb) { return GetRootAsEffect(_bb, new Effect()); }
+  public static Effect GetRootAsEffect(ByteBuffer _bb, Effect obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Effect __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EffectKind Kind { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EffectKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EffectKind.Composite; } }
+  public uint Sources(int j) { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+  public int SourcesLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<uint> GetSourcesBytes() { return __p.__vector_as_span<uint>(8, 4); }
+#else
+  public ArraySegment<byte>? GetSourcesBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public uint[] GetSourcesArray() { return __p.__vector_as_array<uint>(8); }
+  public byte Mode { get { int o = __p.__offset(10); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
+  public float BlurAmount { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Effect> CreateEffect(FlatBufferBuilder builder,
+      Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> @baseOffset = default(Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj>),
+      CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EffectKind kind = CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EffectKind.Composite,
+      VectorOffset sourcesOffset = default(VectorOffset),
+      byte mode = 0,
+      float blur_amount = 0.0f) {
+    builder.StartTable(5);
+    Effect.AddBlurAmount(builder, blur_amount);
+    Effect.AddSources(builder, sourcesOffset);
+    Effect.AddBase(builder, @baseOffset);
+    Effect.AddMode(builder, mode);
+    Effect.AddKind(builder, kind);
+    return Effect.EndEffect(builder);
+  }
+
+  public static void StartEffect(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EffectKind kind) { builder.AddByte(1, (byte)kind, 0); }
+  public static void AddSources(FlatBufferBuilder builder, VectorOffset sourcesOffset) { builder.AddOffset(2, sourcesOffset.Value, 0); }
+  public static VectorOffset CreateSourcesVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateSourcesVectorBlock(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateSourcesVectorBlock(FlatBufferBuilder builder, ArraySegment<uint> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateSourcesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<uint>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartSourcesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddMode(FlatBufferBuilder builder, byte mode) { builder.AddByte(3, mode, 0); }
+  public static void AddBlurAmount(FlatBufferBuilder builder, float blurAmount) { builder.AddFloat(4, blurAmount, 0.0f); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Effect> EndEffect(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Effect>(o);
+  }
+}
+
+
+static public class EffectVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EffectKind*/, 1, false)
+      && verifier.VerifyVectorOfData(tablePos, 8 /*Sources*/, 4 /*uint*/, false)
+      && verifier.VerifyField(tablePos, 10 /*Mode*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 12 /*BlurAmount*/, 4 /*float*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Easing : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Easing GetRootAsEasing(ByteBuffer _bb) { return GetRootAsEasing(_bb, new Easing()); }
+  public static Easing GetRootAsEasing(ByteBuffer _bb, Easing obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Easing __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EasingKind Kind { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EasingKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EasingKind.Linear; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? ControlPoint1 { get { int o = __p.__offset(8); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2? ControlPoint2 { get { int o = __p.__offset(10); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public int? StepCount { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int?)null; } }
+  public int? InitialStep { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int?)null; } }
+  public int? FinalStep { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int?)null; } }
+  public bool? IsInitialStepSingleFrame { get { int o = __p.__offset(18); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool?)null; } }
+  public bool? IsFinalStepSingleFrame { get { int o = __p.__offset(20); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool?)null; } }
+
+  public static void StartEasing(FlatBufferBuilder builder) { builder.StartTable(9); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EasingKind kind) { builder.AddByte(1, (byte)kind, 0); }
+  public static void AddControlPoint1(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> controlPoint1Offset) { builder.AddStruct(2, controlPoint1Offset.Value, 0); }
+  public static void AddControlPoint2(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2> controlPoint2Offset) { builder.AddStruct(3, controlPoint2Offset.Value, 0); }
+  public static void AddStepCount(FlatBufferBuilder builder, int? stepCount) { builder.AddInt(4, stepCount); }
+  public static void AddInitialStep(FlatBufferBuilder builder, int? initialStep) { builder.AddInt(5, initialStep); }
+  public static void AddFinalStep(FlatBufferBuilder builder, int? finalStep) { builder.AddInt(6, finalStep); }
+  public static void AddIsInitialStepSingleFrame(FlatBufferBuilder builder, bool? isInitialStepSingleFrame) { builder.AddBool(7, isInitialStepSingleFrame); }
+  public static void AddIsFinalStepSingleFrame(FlatBufferBuilder builder, bool? isFinalStepSingleFrame) { builder.AddBool(8, isFinalStepSingleFrame); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Easing> EndEasing(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Easing>(o);
+  }
+}
+
+
+static public class EasingVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EasingKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*ControlPoint1*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*ControlPoint2*/, 8 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec2*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*StepCount*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*InitialStep*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*FinalStep*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*IsInitialStepSingleFrame*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 20 /*IsFinalStepSingleFrame*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Animation : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Animation GetRootAsAnimation(ByteBuffer _bb) { return GetRootAsAnimation(_bb, new Animation()); }
+  public static Animation GetRootAsAnimation(ByteBuffer _bb, Animation obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Animation __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.AnimationKind Kind { get { int o = __p.__offset(6); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.AnimationKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.AnimationKind.Scalar; } }
+  public uint Target { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameter? ReferenceParameters(int j) { int o = __p.__offset(10); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameter?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameter()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int ReferenceParametersLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public uint Expression { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public long DurationTicks { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrame? KeyFrames(int j) { int o = __p.__offset(16); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrame?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrame()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int KeyFramesLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public byte? InterpolationColorSpace { get { int o = __p.__offset(18); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animation> CreateAnimation(FlatBufferBuilder builder,
+      Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> @baseOffset = default(Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj>),
+      CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.AnimationKind kind = CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.AnimationKind.Scalar,
+      uint target = 4294967295,
+      VectorOffset reference_parametersOffset = default(VectorOffset),
+      uint expression = 4294967295,
+      long duration_ticks = 0,
+      VectorOffset key_framesOffset = default(VectorOffset),
+      byte? interpolation_color_space = null) {
+    builder.StartTable(8);
+    Animation.AddDurationTicks(builder, duration_ticks);
+    Animation.AddKeyFrames(builder, key_framesOffset);
+    Animation.AddExpression(builder, expression);
+    Animation.AddReferenceParameters(builder, reference_parametersOffset);
+    Animation.AddTarget(builder, target);
+    Animation.AddBase(builder, @baseOffset);
+    Animation.AddInterpolationColorSpace(builder, interpolation_color_space);
+    Animation.AddKind(builder, kind);
+    return Animation.EndAnimation(builder);
+  }
+
+  public static void StartAnimation(FlatBufferBuilder builder) { builder.StartTable(8); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.AnimationKind kind) { builder.AddByte(1, (byte)kind, 0); }
+  public static void AddTarget(FlatBufferBuilder builder, uint target) { builder.AddUint(2, target, 4294967295); }
+  public static void AddReferenceParameters(FlatBufferBuilder builder, VectorOffset referenceParametersOffset) { builder.AddOffset(3, referenceParametersOffset.Value, 0); }
+  public static VectorOffset CreateReferenceParametersVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameter>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateReferenceParametersVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameter>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateReferenceParametersVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameter>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateReferenceParametersVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameter>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartReferenceParametersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddExpression(FlatBufferBuilder builder, uint expression) { builder.AddUint(4, expression, 4294967295); }
+  public static void AddDurationTicks(FlatBufferBuilder builder, long durationTicks) { builder.AddLong(5, durationTicks, 0); }
+  public static void AddKeyFrames(FlatBufferBuilder builder, VectorOffset keyFramesOffset) { builder.AddOffset(6, keyFramesOffset.Value, 0); }
+  public static VectorOffset CreateKeyFramesVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrame>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateKeyFramesVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrame>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateKeyFramesVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrame>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateKeyFramesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrame>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartKeyFramesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddInterpolationColorSpace(FlatBufferBuilder builder, byte? interpolationColorSpace) { builder.AddByte(7, interpolationColorSpace); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animation> EndAnimation(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animation>(o);
+  }
+}
+
+
+static public class AnimationVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.AnimationKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*Target*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyVectorOfTables(tablePos, 10 /*ReferenceParameters*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ReferenceParameterVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 12 /*Expression*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*DurationTicks*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfTables(tablePos, 16 /*KeyFrames*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.KeyFrameVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 18 /*InterpolationColorSpace*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct PropertySet : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static PropertySet GetRootAsPropertySet(ByteBuffer _bb) { return GetRootAsPropertySet(_bb, new PropertySet()); }
+  public static PropertySet GetRootAsPropertySet(ByteBuffer _bb, PropertySet obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public PropertySet __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public uint Owner { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValue? Values(int j) { int o = __p.__offset(8); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValue?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValue()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int ValuesLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySet> CreatePropertySet(FlatBufferBuilder builder,
+      Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> @baseOffset = default(Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj>),
+      uint owner = 4294967295,
+      VectorOffset valuesOffset = default(VectorOffset)) {
+    builder.StartTable(3);
+    PropertySet.AddValues(builder, valuesOffset);
+    PropertySet.AddOwner(builder, owner);
+    PropertySet.AddBase(builder, @baseOffset);
+    return PropertySet.EndPropertySet(builder);
+  }
+
+  public static void StartPropertySet(FlatBufferBuilder builder) { builder.StartTable(3); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddOwner(FlatBufferBuilder builder, uint owner) { builder.AddUint(1, owner, 4294967295); }
+  public static void AddValues(FlatBufferBuilder builder, VectorOffset valuesOffset) { builder.AddOffset(2, valuesOffset.Value, 0); }
+  public static VectorOffset CreateValuesVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValue>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateValuesVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValue>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateValuesVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValue>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateValuesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValue>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartValuesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySet> EndPropertySet(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySet>(o);
+  }
+}
+
+
+static public class PropertySetVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*Owner*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyVectorOfTables(tablePos, 8 /*Values*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Controller : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Controller GetRootAsController(ByteBuffer _bb) { return GetRootAsController(_bb, new Controller()); }
+  public static Controller GetRootAsController(ByteBuffer _bb, Controller obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Controller __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj? Base { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public uint TargetObject { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public uint TargetProperty { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public bool IsPaused { get { int o = __p.__offset(10); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public bool IsCustom { get { int o = __p.__offset(12); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Controller> CreateController(FlatBufferBuilder builder,
+      Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> @baseOffset = default(Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj>),
+      uint target_object = 4294967295,
+      uint target_property = 4294967295,
+      bool is_paused = false,
+      bool is_custom = false) {
+    builder.StartTable(5);
+    Controller.AddTargetProperty(builder, target_property);
+    Controller.AddTargetObject(builder, target_object);
+    Controller.AddBase(builder, @baseOffset);
+    Controller.AddIsCustom(builder, is_custom);
+    Controller.AddIsPaused(builder, is_paused);
+    return Controller.EndController(builder);
+  }
+
+  public static void StartController(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddBase(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObj> baseOffset) { builder.AddOffset(0, baseOffset.Value, 0); }
+  public static void AddTargetObject(FlatBufferBuilder builder, uint targetObject) { builder.AddUint(1, targetObject, 4294967295); }
+  public static void AddTargetProperty(FlatBufferBuilder builder, uint targetProperty) { builder.AddUint(2, targetProperty, 4294967295); }
+  public static void AddIsPaused(FlatBufferBuilder builder, bool isPaused) { builder.AddBool(3, isPaused, false); }
+  public static void AddIsCustom(FlatBufferBuilder builder, bool isCustom) { builder.AddBool(4, isCustom, false); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Controller> EndController(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Controller>(o);
+  }
+}
+
+
+static public class ControllerVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*Base*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CompObjVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 6 /*TargetObject*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*TargetProperty*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*IsPaused*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 12 /*IsCustom*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct PropertyBinding : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static PropertyBinding GetRootAsPropertyBinding(ByteBuffer _bb) { return GetRootAsPropertyBinding(_bb, new PropertyBinding()); }
+  public static PropertyBinding GetRootAsPropertyBinding(ByteBuffer _bb, PropertyBinding obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public PropertyBinding __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public uint Name { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public uint DisplayName { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType ActualType { get { int o = __p.__offset(8); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType.None; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType ExposedType { get { int o = __p.__offset(10); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType.None; } }
+  public float DefaultScalar { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4? DefaultVector { get { int o = __p.__offset(14); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color? DefaultColor { get { int o = __p.__offset(16); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+
+  public static void StartPropertyBinding(FlatBufferBuilder builder) { builder.StartTable(7); }
+  public static void AddName(FlatBufferBuilder builder, uint name) { builder.AddUint(0, name, 0); }
+  public static void AddDisplayName(FlatBufferBuilder builder, uint displayName) { builder.AddUint(1, displayName, 0); }
+  public static void AddActualType(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType actualType) { builder.AddByte(2, (byte)actualType, 0); }
+  public static void AddExposedType(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType exposedType) { builder.AddByte(3, (byte)exposedType, 0); }
+  public static void AddDefaultScalar(FlatBufferBuilder builder, float defaultScalar) { builder.AddFloat(4, defaultScalar, 0.0f); }
+  public static void AddDefaultVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4> defaultVectorOffset) { builder.AddStruct(5, defaultVectorOffset.Value, 0); }
+  public static void AddDefaultColor(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color> defaultColorOffset) { builder.AddStruct(6, defaultColorOffset.Value, 0); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyBinding> EndPropertyBinding(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyBinding>(o);
+  }
+}
+
+
+static public class PropertyBindingVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Name*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*DisplayName*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*ActualType*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType*/, 1, false)
+      && verifier.VerifyField(tablePos, 10 /*ExposedType*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyValueType*/, 1, false)
+      && verifier.VerifyField(tablePos, 12 /*DefaultScalar*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*DefaultVector*/, 16 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Vec4*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*DefaultColor*/, 4 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Color*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Marker : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Marker GetRootAsMarker(ByteBuffer _bb) { return GetRootAsMarker(_bb, new Marker()); }
+  public static Marker GetRootAsMarker(ByteBuffer _bb, Marker obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Marker __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public uint Name { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public float Progress { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float DurationProgress { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Marker> CreateMarker(FlatBufferBuilder builder,
+      uint name = 0,
+      float progress = 0.0f,
+      float duration_progress = 0.0f) {
+    builder.StartTable(3);
+    Marker.AddDurationProgress(builder, duration_progress);
+    Marker.AddProgress(builder, progress);
+    Marker.AddName(builder, name);
+    return Marker.EndMarker(builder);
+  }
+
+  public static void StartMarker(FlatBufferBuilder builder) { builder.StartTable(3); }
+  public static void AddName(FlatBufferBuilder builder, uint name) { builder.AddUint(0, name, 0); }
+  public static void AddProgress(FlatBufferBuilder builder, float progress) { builder.AddFloat(1, progress, 0.0f); }
+  public static void AddDurationProgress(FlatBufferBuilder builder, float durationProgress) { builder.AddFloat(2, durationProgress, 0.0f); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Marker> EndMarker(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Marker>(o);
+  }
+}
+
+
+static public class MarkerVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Name*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*Progress*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*DurationProgress*/, 4 /*float*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct Metadata : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static Metadata GetRootAsMetadata(ByteBuffer _bb) { return GetRootAsMetadata(_bb, new Metadata()); }
+  public static Metadata GetRootAsMetadata(ByteBuffer _bb, Metadata obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public Metadata __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public uint Name { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public float Width { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float Height { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public long DurationTicks { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public float FramesPerSecond { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyBinding? PropertyBindings(int j) { int o = __p.__offset(14); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyBinding?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyBinding()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int PropertyBindingsLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Marker? Markers(int j) { int o = __p.__offset(16); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Marker?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Marker()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int MarkersLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public uint ThemingPropertySet { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Metadata> CreateMetadata(FlatBufferBuilder builder,
+      uint name = 4294967295,
+      float width = 0.0f,
+      float height = 0.0f,
+      long duration_ticks = 0,
+      float frames_per_second = 0.0f,
+      VectorOffset property_bindingsOffset = default(VectorOffset),
+      VectorOffset markersOffset = default(VectorOffset),
+      uint theming_property_set = 4294967295) {
+    builder.StartTable(8);
+    Metadata.AddDurationTicks(builder, duration_ticks);
+    Metadata.AddThemingPropertySet(builder, theming_property_set);
+    Metadata.AddMarkers(builder, markersOffset);
+    Metadata.AddPropertyBindings(builder, property_bindingsOffset);
+    Metadata.AddFramesPerSecond(builder, frames_per_second);
+    Metadata.AddHeight(builder, height);
+    Metadata.AddWidth(builder, width);
+    Metadata.AddName(builder, name);
+    return Metadata.EndMetadata(builder);
+  }
+
+  public static void StartMetadata(FlatBufferBuilder builder) { builder.StartTable(8); }
+  public static void AddName(FlatBufferBuilder builder, uint name) { builder.AddUint(0, name, 4294967295); }
+  public static void AddWidth(FlatBufferBuilder builder, float width) { builder.AddFloat(1, width, 0.0f); }
+  public static void AddHeight(FlatBufferBuilder builder, float height) { builder.AddFloat(2, height, 0.0f); }
+  public static void AddDurationTicks(FlatBufferBuilder builder, long durationTicks) { builder.AddLong(3, durationTicks, 0); }
+  public static void AddFramesPerSecond(FlatBufferBuilder builder, float framesPerSecond) { builder.AddFloat(4, framesPerSecond, 0.0f); }
+  public static void AddPropertyBindings(FlatBufferBuilder builder, VectorOffset propertyBindingsOffset) { builder.AddOffset(5, propertyBindingsOffset.Value, 0); }
+  public static VectorOffset CreatePropertyBindingsVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyBinding>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreatePropertyBindingsVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyBinding>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreatePropertyBindingsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyBinding>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreatePropertyBindingsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyBinding>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartPropertyBindingsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddMarkers(FlatBufferBuilder builder, VectorOffset markersOffset) { builder.AddOffset(6, markersOffset.Value, 0); }
+  public static VectorOffset CreateMarkersVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Marker>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateMarkersVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Marker>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateMarkersVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Marker>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateMarkersVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Marker>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartMarkersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddThemingPropertySet(FlatBufferBuilder builder, uint themingPropertySet) { builder.AddUint(7, themingPropertySet, 4294967295); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Metadata> EndMetadata(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Metadata>(o);
+  }
+}
+
+
+static public class MetadataVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Name*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*Width*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*Height*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*DurationTicks*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*FramesPerSecond*/, 4 /*float*/, 4, false)
+      && verifier.VerifyVectorOfTables(tablePos, 14 /*PropertyBindings*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertyBindingVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 16 /*Markers*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.MarkerVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 18 /*ThemingPropertySet*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct LottieComposition : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static LottieComposition GetRootAsLottieComposition(ByteBuffer _bb) { return GetRootAsLottieComposition(_bb, new LottieComposition()); }
+  public static LottieComposition GetRootAsLottieComposition(ByteBuffer _bb, LottieComposition obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public static bool LottieCompositionBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "LCMP"); }
+  public static bool VerifyLottieComposition(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("LCMP", false, LottieCompositionVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public LottieComposition __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public ushort SchemaVersion { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUshort(o + __p.bb_pos) : (ushort)0; } }
+  public ushort RequiredUapVersion { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUshort(o + __p.bb_pos) : (ushort)0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Metadata? Metadata { get { int o = __p.__offset(8); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Metadata?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Metadata()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  public uint RootVisual { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public string Strings(int j) { int o = __p.__offset(12); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
+  public int StringsLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Visual? Visuals(int j) { int o = __p.__offset(14); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Visual?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Visual()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int VisualsLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shape? Shapes(int j) { int o = __p.__offset(16); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shape?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shape()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int ShapesLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Geometry? Geometries(int j) { int o = __p.__offset(18); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Geometry?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Geometry()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int GeometriesLength { get { int o = __p.__offset(18); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometry? CanvasGeometries(int j) { int o = __p.__offset(20); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometry?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometry()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int CanvasGeometriesLength { get { int o = __p.__offset(20); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Brush? Brushes(int j) { int o = __p.__offset(22); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Brush?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Brush()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int BrushesLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GradientStop? GradientStops(int j) { int o = __p.__offset(24); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GradientStop?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GradientStop()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int GradientStopsLength { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ViewBox? ViewBoxes(int j) { int o = __p.__offset(26); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ViewBox?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ViewBox()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int ViewBoxesLength { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Clip? Clips(int j) { int o = __p.__offset(28); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Clip?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Clip()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int ClipsLength { get { int o = __p.__offset(28); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shadow? Shadows(int j) { int o = __p.__offset(30); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shadow?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shadow()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int ShadowsLength { get { int o = __p.__offset(30); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Surface? Surfaces(int j) { int o = __p.__offset(32); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Surface?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Surface()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int SurfacesLength { get { int o = __p.__offset(32); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Effect? Effects(int j) { int o = __p.__offset(34); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Effect?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Effect()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int EffectsLength { get { int o = __p.__offset(34); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Easing? Easings(int j) { int o = __p.__offset(36); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Easing?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Easing()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int EasingsLength { get { int o = __p.__offset(36); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animation? Animations(int j) { int o = __p.__offset(38); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animation?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animation()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int AnimationsLength { get { int o = __p.__offset(38); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySet? PropertySets(int j) { int o = __p.__offset(40); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySet?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySet()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int PropertySetsLength { get { int o = __p.__offset(40); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Controller? Controllers(int j) { int o = __p.__offset(42); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Controller?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Controller()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int ControllersLength { get { int o = __p.__offset(42); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public uint CustomControllers(int j) { int o = __p.__offset(44); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+  public int CustomControllersLength { get { int o = __p.__offset(44); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<uint> GetCustomControllersBytes() { return __p.__vector_as_span<uint>(44, 4); }
+#else
+  public ArraySegment<byte>? GetCustomControllersBytes() { return __p.__vector_as_arraysegment(44); }
+#endif
+  public uint[] GetCustomControllersArray() { return __p.__vector_as_array<uint>(44); }
+
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.LottieComposition> CreateLottieComposition(FlatBufferBuilder builder,
+      ushort schema_version = 0,
+      ushort required_uap_version = 0,
+      Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Metadata> metadataOffset = default(Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Metadata>),
+      uint root_visual = 4294967295,
+      VectorOffset stringsOffset = default(VectorOffset),
+      VectorOffset visualsOffset = default(VectorOffset),
+      VectorOffset shapesOffset = default(VectorOffset),
+      VectorOffset geometriesOffset = default(VectorOffset),
+      VectorOffset canvas_geometriesOffset = default(VectorOffset),
+      VectorOffset brushesOffset = default(VectorOffset),
+      VectorOffset gradient_stopsOffset = default(VectorOffset),
+      VectorOffset view_boxesOffset = default(VectorOffset),
+      VectorOffset clipsOffset = default(VectorOffset),
+      VectorOffset shadowsOffset = default(VectorOffset),
+      VectorOffset surfacesOffset = default(VectorOffset),
+      VectorOffset effectsOffset = default(VectorOffset),
+      VectorOffset easingsOffset = default(VectorOffset),
+      VectorOffset animationsOffset = default(VectorOffset),
+      VectorOffset property_setsOffset = default(VectorOffset),
+      VectorOffset controllersOffset = default(VectorOffset),
+      VectorOffset custom_controllersOffset = default(VectorOffset)) {
+    builder.StartTable(21);
+    LottieComposition.AddCustomControllers(builder, custom_controllersOffset);
+    LottieComposition.AddControllers(builder, controllersOffset);
+    LottieComposition.AddPropertySets(builder, property_setsOffset);
+    LottieComposition.AddAnimations(builder, animationsOffset);
+    LottieComposition.AddEasings(builder, easingsOffset);
+    LottieComposition.AddEffects(builder, effectsOffset);
+    LottieComposition.AddSurfaces(builder, surfacesOffset);
+    LottieComposition.AddShadows(builder, shadowsOffset);
+    LottieComposition.AddClips(builder, clipsOffset);
+    LottieComposition.AddViewBoxes(builder, view_boxesOffset);
+    LottieComposition.AddGradientStops(builder, gradient_stopsOffset);
+    LottieComposition.AddBrushes(builder, brushesOffset);
+    LottieComposition.AddCanvasGeometries(builder, canvas_geometriesOffset);
+    LottieComposition.AddGeometries(builder, geometriesOffset);
+    LottieComposition.AddShapes(builder, shapesOffset);
+    LottieComposition.AddVisuals(builder, visualsOffset);
+    LottieComposition.AddStrings(builder, stringsOffset);
+    LottieComposition.AddRootVisual(builder, root_visual);
+    LottieComposition.AddMetadata(builder, metadataOffset);
+    LottieComposition.AddRequiredUapVersion(builder, required_uap_version);
+    LottieComposition.AddSchemaVersion(builder, schema_version);
+    return LottieComposition.EndLottieComposition(builder);
+  }
+
+  public static void StartLottieComposition(FlatBufferBuilder builder) { builder.StartTable(21); }
+  public static void AddSchemaVersion(FlatBufferBuilder builder, ushort schemaVersion) { builder.AddUshort(0, schemaVersion, 0); }
+  public static void AddRequiredUapVersion(FlatBufferBuilder builder, ushort requiredUapVersion) { builder.AddUshort(1, requiredUapVersion, 0); }
+  public static void AddMetadata(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Metadata> metadataOffset) { builder.AddOffset(2, metadataOffset.Value, 0); }
+  public static void AddRootVisual(FlatBufferBuilder builder, uint rootVisual) { builder.AddUint(3, rootVisual, 4294967295); }
+  public static void AddStrings(FlatBufferBuilder builder, VectorOffset stringsOffset) { builder.AddOffset(4, stringsOffset.Value, 0); }
+  public static VectorOffset CreateStringsVector(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateStringsVectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStringsVectorBlock(FlatBufferBuilder builder, ArraySegment<StringOffset> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStringsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<StringOffset>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartStringsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddVisuals(FlatBufferBuilder builder, VectorOffset visualsOffset) { builder.AddOffset(5, visualsOffset.Value, 0); }
+  public static VectorOffset CreateVisualsVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Visual>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateVisualsVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Visual>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateVisualsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Visual>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateVisualsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Visual>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartVisualsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddShapes(FlatBufferBuilder builder, VectorOffset shapesOffset) { builder.AddOffset(6, shapesOffset.Value, 0); }
+  public static VectorOffset CreateShapesVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shape>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateShapesVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shape>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapesVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shape>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shape>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartShapesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddGeometries(FlatBufferBuilder builder, VectorOffset geometriesOffset) { builder.AddOffset(7, geometriesOffset.Value, 0); }
+  public static VectorOffset CreateGeometriesVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Geometry>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateGeometriesVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Geometry>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateGeometriesVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Geometry>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateGeometriesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Geometry>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartGeometriesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddCanvasGeometries(FlatBufferBuilder builder, VectorOffset canvasGeometriesOffset) { builder.AddOffset(8, canvasGeometriesOffset.Value, 0); }
+  public static VectorOffset CreateCanvasGeometriesVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometry>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateCanvasGeometriesVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometry>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCanvasGeometriesVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometry>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCanvasGeometriesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometry>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartCanvasGeometriesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddBrushes(FlatBufferBuilder builder, VectorOffset brushesOffset) { builder.AddOffset(9, brushesOffset.Value, 0); }
+  public static VectorOffset CreateBrushesVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Brush>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateBrushesVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Brush>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateBrushesVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Brush>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateBrushesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Brush>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartBrushesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddGradientStops(FlatBufferBuilder builder, VectorOffset gradientStopsOffset) { builder.AddOffset(10, gradientStopsOffset.Value, 0); }
+  public static VectorOffset CreateGradientStopsVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GradientStop>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateGradientStopsVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GradientStop>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateGradientStopsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GradientStop>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateGradientStopsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GradientStop>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartGradientStopsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddViewBoxes(FlatBufferBuilder builder, VectorOffset viewBoxesOffset) { builder.AddOffset(11, viewBoxesOffset.Value, 0); }
+  public static VectorOffset CreateViewBoxesVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ViewBox>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateViewBoxesVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ViewBox>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateViewBoxesVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ViewBox>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateViewBoxesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ViewBox>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartViewBoxesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddClips(FlatBufferBuilder builder, VectorOffset clipsOffset) { builder.AddOffset(12, clipsOffset.Value, 0); }
+  public static VectorOffset CreateClipsVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Clip>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateClipsVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Clip>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateClipsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Clip>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateClipsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Clip>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartClipsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddShadows(FlatBufferBuilder builder, VectorOffset shadowsOffset) { builder.AddOffset(13, shadowsOffset.Value, 0); }
+  public static VectorOffset CreateShadowsVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shadow>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateShadowsVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shadow>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShadowsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shadow>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShadowsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Shadow>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartShadowsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddSurfaces(FlatBufferBuilder builder, VectorOffset surfacesOffset) { builder.AddOffset(14, surfacesOffset.Value, 0); }
+  public static VectorOffset CreateSurfacesVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Surface>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateSurfacesVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Surface>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateSurfacesVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Surface>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateSurfacesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Surface>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartSurfacesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddEffects(FlatBufferBuilder builder, VectorOffset effectsOffset) { builder.AddOffset(15, effectsOffset.Value, 0); }
+  public static VectorOffset CreateEffectsVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Effect>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateEffectsVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Effect>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateEffectsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Effect>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateEffectsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Effect>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartEffectsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddEasings(FlatBufferBuilder builder, VectorOffset easingsOffset) { builder.AddOffset(16, easingsOffset.Value, 0); }
+  public static VectorOffset CreateEasingsVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Easing>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateEasingsVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Easing>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateEasingsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Easing>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateEasingsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Easing>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartEasingsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddAnimations(FlatBufferBuilder builder, VectorOffset animationsOffset) { builder.AddOffset(17, animationsOffset.Value, 0); }
+  public static VectorOffset CreateAnimationsVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animation>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateAnimationsVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animation>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateAnimationsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animation>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateAnimationsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Animation>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartAnimationsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddPropertySets(FlatBufferBuilder builder, VectorOffset propertySetsOffset) { builder.AddOffset(18, propertySetsOffset.Value, 0); }
+  public static VectorOffset CreatePropertySetsVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySet>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreatePropertySetsVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySet>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreatePropertySetsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySet>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreatePropertySetsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySet>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartPropertySetsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddControllers(FlatBufferBuilder builder, VectorOffset controllersOffset) { builder.AddOffset(19, controllersOffset.Value, 0); }
+  public static VectorOffset CreateControllersVector(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Controller>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateControllersVectorBlock(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Controller>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateControllersVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Controller>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateControllersVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Controller>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartControllersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddCustomControllers(FlatBufferBuilder builder, VectorOffset customControllersOffset) { builder.AddOffset(20, customControllersOffset.Value, 0); }
+  public static VectorOffset CreateCustomControllersVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateCustomControllersVectorBlock(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomControllersVectorBlock(FlatBufferBuilder builder, ArraySegment<uint> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomControllersVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<uint>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartCustomControllersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.LottieComposition> EndLottieComposition(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.LottieComposition>(o);
+  }
+  public static void FinishLottieCompositionBuffer(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.LottieComposition> offset) { builder.Finish(offset.Value, "LCMP"); }
+  public static void FinishSizePrefixedLottieCompositionBuffer(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.LottieComposition> offset) { builder.FinishSizePrefixed(offset.Value, "LCMP"); }
+}
+
+
+static public class LottieCompositionVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*SchemaVersion*/, 2 /*ushort*/, 2, false)
+      && verifier.VerifyField(tablePos, 6 /*RequiredUapVersion*/, 2 /*ushort*/, 2, false)
+      && verifier.VerifyTable(tablePos, 8 /*Metadata*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.MetadataVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 10 /*RootVisual*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyVectorOfStrings(tablePos, 12 /*Strings*/, false)
+      && verifier.VerifyVectorOfTables(tablePos, 14 /*Visuals*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.VisualVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 16 /*Shapes*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShapeVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 18 /*Geometries*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GeometryVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 20 /*CanvasGeometries*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometryVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 22 /*Brushes*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.BrushVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 24 /*GradientStops*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.GradientStopVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 26 /*ViewBoxes*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ViewBoxVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 28 /*Clips*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ClipVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 30 /*Shadows*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ShadowVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 32 /*Surfaces*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.SurfaceVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 34 /*Effects*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EffectVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 36 /*Easings*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.EasingVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 38 /*Animations*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.AnimationVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 40 /*PropertySets*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.PropertySetVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 42 /*Controllers*/, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.ControllerVerify.Verify, false)
+      && verifier.VerifyVectorOfData(tablePos, 44 /*CustomControllers*/, 4 /*uint*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+public struct CanvasGeometry : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_2_10(); }
+  public static CanvasGeometry GetRootAsCanvasGeometry(ByteBuffer _bb) { return GetRootAsCanvasGeometry(_bb, new CanvasGeometry()); }
+  public static CanvasGeometry GetRootAsCanvasGeometry(ByteBuffer _bb, CanvasGeometry obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CanvasGeometry __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometryKind Kind { get { int o = __p.__offset(4); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometryKind)__p.bb.Get(o + __p.bb_pos) : CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometryKind.Combination; } }
+  public uint A { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public uint B { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public byte CombineMode { get { int o = __p.__offset(10); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
+  public CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2? Matrix { get { int o = __p.__offset(12); return o != 0 ? (CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2?)(new CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  public uint Source { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)4294967295; } }
+  public uint Geometries(int j) { int o = __p.__offset(16); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+  public int GeometriesLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<uint> GetGeometriesBytes() { return __p.__vector_as_span<uint>(16, 4); }
+#else
+  public ArraySegment<byte>? GetGeometriesBytes() { return __p.__vector_as_arraysegment(16); }
+#endif
+  public uint[] GetGeometriesArray() { return __p.__vector_as_array<uint>(16); }
+  public byte FillRule { get { int o = __p.__offset(18); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
+  public byte Ops(int j) { int o = __p.__offset(20); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; }
+  public int OpsLength { get { int o = __p.__offset(20); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetOpsBytes() { return __p.__vector_as_span<byte>(20, 1); }
+#else
+  public ArraySegment<byte>? GetOpsBytes() { return __p.__vector_as_arraysegment(20); }
+#endif
+  public byte[] GetOpsArray() { return __p.__vector_as_array<byte>(20); }
+  public float Operands(int j) { int o = __p.__offset(22); return o != 0 ? __p.bb.GetFloat(__p.__vector(o) + j * 4) : (float)0; }
+  public int OperandsLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<float> GetOperandsBytes() { return __p.__vector_as_span<float>(22, 4); }
+#else
+  public ArraySegment<byte>? GetOperandsBytes() { return __p.__vector_as_arraysegment(22); }
+#endif
+  public float[] GetOperandsArray() { return __p.__vector_as_array<float>(22); }
+  public float X { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float Y { get { int o = __p.__offset(26); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float W { get { int o = __p.__offset(28); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float H { get { int o = __p.__offset(30); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float RadiusX { get { int o = __p.__offset(32); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float RadiusY { get { int o = __p.__offset(34); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+
+  public static void StartCanvasGeometry(FlatBufferBuilder builder) { builder.StartTable(16); }
+  public static void AddKind(FlatBufferBuilder builder, CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometryKind kind) { builder.AddByte(0, (byte)kind, 0); }
+  public static void AddA(FlatBufferBuilder builder, uint a) { builder.AddUint(1, a, 4294967295); }
+  public static void AddB(FlatBufferBuilder builder, uint b) { builder.AddUint(2, b, 4294967295); }
+  public static void AddCombineMode(FlatBufferBuilder builder, byte combineMode) { builder.AddByte(3, combineMode, 0); }
+  public static void AddMatrix(FlatBufferBuilder builder, Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2> matrixOffset) { builder.AddStruct(4, matrixOffset.Value, 0); }
+  public static void AddSource(FlatBufferBuilder builder, uint source) { builder.AddUint(5, source, 4294967295); }
+  public static void AddGeometries(FlatBufferBuilder builder, VectorOffset geometriesOffset) { builder.AddOffset(6, geometriesOffset.Value, 0); }
+  public static VectorOffset CreateGeometriesVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateGeometriesVectorBlock(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateGeometriesVectorBlock(FlatBufferBuilder builder, ArraySegment<uint> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateGeometriesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<uint>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartGeometriesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddFillRule(FlatBufferBuilder builder, byte fillRule) { builder.AddByte(7, fillRule, 0); }
+  public static void AddOps(FlatBufferBuilder builder, VectorOffset opsOffset) { builder.AddOffset(8, opsOffset.Value, 0); }
+  public static VectorOffset CreateOpsVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateOpsVectorBlock(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateOpsVectorBlock(FlatBufferBuilder builder, ArraySegment<byte> data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateOpsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<byte>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartOpsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
+  public static void AddOperands(FlatBufferBuilder builder, VectorOffset operandsOffset) { builder.AddOffset(9, operandsOffset.Value, 0); }
+  public static VectorOffset CreateOperandsVector(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddFloat(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateOperandsVectorBlock(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateOperandsVectorBlock(FlatBufferBuilder builder, ArraySegment<float> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateOperandsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<float>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartOperandsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddX(FlatBufferBuilder builder, float x) { builder.AddFloat(10, x, 0.0f); }
+  public static void AddY(FlatBufferBuilder builder, float y) { builder.AddFloat(11, y, 0.0f); }
+  public static void AddW(FlatBufferBuilder builder, float w) { builder.AddFloat(12, w, 0.0f); }
+  public static void AddH(FlatBufferBuilder builder, float h) { builder.AddFloat(13, h, 0.0f); }
+  public static void AddRadiusX(FlatBufferBuilder builder, float radiusX) { builder.AddFloat(14, radiusX, 0.0f); }
+  public static void AddRadiusY(FlatBufferBuilder builder, float radiusY) { builder.AddFloat(15, radiusY, 0.0f); }
+  public static Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometry> EndCanvasGeometry(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometry>(o);
+  }
+}
+
+
+static public class CanvasGeometryVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Kind*/, 1 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.CanvasGeometryKind*/, 1, false)
+      && verifier.VerifyField(tablePos, 6 /*A*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*B*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*CombineMode*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 12 /*Matrix*/, 24 /*CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema.Mat3x2*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*Source*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 16 /*Geometries*/, 4 /*uint*/, false)
+      && verifier.VerifyField(tablePos, 18 /*FillRule*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyVectorOfData(tablePos, 20 /*Ops*/, 1 /*byte*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 22 /*Operands*/, 4 /*float*/, false)
+      && verifier.VerifyField(tablePos, 24 /*X*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 26 /*Y*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 28 /*W*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 30 /*H*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 32 /*RadiusX*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 34 /*RadiusY*/, 4 /*float*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/source/CompDataFlatbuffer/Schema.cs b/source/CompDataFlatbuffer/Schema.cs
deleted file mode 100644
index 84b3451a..00000000
--- a/source/CompDataFlatbuffer/Schema.cs
+++ /dev/null
@@ -1,385 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#nullable enable
-
-namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
-{
-    /// <summary>
-    /// Field ids, enum values and constants of the lottie_comp.fbs schema.
-    /// These must be kept in sync with lottie_comp.fbs; field ids are the
-    /// 0-based declaration order of the fields of each table.
-    /// </summary>
-    static class Schema
-    {
-        /// <summary>
-        /// The version of the schema that this code reads and writes. Bumped for
-        /// every additive change to lottie_comp.fbs.
-        /// </summary>
-        internal const ushort Version = 1;
-
-        /// <summary>
-        /// The 4 character identifier stored at offset 4 of every buffer.
-        /// </summary>
-        internal const string FileIdentifier = "LCMP";
-
-        /// <summary>
-        /// The file extension used for serialized compositions.
-        /// </summary>
-        internal const string FileExtension = ".lcomp";
-
-        /// <summary>
-        /// The value of an index or reference field that refers to nothing.
-        /// </summary>
-        internal const uint NullIndex = 0xFFFFFFFF;
-
-        /// <summary>
-        /// The number of bits used to store the index part of an object reference.
-        /// </summary>
-        internal const int ObjectReferenceIndexBits = 28;
-
-        internal static uint PackObjectReference(ObjectCategory category, int index)
-            => ((uint)category << ObjectReferenceIndexBits) | (uint)index;
-
-        internal static ObjectCategory UnpackCategory(uint reference)
-            => (ObjectCategory)(reference >> ObjectReferenceIndexBits);
-
-        internal static int UnpackIndex(uint reference)
-            => (int)(reference & ((1u << ObjectReferenceIndexBits) - 1));
-
-        internal static class Animator
-        {
-            internal const int FieldCount = 3;
-            internal const int Property = 0;
-            internal const int Animation = 1;
-            internal const int Controller = 2;
-        }
-
-        internal static class CompObj
-        {
-            internal const int FieldCount = 3;
-            internal const int Comment = 0;
-            internal const int Animators = 1;
-            internal const int Properties = 2;
-        }
-
-        internal static class PropertyValue
-        {
-            internal const int FieldCount = 5;
-            internal const int Name = 0;
-            internal const int Type = 1;
-            internal const int Scalar = 2;
-            internal const int Vector = 3;
-            internal const int Color = 4;
-        }
-
-        internal static class ReferenceParameter
-        {
-            internal const int FieldCount = 2;
-            internal const int Name = 0;
-            internal const int Target = 1;
-        }
-
-        internal static class SourceParameter
-        {
-            internal const int FieldCount = 2;
-            internal const int Name = 0;
-            internal const int Brush = 1;
-        }
-
-        internal static class KeyFrame
-        {
-            internal const int FieldCount = 8;
-            internal const int Progress = 0;
-            internal const int Easing = 1;
-            internal const int Kind = 2;
-            internal const int Expression = 3;
-            internal const int Scalar = 4;
-            internal const int Vector = 5;
-            internal const int Color = 6;
-            internal const int Path = 7;
-        }
-
-        internal static class Visual
-        {
-            internal const int FieldCount = 18;
-            internal const int Base = 0;
-            internal const int Kind = 1;
-            internal const int BorderMode = 2;
-            internal const int CenterPoint = 3;
-            internal const int Clip = 4;
-            internal const int IsVisible = 5;
-            internal const int Offset = 6;
-            internal const int Opacity = 7;
-            internal const int RotationAngleInDegrees = 8;
-            internal const int RotationAxis = 9;
-            internal const int Scale = 10;
-            internal const int Size = 11;
-            internal const int TransformMatrix = 12;
-            internal const int Children = 13;
-            internal const int Shapes = 14;
-            internal const int ViewBox = 15;
-            internal const int Brush = 16;
-            internal const int Shadow = 17;
-        }
-
-        internal static class Shape
-        {
-            internal const int FieldCount = 20;
-            internal const int Base = 0;
-            internal const int Kind = 1;
-            internal const int CenterPoint = 2;
-            internal const int Offset = 3;
-            internal const int RotationAngleInDegrees = 4;
-            internal const int Scale = 5;
-            internal const int TransformMatrix = 6;
-            internal const int Shapes = 7;
-            internal const int FillBrush = 8;
-            internal const int StrokeBrush = 9;
-            internal const int Geometry = 10;
-            internal const int IsStrokeNonScaling = 11;
-            internal const int StrokeDashOffset = 12;
-            internal const int StrokeDashArray = 13;
-            internal const int StrokeDashCap = 14;
-            internal const int StrokeStartCap = 15;
-            internal const int StrokeEndCap = 16;
-            internal const int StrokeLineJoin = 17;
-            internal const int StrokeMiterLimit = 18;
-            internal const int StrokeThickness = 19;
-        }
-
-        internal static class Geometry
-        {
-            internal const int FieldCount = 11;
-            internal const int Base = 0;
-            internal const int Kind = 1;
-            internal const int TrimStart = 2;
-            internal const int TrimEnd = 3;
-            internal const int TrimOffset = 4;
-            internal const int Path = 5;
-            internal const int Offset = 6;
-            internal const int Size = 7;
-            internal const int CornerRadius = 8;
-            internal const int Center = 9;
-            internal const int Radius = 10;
-        }
-
-        internal static class Brush
-        {
-            internal const int FieldCount = 23;
-            internal const int Base = 0;
-            internal const int Kind = 1;
-            internal const int Color = 2;
-            internal const int AnchorPoint = 3;
-            internal const int CenterPoint = 4;
-            internal const int ColorStops = 5;
-            internal const int ExtendMode = 6;
-            internal const int InterpolationSpace = 7;
-            internal const int MappingMode = 8;
-            internal const int Offset = 9;
-            internal const int RotationAngleInDegrees = 10;
-            internal const int Scale = 11;
-            internal const int TransformMatrix = 12;
-            internal const int StartPoint = 13;
-            internal const int EndPoint = 14;
-            internal const int EllipseCenter = 15;
-            internal const int EllipseRadius = 16;
-            internal const int GradientOriginOffset = 17;
-            internal const int Surface = 18;
-            internal const int Source = 19;
-            internal const int Mask = 20;
-            internal const int Effect = 21;
-            internal const int SourceParameters = 22;
-        }
-
-        internal static class GradientStop
-        {
-            internal const int FieldCount = 3;
-            internal const int Base = 0;
-            internal const int Color = 1;
-            internal const int Offset = 2;
-        }
-
-        internal static class ViewBox
-        {
-            internal const int FieldCount = 2;
-            internal const int Base = 0;
-            internal const int Size = 1;
-        }
-
-        internal static class Clip
-        {
-            internal const int FieldCount = 9;
-            internal const int Base = 0;
-            internal const int Kind = 1;
-            internal const int CenterPoint = 2;
-            internal const int Scale = 3;
-            internal const int LeftInset = 4;
-            internal const int RightInset = 5;
-            internal const int TopInset = 6;
-            internal const int BottomInset = 7;
-            internal const int Geometry = 8;
-        }
-
-        internal static class Shadow
-        {
-            internal const int FieldCount = 8;
-            internal const int Base = 0;
-            internal const int Kind = 1;
-            internal const int BlurRadius = 2;
-            internal const int Color = 3;
-            internal const int Mask = 4;
-            internal const int Offset = 5;
-            internal const int Opacity = 6;
-            internal const int SourcePolicy = 7;
-        }
-
-        internal static class Surface
-        {
-            internal const int FieldCount = 7;
-            internal const int Base = 0;
-            internal const int Kind = 1;
-            internal const int SourceVisual = 2;
-            internal const int SourceSize = 3;
-            internal const int SourceOffset = 4;
-            internal const int Uri = 5;
-            internal const int Bytes = 6;
-        }
-
-        internal static class Effect
-        {
-            internal const int FieldCount = 5;
-            internal const int Base = 0;
-            internal const int Kind = 1;
-            internal const int Sources = 2;
-            internal const int Mode = 3;
-            internal const int BlurAmount = 4;
-        }
-
-        internal static class Easing
-        {
-            internal const int FieldCount = 9;
-            internal const int Base = 0;
-            internal const int Kind = 1;
-            internal const int ControlPoint1 = 2;
-            internal const int ControlPoint2 = 3;
-            internal const int StepCount = 4;
-            internal const int InitialStep = 5;
-            internal const int FinalStep = 6;
-            internal const int IsInitialStepSingleFrame = 7;
-            internal const int IsFinalStepSingleFrame = 8;
-        }
-
-        internal static class Animation
-        {
-            internal const int FieldCount = 8;
-            internal const int Base = 0;
-            internal const int Kind = 1;
-            internal const int Target = 2;
-            internal const int ReferenceParameters = 3;
-            internal const int Expression = 4;
-            internal const int DurationTicks = 5;
-            internal const int KeyFrames = 6;
-            internal const int InterpolationColorSpace = 7;
-        }
-
-        internal static class PropertySet
-        {
-            internal const int FieldCount = 3;
-            internal const int Base = 0;
-            internal const int Owner = 1;
-            internal const int Values = 2;
-        }
-
-        internal static class Controller
-        {
-            internal const int FieldCount = 5;
-            internal const int Base = 0;
-            internal const int TargetObject = 1;
-            internal const int TargetProperty = 2;
-            internal const int IsPaused = 3;
-            internal const int IsCustom = 4;
-        }
-
-        internal static class PropertyBinding
-        {
-            internal const int FieldCount = 7;
-            internal const int Name = 0;
-            internal const int DisplayName = 1;
-            internal const int ActualType = 2;
-            internal const int ExposedType = 3;
-            internal const int DefaultScalar = 4;
-            internal const int DefaultVector = 5;
-            internal const int DefaultColor = 6;
-        }
-
-        internal static class Marker
-        {
-            internal const int FieldCount = 3;
-            internal const int Name = 0;
-            internal const int Progress = 1;
-            internal const int DurationProgress = 2;
-        }
-
-        internal static class Metadata
-        {
-            internal const int FieldCount = 8;
-            internal const int Name = 0;
-            internal const int Width = 1;
-            internal const int Height = 2;
-            internal const int DurationTicks = 3;
-            internal const int FramesPerSecond = 4;
-            internal const int PropertyBindings = 5;
-            internal const int Markers = 6;
-            internal const int ThemingPropertySet = 7;
-        }
-
-        internal static class Composition
-        {
-            internal const int FieldCount = 21;
-            internal const int SchemaVersion = 0;
-            internal const int RequiredUapVersion = 1;
-            internal const int Metadata = 2;
-            internal const int RootVisual = 3;
-            internal const int Strings = 4;
-            internal const int Visuals = 5;
-            internal const int Shapes = 6;
-            internal const int Geometries = 7;
-            internal const int CanvasGeometries = 8;
-            internal const int Brushes = 9;
-            internal const int GradientStops = 10;
-            internal const int ViewBoxes = 11;
-            internal const int Clips = 12;
-            internal const int Shadows = 13;
-            internal const int Surfaces = 14;
-            internal const int Effects = 15;
-            internal const int Easings = 16;
-            internal const int Animations = 17;
-            internal const int PropertySets = 18;
-            internal const int Controllers = 19;
-            internal const int CustomControllers = 20;
-        }
-
-        internal static class CanvasGeometry
-        {
-            internal const int FieldCount = 16;
-            internal const int Kind = 0;
-            internal const int A = 1;
-            internal const int B = 2;
-            internal const int CombineMode = 3;
-            internal const int Matrix = 4;
-            internal const int Source = 5;
-            internal const int Geometries = 6;
-            internal const int FillRule = 7;
-            internal const int Ops = 8;
-            internal const int Operands = 9;
-            internal const int X = 10;
-            internal const int Y = 11;
-            internal const int W = 12;
-            internal const int H = 13;
-            internal const int RadiusX = 14;
-            internal const int RadiusY = 15;
-        }
-    }
-}
diff --git a/source/CompDataFlatbuffer/SchemaEnums.cs b/source/CompDataFlatbuffer/SchemaEnums.cs
deleted file mode 100644
index ddafef6d..00000000
--- a/source/CompDataFlatbuffer/SchemaEnums.cs
+++ /dev/null
@@ -1,139 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#nullable enable
-
-namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
-{
-    /// <summary>
-    /// Identifies the node vector that a packed object reference points into.
-    /// Must be kept in sync with the ObjectCategory enum in lottie_comp.fbs.
-    /// </summary>
-    enum ObjectCategory : byte
-    {
-        Visual = 0,
-        Shape = 1,
-        Geometry = 2,
-        Brush = 3,
-        Animation = 4,
-        Easing = 5,
-        PropertySet = 6,
-        Surface = 7,
-        Clip = 8,
-        Controller = 9,
-        Shadow = 10,
-        Effect = 11,
-        GradientStop = 12,
-        ViewBox = 13,
-    }
-
-    enum VisualKind : byte
-    {
-        Container = 0,
-        Sprite = 1,
-        Shape = 2,
-        Layer = 3,
-    }
-
-    enum ShapeKind : byte
-    {
-        Container = 0,
-        Sprite = 1,
-    }
-
-    enum GeometryKind : byte
-    {
-        Path = 0,
-        Rectangle = 1,
-        RoundedRectangle = 2,
-        Ellipse = 3,
-    }
-
-    enum BrushKind : byte
-    {
-        Color = 0,
-        LinearGradient = 1,
-        RadialGradient = 2,
-        Surface = 3,
-        Mask = 4,
-        Effect = 5,
-    }
-
-    enum ClipKind : byte
-    {
-        Inset = 0,
-        Geometric = 1,
-    }
-
-    enum ShadowKind : byte
-    {
-        Drop = 0,
-    }
-
-    enum SurfaceKind : byte
-    {
-        VisualSurface = 0,
-        LoadedImageFromUri = 1,
-        LoadedImageFromStream = 2,
-    }
-
-    enum EffectKind : byte
-    {
-        Composite = 0,
-        GaussianBlur = 1,
-    }
-
-    enum EasingKind : byte
-    {
-        Linear = 0,
-        CubicBezier = 1,
-        Step = 2,
-    }
-
-    enum AnimationKind : byte
-    {
-        Scalar = 0,
-        Vector2 = 1,
-        Vector3 = 2,
-        Vector4 = 3,
-        Color = 4,
-        Boolean = 5,
-        Path = 6,
-        Expression = 7,
-    }
-
-    enum KeyFrameKind : byte
-    {
-        Value = 0,
-        Expression = 1,
-    }
-
-    enum CanvasGeometryKind : byte
-    {
-        Combination = 0,
-        Ellipse = 1,
-        Group = 2,
-        Path = 3,
-        RoundedRectangle = 4,
-        TransformedGeometry = 5,
-    }
-
-    /// <summary>
-    /// The opcodes of the flattened CanvasPathBuilder command stream.
-    /// </summary>
-    enum PathOp : byte
-    {
-        /// <summary>Consumes 2 operands: x, y.</summary>
-        BeginFigure = 0,
-
-        /// <summary>Consumes 1 operand: the CanvasFigureLoop.</summary>
-        EndFigure = 1,
-
-        /// <summary>Consumes 2 operands: x, y.</summary>
-        AddLine = 2,
-
-        /// <summary>Consumes 6 operands: cp1.x, cp1.y, cp2.x, cp2.y, end.x, end.y.</summary>
-        AddCubicBezier = 3,
-    }
-}

From a5b26958513ab7777a3d0e15d7e81499b8d89fee Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 18:06:20 +0000
Subject: [PATCH 03/39] Add GraphIndexer: deterministic reference-identity walk
 of the WinCompData graph

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 .../CompDataFlatbuffer.dll.csproj             |   1 +
 .../CompDataFlatbuffer.projitems              |   1 +
 source/CompDataFlatbuffer/GraphIndexer.cs     | 562 ++++++++++++++++++
 3 files changed, 564 insertions(+)
 create mode 100644 source/CompDataFlatbuffer/GraphIndexer.cs

diff --git a/dlls/CompDataFlatbuffer/CompDataFlatbuffer.dll.csproj b/dlls/CompDataFlatbuffer/CompDataFlatbuffer.dll.csproj
index cb3d2170..08da3387 100644
--- a/dlls/CompDataFlatbuffer/CompDataFlatbuffer.dll.csproj
+++ b/dlls/CompDataFlatbuffer/CompDataFlatbuffer.dll.csproj
@@ -19,6 +19,7 @@
     <ProjectReference Include="..\CompMetadata\CompMetadata.dll.csproj" />
     <ProjectReference Include="..\LottieMetadata\LottieMetadata.dll.csproj" />
     <ProjectReference Include="..\WinCompData\WinCompData.dll.csproj" />
+    <ProjectReference Include="..\WinUIXamlMediaData\WinUIXamlMediaData.dll.csproj" />
   </ItemGroup>
 
 </Project>
diff --git a/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems b/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
index add80aa3..57f9979a 100644
--- a/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
+++ b/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
@@ -10,6 +10,7 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)Format.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)GraphIndexer.cs" />
   </ItemGroup>
   <ItemGroup>
     <!-- Generated by build/RegenerateFlatbuffers.ps1 from source/LottieFlatbuffer/lottie_comp.fbs.
diff --git a/source/CompDataFlatbuffer/GraphIndexer.cs b/source/CompDataFlatbuffer/GraphIndexer.cs
new file mode 100644
index 00000000..aea762e5
--- /dev/null
+++ b/source/CompDataFlatbuffer/GraphIndexer.cs
@@ -0,0 +1,562 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using CommunityToolkit.WinUI.Lottie.WinCompData;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgce;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg;
+using CommunityToolkit.WinUI.Lottie.WinUIXamlMediaData;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
+{
+    /// <summary>
+    /// Walks a WinCompData graph and assigns a dense index to every node, grouped by
+    /// the <see cref="Schema.ObjectCategory"/> that the node is serialized into.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Indices are assigned in the order that nodes are first reached by a depth first
+    /// walk from the root. The walk order is fully determined by the shape of the graph,
+    /// so serializing the same graph twice produces identical output.
+    /// </para>
+    /// <para>
+    /// Nodes are identified by reference, not by value. This preserves the sharing in
+    /// the graph: a node that is referenced from several places is stored once and
+    /// referenced by index, which is what lets the interpreter realize it once.
+    /// </para>
+    /// </remarks>
+    sealed class GraphIndexer
+    {
+        // Nodes are keyed by reference so that distinct but equal objects stay distinct,
+        // matching the reference-identity caching that Instantiator performs at runtime.
+        readonly Dictionary<object, int> _visuals = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _shapes = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _geometries = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _canvasGeometries = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _brushes = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _gradientStops = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _viewBoxes = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _clips = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _shadows = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _surfaces = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _effects = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _easings = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _animations = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _propertySets = new Dictionary<object, int>(ReferenceComparer.Instance);
+        readonly Dictionary<object, int> _controllers = new Dictionary<object, int>(ReferenceComparer.Instance);
+
+        readonly Dictionary<string, int> _strings = new Dictionary<string, int>(StringComparer.Ordinal);
+
+        GraphIndexer()
+        {
+        }
+
+        internal List<Visual> VisualList { get; } = new List<Visual>();
+
+        internal List<CompositionShape> ShapeList { get; } = new List<CompositionShape>();
+
+        internal List<CompositionGeometry> GeometryList { get; } = new List<CompositionGeometry>();
+
+        internal List<CanvasGeometry> CanvasGeometryList { get; } = new List<CanvasGeometry>();
+
+        internal List<CompositionBrush> BrushList { get; } = new List<CompositionBrush>();
+
+        internal List<CompositionColorGradientStop> GradientStopList { get; } = new List<CompositionColorGradientStop>();
+
+        internal List<CompositionViewBox> ViewBoxList { get; } = new List<CompositionViewBox>();
+
+        internal List<CompositionClip> ClipList { get; } = new List<CompositionClip>();
+
+        internal List<CompositionShadow> ShadowList { get; } = new List<CompositionShadow>();
+
+        internal List<ICompositionSurface> SurfaceList { get; } = new List<ICompositionSurface>();
+
+        internal List<GraphicsEffectBase> EffectList { get; } = new List<GraphicsEffectBase>();
+
+        internal List<CompositionEasingFunction> EasingList { get; } = new List<CompositionEasingFunction>();
+
+        internal List<CompositionAnimation> AnimationList { get; } = new List<CompositionAnimation>();
+
+        internal List<CompositionPropertySet> PropertySetList { get; } = new List<CompositionPropertySet>();
+
+        internal List<AnimationController> ControllerList { get; } = new List<AnimationController>();
+
+        internal List<string> StringList { get; } = new List<string>();
+
+        /// <summary>
+        /// Walks the graph rooted at <paramref name="root"/> and returns the resulting index.
+        /// </summary>
+        /// <param name="root">The root visual of the graph.</param>
+        /// <returns>An indexer holding every node reachable from <paramref name="root"/>.</returns>
+        internal static GraphIndexer Index(Visual root)
+        {
+            var result = new GraphIndexer();
+            result.GetVisual(root);
+            return result;
+        }
+
+        /// <summary>
+        /// Returns the index of a string, adding it to the string table if necessary.
+        /// </summary>
+        /// <param name="value">The string, or null.</param>
+        /// <returns>The index of the string, or <see cref="Format.NullIndex"/> if null.</returns>
+        internal uint GetString(string? value)
+        {
+            if (value is null)
+            {
+                return Format.NullIndex;
+            }
+
+            if (!_strings.TryGetValue(value, out var index))
+            {
+                index = StringList.Count;
+                StringList.Add(value);
+                _strings.Add(value, index);
+            }
+
+            return (uint)index;
+        }
+
+        internal uint GetVisual(Visual? value) => Reference(_visuals, value, Schema.ObjectCategory.Visual);
+
+        internal uint GetShape(CompositionShape? value) => Reference(_shapes, value, Schema.ObjectCategory.Shape);
+
+        internal uint GetGeometry(CompositionGeometry? value) => Reference(_geometries, value, Schema.ObjectCategory.Geometry);
+
+        internal uint GetCanvasGeometry(CanvasGeometry? value) => Index(_canvasGeometries, value);
+
+        internal uint GetBrush(CompositionBrush? value) => Reference(_brushes, value, Schema.ObjectCategory.Brush);
+
+        internal uint GetGradientStop(CompositionColorGradientStop? value) => Index(_gradientStops, value);
+
+        internal uint GetViewBox(CompositionViewBox? value) => Index(_viewBoxes, value);
+
+        internal uint GetClip(CompositionClip? value) => Index(_clips, value);
+
+        internal uint GetShadow(CompositionShadow? value) => Index(_shadows, value);
+
+        internal uint GetSurface(ICompositionSurface? value) => Index(_surfaces, value);
+
+        internal uint GetEffect(GraphicsEffectBase? value) => Index(_effects, value);
+
+        internal uint GetEasing(CompositionEasingFunction? value) => Index(_easings, value);
+
+        internal uint GetAnimation(CompositionAnimation? value) => Index(_animations, value);
+
+        internal uint GetPropertySet(CompositionPropertySet? value) => Index(_propertySets, value);
+
+        internal uint GetController(AnimationController? value) => Index(_controllers, value);
+
+        /// <summary>
+        /// Returns the index of an already-discovered object as a packed object reference.
+        /// Used for the fields that can refer to any kind of object, such as the target of
+        /// an animation reference parameter.
+        /// </summary>
+        /// <param name="value">The object, or null.</param>
+        /// <returns>The packed object reference, or <see cref="Format.NullIndex"/>.</returns>
+        internal uint GetObjectReference(CompositionObject? value)
+        {
+            switch (value)
+            {
+                case null: return Format.NullIndex;
+                case Visual visual: return GetVisual(visual);
+                case CompositionShape shape: return GetShape(shape);
+                case CompositionGeometry geometry: return GetGeometry(geometry);
+                case CompositionBrush brush: return GetBrush(brush);
+                case CompositionAnimation animation:
+                    return Format.PackObjectReference(Schema.ObjectCategory.Animation, (int)GetAnimation(animation));
+                case CompositionEasingFunction easing:
+                    return Format.PackObjectReference(Schema.ObjectCategory.Easing, (int)GetEasing(easing));
+                case CompositionPropertySet propertySet:
+                    return Format.PackObjectReference(Schema.ObjectCategory.PropertySet, (int)GetPropertySet(propertySet));
+                case CompositionVisualSurface surface:
+                    return Format.PackObjectReference(Schema.ObjectCategory.Surface, (int)GetSurface(surface));
+                case CompositionClip clip:
+                    return Format.PackObjectReference(Schema.ObjectCategory.Clip, (int)GetClip(clip));
+                case AnimationController controller:
+                    return Format.PackObjectReference(Schema.ObjectCategory.Controller, (int)GetController(controller));
+                case CompositionShadow shadow:
+                    return Format.PackObjectReference(Schema.ObjectCategory.Shadow, (int)GetShadow(shadow));
+                case CompositionColorGradientStop stop:
+                    return Format.PackObjectReference(Schema.ObjectCategory.GradientStop, (int)GetGradientStop(stop));
+                case CompositionViewBox viewBox:
+                    return Format.PackObjectReference(Schema.ObjectCategory.ViewBox, (int)GetViewBox(viewBox));
+                default:
+                    throw new InvalidOperationException($"Cannot reference {value.Type}.");
+            }
+        }
+
+        // Returns the packed object reference for a node in a category whose index is
+        // also used directly by strongly typed fields.
+        uint Reference<T>(Dictionary<object, int> map, T? value, Schema.ObjectCategory category)
+            where T : class
+            => value is null ? Format.NullIndex : Format.PackObjectReference(category, (int)Index(map, value));
+
+        // Returns the plain index of a node, adding it to the graph if it has not been
+        // seen before. The node is registered before its children are walked so that
+        // cycles terminate.
+        uint Index<T>(Dictionary<object, int> map, T? value)
+            where T : class
+        {
+            if (value is null)
+            {
+                return Format.NullIndex;
+            }
+
+            if (map.TryGetValue(value, out var existing))
+            {
+                return (uint)existing;
+            }
+
+            var index = map.Count;
+            map.Add(value, index);
+            Add(value, index);
+            return (uint)index;
+        }
+
+        // Appends a newly discovered node to its category list and walks its children.
+        void Add(object value, int index)
+        {
+            switch (value)
+            {
+                case Visual visual:
+                    VisualList.Add(visual);
+                    WalkVisual(visual);
+                    break;
+                case CompositionShape shape:
+                    ShapeList.Add(shape);
+                    WalkShape(shape);
+                    break;
+                case CompositionGeometry geometry:
+                    GeometryList.Add(geometry);
+                    WalkGeometry(geometry);
+                    break;
+                case CanvasGeometry canvasGeometry:
+                    CanvasGeometryList.Add(canvasGeometry);
+                    WalkCanvasGeometry(canvasGeometry);
+                    break;
+                case CompositionBrush brush:
+                    BrushList.Add(brush);
+                    WalkBrush(brush);
+                    break;
+                case CompositionColorGradientStop stop:
+                    GradientStopList.Add(stop);
+                    WalkCompositionObject(stop);
+                    break;
+                case CompositionViewBox viewBox:
+                    ViewBoxList.Add(viewBox);
+                    WalkCompositionObject(viewBox);
+                    break;
+                case CompositionClip clip:
+                    ClipList.Add(clip);
+                    WalkClip(clip);
+                    break;
+                case CompositionShadow shadow:
+                    ShadowList.Add(shadow);
+                    WalkShadow(shadow);
+                    break;
+                case ICompositionSurface surface:
+                    SurfaceList.Add(surface);
+                    WalkSurface(surface);
+                    break;
+                case GraphicsEffectBase effect:
+                    EffectList.Add(effect);
+                    break;
+                case CompositionEasingFunction easing:
+                    EasingList.Add(easing);
+                    WalkCompositionObject(easing);
+                    break;
+                case CompositionAnimation animation:
+                    AnimationList.Add(animation);
+                    WalkAnimation(animation);
+                    break;
+                case CompositionPropertySet propertySet:
+                    PropertySetList.Add(propertySet);
+                    WalkPropertySet(propertySet);
+                    break;
+                case AnimationController controller:
+                    ControllerList.Add(controller);
+                    WalkController(controller);
+                    break;
+                default:
+                    throw new InvalidOperationException($"Unexpected node {value.GetType().Name}.");
+            }
+        }
+
+        // Walks the state that every CompositionObject has: its comment, its animators,
+        // and its property set.
+        void WalkCompositionObject(CompositionObject value)
+        {
+            GetString(value.Comment);
+
+            foreach (var animator in value.Animators)
+            {
+                GetString(animator.AnimatedProperty);
+                GetAnimation(animator.Animation);
+                GetController(animator.Controller);
+            }
+
+            // A property set is only serialized if it carries state. The property set of a
+            // property set is itself, so recursing into it unconditionally would not
+            // terminate.
+            if (value.Type != CompositionObjectType.CompositionPropertySet && HasState(value.Properties))
+            {
+                GetPropertySet(value.Properties);
+            }
+        }
+
+        internal static bool HasState(CompositionPropertySet propertySet)
+        {
+            if (propertySet.Names.Count > 0)
+            {
+                return true;
+            }
+
+            foreach (var unused in propertySet.Animators)
+            {
+                return true;
+            }
+
+            return propertySet.Comment is not null;
+        }
+
+        void WalkVisual(Visual value)
+        {
+            WalkCompositionObject(value);
+            GetClip(value.Clip);
+
+            switch (value)
+            {
+                case ShapeVisual shapeVisual:
+                    foreach (var shape in shapeVisual.Shapes)
+                    {
+                        GetShape(shape);
+                    }
+
+                    GetViewBox(shapeVisual.ViewBox);
+                    break;
+                case SpriteVisual spriteVisual:
+                    GetBrush(spriteVisual.Brush);
+                    GetShadow(spriteVisual.Shadow);
+                    break;
+                case LayerVisual layerVisual:
+                    GetShadow(layerVisual.Shadow);
+                    break;
+            }
+
+            if (value is ContainerVisual container)
+            {
+                foreach (var child in container.Children)
+                {
+                    GetVisual(child);
+                }
+            }
+        }
+
+        void WalkShape(CompositionShape value)
+        {
+            WalkCompositionObject(value);
+
+            switch (value)
+            {
+                case CompositionContainerShape containerShape:
+                    foreach (var shape in containerShape.Shapes)
+                    {
+                        GetShape(shape);
+                    }
+
+                    break;
+                case CompositionSpriteShape spriteShape:
+                    GetBrush(spriteShape.FillBrush);
+                    GetBrush(spriteShape.StrokeBrush);
+                    GetGeometry(spriteShape.Geometry);
+                    break;
+            }
+        }
+
+        void WalkGeometry(CompositionGeometry value)
+        {
+            WalkCompositionObject(value);
+
+            if (value is CompositionPathGeometry pathGeometry && pathGeometry.Path is not null)
+            {
+                GetCanvasGeometry((CanvasGeometry)pathGeometry.Path.Source);
+            }
+        }
+
+        void WalkCanvasGeometry(CanvasGeometry value)
+        {
+            switch (value)
+            {
+                case CanvasGeometry.Combination combination:
+                    GetCanvasGeometry(combination.A);
+                    GetCanvasGeometry(combination.B);
+                    break;
+                case CanvasGeometry.Group group:
+                    foreach (var geometry in group.Geometries)
+                    {
+                        GetCanvasGeometry(geometry);
+                    }
+
+                    break;
+                case CanvasGeometry.TransformedGeometry transformed:
+                    GetCanvasGeometry(transformed.SourceGeometry);
+                    break;
+            }
+        }
+
+        void WalkBrush(CompositionBrush value)
+        {
+            WalkCompositionObject(value);
+
+            switch (value)
+            {
+                case CompositionGradientBrush gradientBrush:
+                    foreach (var stop in gradientBrush.ColorStops)
+                    {
+                        GetGradientStop(stop);
+                    }
+
+                    break;
+                case CompositionSurfaceBrush surfaceBrush:
+                    GetSurface(surfaceBrush.Surface);
+                    break;
+                case CompositionMaskBrush maskBrush:
+                    GetBrush(maskBrush.Source);
+                    GetBrush(maskBrush.Mask);
+                    break;
+                case CompositionEffectBrush effectBrush:
+                    var effect = effectBrush.GetEffectFactory().Effect;
+                    GetEffect(effect);
+                    foreach (var source in effect.Sources)
+                    {
+                        GetString(source.Name);
+                        GetBrush(effectBrush.GetSourceParameter(source.Name));
+                    }
+
+                    break;
+            }
+        }
+
+        void WalkClip(CompositionClip value)
+        {
+            WalkCompositionObject(value);
+
+            if (value is CompositionGeometricClip geometricClip)
+            {
+                GetGeometry(geometricClip.Geometry);
+            }
+        }
+
+        void WalkShadow(CompositionShadow value)
+        {
+            WalkCompositionObject(value);
+
+            if (value is DropShadow dropShadow)
+            {
+                GetBrush(dropShadow.Mask);
+            }
+        }
+
+        void WalkSurface(ICompositionSurface value)
+        {
+            switch (value)
+            {
+                case CompositionVisualSurface visualSurface:
+                    WalkCompositionObject(visualSurface);
+                    GetVisual(visualSurface.SourceVisual);
+                    break;
+                case LoadedImageSurfaceFromUri fromUri:
+                    GetString(fromUri.Uri.ToString());
+                    break;
+            }
+        }
+
+        void WalkAnimation(CompositionAnimation value)
+        {
+            WalkCompositionObject(value);
+            GetString(value.Target);
+
+            foreach (var parameter in value.ReferenceParameters)
+            {
+                GetString(parameter.Key);
+                GetObjectReference(parameter.Value);
+            }
+
+            switch (value)
+            {
+                case ExpressionAnimation expressionAnimation:
+                    GetString(expressionAnimation.Expression.ToText());
+                    break;
+                case KeyFrameAnimation_ keyFrameAnimation:
+                    foreach (var keyFrame in keyFrameAnimation.KeyFrames)
+                    {
+                        GetEasing(keyFrame.Easing);
+
+                        switch (keyFrame)
+                        {
+                            case KeyFrameAnimation_.ExpressionKeyFrame expressionKeyFrame:
+                                GetString(expressionKeyFrame.Expression.ToText());
+                                break;
+                            case KeyFrameAnimation<CompositionPath, WinCompData.Expressions.Void>.ValueKeyFrame pathKeyFrame:
+                                GetCanvasGeometry((CanvasGeometry)pathKeyFrame.Value.Source);
+                                break;
+                        }
+                    }
+
+                    break;
+            }
+        }
+
+        void WalkPropertySet(CompositionPropertySet value)
+        {
+            GetString(value.Comment);
+
+            foreach (var animator in value.Animators)
+            {
+                GetString(animator.AnimatedProperty);
+                GetAnimation(animator.Animation);
+                GetController(animator.Controller);
+            }
+
+            foreach (var name in value.Names)
+            {
+                GetString(name.Key);
+            }
+
+            if (value.Owner is not null)
+            {
+                GetObjectReference(value.Owner);
+            }
+        }
+
+        void WalkController(AnimationController value)
+        {
+            WalkCompositionObject(value);
+            GetString(value.TargetProperty);
+
+            if (value.TargetObject is not null)
+            {
+                GetObjectReference(value.TargetObject);
+            }
+        }
+
+        sealed class ReferenceComparer : IEqualityComparer<object>
+        {
+            internal static readonly ReferenceComparer Instance = new ReferenceComparer();
+
+            ReferenceComparer()
+            {
+            }
+
+            bool IEqualityComparer<object>.Equals(object? x, object? y) => ReferenceEquals(x, y);
+
+            int IEqualityComparer<object>.GetHashCode(object obj)
+                => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+        }
+    }
+}

From 41d71077789309b8da74edea7a2eefc4d5ed8adc Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 18:11:10 +0000
Subject: [PATCH 04/39] Add CompositionSerializer: WinCompData graph to
 FlatBuffer

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 .../CompDataFlatbuffer.projitems              |    1 +
 .../CompositionSerializer.cs                  | 1110 +++++++++++++++++
 source/CompDataFlatbuffer/GraphIndexer.cs     |   62 +-
 3 files changed, 1137 insertions(+), 36 deletions(-)
 create mode 100644 source/CompDataFlatbuffer/CompositionSerializer.cs

diff --git a/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems b/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
index 57f9979a..074a62df 100644
--- a/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
+++ b/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
@@ -11,6 +11,7 @@
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)Format.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)GraphIndexer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)CompositionSerializer.cs" />
   </ItemGroup>
   <ItemGroup>
     <!-- Generated by build/RegenerateFlatbuffers.ps1 from source/LottieFlatbuffer/lottie_comp.fbs.
diff --git a/source/CompDataFlatbuffer/CompositionSerializer.cs b/source/CompDataFlatbuffer/CompositionSerializer.cs
new file mode 100644
index 00000000..19260209
--- /dev/null
+++ b/source/CompDataFlatbuffer/CompositionSerializer.cs
@@ -0,0 +1,1110 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using CommunityToolkit.WinUI.Lottie.CompMetadata;
+using CommunityToolkit.WinUI.Lottie.LottieMetadata;
+using CommunityToolkit.WinUI.Lottie.WinCompData;
+using CommunityToolkit.WinUI.Lottie.WinCompData.MetaData;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgce;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg;
+using CommunityToolkit.WinUI.Lottie.WinUIXamlMediaData;
+using Google.FlatBuffers;
+using Expressions = CommunityToolkit.WinUI.Lottie.WinCompData.Expressions;
+using Fb = CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema;
+using Wui = CommunityToolkit.WinUI.Lottie.WinCompData.Wui;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
+{
+    /// <summary>
+    /// Serializes a translated Lottie animation - a WinCompData object graph - into the
+    /// FlatBuffers format described by lottie_comp.fbs.
+    /// </summary>
+    /// <remarks>
+    /// The output is deterministic: serializing the same graph twice produces byte
+    /// identical results.
+    /// </remarks>
+#if PUBLIC_CompDataFlatbuffer
+    public
+#endif
+    static class CompositionSerializer
+    {
+        /// <summary>
+        /// Serializes a WinCompData graph into a FlatBuffer.
+        /// </summary>
+        /// <param name="root">The root visual of the graph.</param>
+        /// <param name="requiredUapVersion">The minimum UAP version required to instantiate the graph.</param>
+        /// <param name="metadata">Metadata describing the source Lottie animation, or null.</param>
+        /// <param name="propertyBindings">The property bindings exposed by the graph, or null.</param>
+        /// <returns>The serialized graph.</returns>
+        public static byte[] Serialize(
+            Visual root,
+            ushort requiredUapVersion,
+            LottieCompositionMetadata? metadata = null,
+            IReadOnlyList<PropertyBinding>? propertyBindings = null)
+        {
+            if (root is null)
+            {
+                throw new ArgumentNullException(nameof(root));
+            }
+
+            var graph = GraphIndexer.Index(root);
+
+            // 1024 is a starting size only - the builder grows as needed.
+            var builder = new FlatBufferBuilder(1024);
+
+            // Strings are created first because a string cannot be created while a table
+            // is under construction, and almost every table refers to one.
+            var strings = new StringOffset[graph.StringList.Count];
+            for (var i = 0; i < strings.Length; i++)
+            {
+                strings[i] = builder.CreateString(graph.StringList[i]);
+            }
+
+            // The node lists grow as the graph is walked, so they are indexed by position
+            // rather than iterated, and the walk is complete before serialization starts.
+            var visuals = Map(graph.VisualList, v => WriteVisual(builder, graph, v));
+            var shapes = Map(graph.ShapeList, v => WriteShape(builder, graph, v));
+            var geometries = Map(graph.GeometryList, v => WriteGeometry(builder, graph, v));
+            var canvasGeometries = Map(graph.CanvasGeometryList, v => WriteCanvasGeometry(builder, graph, v));
+            var brushes = Map(graph.BrushList, v => WriteBrush(builder, graph, v));
+            var gradientStops = Map(graph.GradientStopList, v => WriteGradientStop(builder, graph, v));
+            var viewBoxes = Map(graph.ViewBoxList, v => WriteViewBox(builder, graph, v));
+            var clips = Map(graph.ClipList, v => WriteClip(builder, graph, v));
+            var shadows = Map(graph.ShadowList, v => WriteShadow(builder, graph, v));
+            var surfaces = Map(graph.SurfaceList, v => WriteSurface(builder, graph, v, strings));
+            var effects = Map(graph.EffectList, v => WriteEffect(builder, graph, v));
+            var easings = Map(graph.EasingList, v => WriteEasing(builder, graph, v));
+            var animations = Map(graph.AnimationList, v => WriteAnimation(builder, graph, v));
+            var propertySets = Map(graph.PropertySetList, v => WritePropertySet(builder, graph, v));
+            var controllers = Map(graph.ControllerList, v => WriteController(builder, graph, v));
+
+            var metadataOffset = WriteMetadata(builder, graph, metadata, propertyBindings);
+
+            // The indices of the controllers that a host must supply, in index order.
+            var customControllers = graph.ControllerList
+                .Select((controller, index) => (controller, index))
+                .Where(x => x.controller.IsCustom)
+                .Select(x => (uint)x.index)
+                .ToArray();
+
+            var stringsVector = Fb.LottieComposition.CreateStringsVector(builder, strings);
+            var visualsVector = Fb.LottieComposition.CreateVisualsVector(builder, visuals);
+            var shapesVector = Fb.LottieComposition.CreateShapesVector(builder, shapes);
+            var geometriesVector = Fb.LottieComposition.CreateGeometriesVector(builder, geometries);
+            var canvasGeometriesVector = Fb.LottieComposition.CreateCanvasGeometriesVector(builder, canvasGeometries);
+            var brushesVector = Fb.LottieComposition.CreateBrushesVector(builder, brushes);
+            var gradientStopsVector = Fb.LottieComposition.CreateGradientStopsVector(builder, gradientStops);
+            var viewBoxesVector = Fb.LottieComposition.CreateViewBoxesVector(builder, viewBoxes);
+            var clipsVector = Fb.LottieComposition.CreateClipsVector(builder, clips);
+            var shadowsVector = Fb.LottieComposition.CreateShadowsVector(builder, shadows);
+            var surfacesVector = Fb.LottieComposition.CreateSurfacesVector(builder, surfaces);
+            var effectsVector = Fb.LottieComposition.CreateEffectsVector(builder, effects);
+            var easingsVector = Fb.LottieComposition.CreateEasingsVector(builder, easings);
+            var animationsVector = Fb.LottieComposition.CreateAnimationsVector(builder, animations);
+            var propertySetsVector = Fb.LottieComposition.CreatePropertySetsVector(builder, propertySets);
+            var controllersVector = Fb.LottieComposition.CreateControllersVector(builder, controllers);
+            var customControllersVector = Fb.LottieComposition.CreateCustomControllersVector(builder, customControllers);
+
+            Fb.LottieComposition.StartLottieComposition(builder);
+            Fb.LottieComposition.AddSchemaVersion(builder, Format.Version);
+            Fb.LottieComposition.AddRequiredUapVersion(builder, requiredUapVersion);
+            Fb.LottieComposition.AddMetadata(builder, metadataOffset);
+            Fb.LottieComposition.AddRootVisual(builder, graph.GetVisual(root));
+            Fb.LottieComposition.AddStrings(builder, stringsVector);
+            Fb.LottieComposition.AddVisuals(builder, visualsVector);
+            Fb.LottieComposition.AddShapes(builder, shapesVector);
+            Fb.LottieComposition.AddGeometries(builder, geometriesVector);
+            Fb.LottieComposition.AddCanvasGeometries(builder, canvasGeometriesVector);
+            Fb.LottieComposition.AddBrushes(builder, brushesVector);
+            Fb.LottieComposition.AddGradientStops(builder, gradientStopsVector);
+            Fb.LottieComposition.AddViewBoxes(builder, viewBoxesVector);
+            Fb.LottieComposition.AddClips(builder, clipsVector);
+            Fb.LottieComposition.AddShadows(builder, shadowsVector);
+            Fb.LottieComposition.AddSurfaces(builder, surfacesVector);
+            Fb.LottieComposition.AddEffects(builder, effectsVector);
+            Fb.LottieComposition.AddEasings(builder, easingsVector);
+            Fb.LottieComposition.AddAnimations(builder, animationsVector);
+            Fb.LottieComposition.AddPropertySets(builder, propertySetsVector);
+            Fb.LottieComposition.AddControllers(builder, controllersVector);
+            Fb.LottieComposition.AddCustomControllers(builder, customControllersVector);
+            var composition = Fb.LottieComposition.EndLottieComposition(builder);
+
+            Fb.LottieComposition.FinishLottieCompositionBuffer(builder, composition);
+
+            return builder.SizedByteArray();
+        }
+
+        static TResult[] Map<T, TResult>(List<T> source, Func<T, TResult> selector)
+        {
+            // The list is indexed rather than enumerated because writing a node can
+            // never add to it - the graph walk completed before serialization started.
+            var result = new TResult[source.Count];
+            for (var i = 0; i < source.Count; i++)
+            {
+                result[i] = selector(source[i]);
+            }
+
+            return result;
+        }
+
+        // ---------------------------------------------------------------------
+        // Shared state.
+        // ---------------------------------------------------------------------
+        // Writes the CompositionObject state shared by every node, or returns a null
+        // offset if the object carries none of it.
+        static Offset<Fb.CompObj> WriteCompObj(FlatBufferBuilder builder, GraphIndexer graph, CompositionObject value)
+        {
+            var comment = graph.GetString(value.Comment);
+
+            var animators = value.Animators.ToArray();
+            var animatorOffsets = new Offset<Fb.Animator>[animators.Length];
+            for (var i = 0; i < animators.Length; i++)
+            {
+                var animator = animators[i];
+                Fb.Animator.StartAnimator(builder);
+                Fb.Animator.AddProperty(builder, graph.GetString(animator.AnimatedProperty));
+                Fb.Animator.AddAnimation(builder, graph.GetAnimation(animator.Animation));
+                Fb.Animator.AddController(builder, graph.GetController(animator.Controller));
+                animatorOffsets[i] = Fb.Animator.EndAnimator(builder);
+            }
+
+            // The property set of a property set is itself, so it is never written as a
+            // nested reference.
+            var properties = value.Type != CompositionObjectType.CompositionPropertySet && GraphIndexer.HasState(value.Properties)
+                ? graph.GetPropertySet(value.Properties)
+                : Format.NullIndex;
+
+            if (comment == Format.NullIndex && animators.Length == 0 && properties == Format.NullIndex)
+            {
+                return default;
+            }
+
+            var animatorsVector = animators.Length == 0
+                ? default
+                : Fb.CompObj.CreateAnimatorsVector(builder, animatorOffsets);
+
+            Fb.CompObj.StartCompObj(builder);
+            Fb.CompObj.AddComment(builder, comment);
+
+            if (animators.Length > 0)
+            {
+                Fb.CompObj.AddAnimators(builder, animatorsVector);
+            }
+
+            Fb.CompObj.AddProperties(builder, properties);
+            return Fb.CompObj.EndCompObj(builder);
+        }
+
+        static void AddBase(FlatBufferBuilder builder, Offset<Fb.CompObj> value, Action<FlatBufferBuilder, Offset<Fb.CompObj>> add)
+        {
+            if (value.Value != 0)
+            {
+                add(builder, value);
+            }
+        }
+
+        // ---------------------------------------------------------------------
+        // Nodes.
+        // ---------------------------------------------------------------------
+        static Offset<Fb.Visual> WriteVisual(FlatBufferBuilder builder, GraphIndexer graph, Visual value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            var children = value is ContainerVisual container && container.Children.Count > 0
+                ? Fb.Visual.CreateChildrenVector(builder, container.Children.Select(graph.GetVisual).ToArray())
+                : default;
+
+            var shapes = value is ShapeVisual shapeVisual && shapeVisual.Shapes.Count > 0
+                ? Fb.Visual.CreateShapesVector(builder, shapeVisual.Shapes.Select(graph.GetShape).ToArray())
+                : default;
+
+            Fb.Visual.StartVisual(builder);
+            AddBase(builder, compObj, Fb.Visual.AddBase);
+            Fb.Visual.AddKind(builder, value switch
+            {
+                ShapeVisual _ => Fb.VisualKind.Shape,
+                SpriteVisual _ => Fb.VisualKind.Sprite,
+                LayerVisual _ => Fb.VisualKind.Layer,
+                _ => Fb.VisualKind.Container,
+            });
+
+            Fb.Visual.AddBorderMode(builder, (byte?)value.BorderMode);
+            AddVec3(builder, value.CenterPoint, Fb.Visual.AddCenterPoint);
+            Fb.Visual.AddClip(builder, graph.GetClip(value.Clip));
+            Fb.Visual.AddIsVisible(builder, value.IsVisible);
+            AddVec3(builder, value.Offset, Fb.Visual.AddOffset);
+            Fb.Visual.AddOpacity(builder, value.Opacity);
+            Fb.Visual.AddRotationAngleInDegrees(builder, value.RotationAngleInDegrees);
+            AddVec3(builder, value.RotationAxis, Fb.Visual.AddRotationAxis);
+            AddVec3(builder, value.Scale, Fb.Visual.AddScale);
+            AddVec2(builder, value.Size, Fb.Visual.AddSize);
+            AddMat4x4(builder, value.TransformMatrix, Fb.Visual.AddTransformMatrix);
+
+            if (children.Value != 0)
+            {
+                Fb.Visual.AddChildren(builder, children);
+            }
+
+            if (shapes.Value != 0)
+            {
+                Fb.Visual.AddShapes(builder, shapes);
+            }
+
+            switch (value)
+            {
+                case ShapeVisual shape:
+                    Fb.Visual.AddViewBox(builder, graph.GetViewBox(shape.ViewBox));
+                    break;
+                case SpriteVisual sprite:
+                    Fb.Visual.AddBrush(builder, graph.GetBrush(sprite.Brush));
+                    Fb.Visual.AddShadow(builder, graph.GetShadow(sprite.Shadow));
+                    break;
+                case LayerVisual layer:
+                    Fb.Visual.AddShadow(builder, graph.GetShadow(layer.Shadow));
+                    break;
+            }
+
+            return Fb.Visual.EndVisual(builder);
+        }
+
+        static Offset<Fb.Shape> WriteShape(FlatBufferBuilder builder, GraphIndexer graph, CompositionShape value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            var shapes = value is CompositionContainerShape containerShape && containerShape.Shapes.Count > 0
+                ? Fb.Shape.CreateShapesVector(builder, containerShape.Shapes.Select(graph.GetShape).ToArray())
+                : default;
+
+            var spriteShape = value as CompositionSpriteShape;
+
+            var strokeDashArray = spriteShape is not null && spriteShape.StrokeDashArray.Count > 0
+                ? Fb.Shape.CreateStrokeDashArrayVector(builder, spriteShape.StrokeDashArray.ToArray())
+                : default;
+
+            Fb.Shape.StartShape(builder);
+            AddBase(builder, compObj, Fb.Shape.AddBase);
+            Fb.Shape.AddKind(builder, spriteShape is not null ? Fb.ShapeKind.Sprite : Fb.ShapeKind.Container);
+
+            AddVec2(builder, value.CenterPoint, Fb.Shape.AddCenterPoint);
+            AddVec2(builder, value.Offset, Fb.Shape.AddOffset);
+            Fb.Shape.AddRotationAngleInDegrees(builder, value.RotationAngleInDegrees);
+            AddVec2(builder, value.Scale, Fb.Shape.AddScale);
+            AddMat3x2(builder, value.TransformMatrix, Fb.Shape.AddTransformMatrix);
+
+            if (shapes.Value != 0)
+            {
+                Fb.Shape.AddShapes(builder, shapes);
+            }
+
+            if (spriteShape is not null)
+            {
+                Fb.Shape.AddFillBrush(builder, graph.GetBrush(spriteShape.FillBrush));
+                Fb.Shape.AddStrokeBrush(builder, graph.GetBrush(spriteShape.StrokeBrush));
+                Fb.Shape.AddGeometry(builder, graph.GetGeometry(spriteShape.Geometry));
+                Fb.Shape.AddIsStrokeNonScaling(builder, spriteShape.IsStrokeNonScaling);
+                Fb.Shape.AddStrokeDashOffset(builder, spriteShape.StrokeDashOffset);
+
+                if (strokeDashArray.Value != 0)
+                {
+                    Fb.Shape.AddStrokeDashArray(builder, strokeDashArray);
+                }
+
+                Fb.Shape.AddStrokeDashCap(builder, (byte?)spriteShape.StrokeDashCap);
+                Fb.Shape.AddStrokeStartCap(builder, (byte?)spriteShape.StrokeStartCap);
+                Fb.Shape.AddStrokeEndCap(builder, (byte?)spriteShape.StrokeEndCap);
+                Fb.Shape.AddStrokeLineJoin(builder, (byte?)spriteShape.StrokeLineJoin);
+                Fb.Shape.AddStrokeMiterLimit(builder, spriteShape.StrokeMiterLimit);
+                Fb.Shape.AddStrokeThickness(builder, spriteShape.StrokeThickness);
+            }
+
+            return Fb.Shape.EndShape(builder);
+        }
+
+        static Offset<Fb.Geometry> WriteGeometry(FlatBufferBuilder builder, GraphIndexer graph, CompositionGeometry value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            Fb.Geometry.StartGeometry(builder);
+            AddBase(builder, compObj, Fb.Geometry.AddBase);
+            Fb.Geometry.AddKind(builder, value switch
+            {
+                CompositionRectangleGeometry _ => Fb.GeometryKind.Rectangle,
+                CompositionRoundedRectangleGeometry _ => Fb.GeometryKind.RoundedRectangle,
+                CompositionEllipseGeometry _ => Fb.GeometryKind.Ellipse,
+                _ => Fb.GeometryKind.Path,
+            });
+
+            Fb.Geometry.AddTrimStart(builder, value.TrimStart);
+            Fb.Geometry.AddTrimEnd(builder, value.TrimEnd);
+            Fb.Geometry.AddTrimOffset(builder, value.TrimOffset);
+
+            switch (value)
+            {
+                case CompositionPathGeometry path:
+                    Fb.Geometry.AddPath(
+                        builder,
+                        path.Path is null
+                            ? Format.NullIndex
+                            : graph.GetCanvasGeometry((CanvasGeometry)path.Path.Source));
+                    break;
+                case CompositionRectangleGeometry rectangle:
+                    AddVec2(builder, rectangle.Offset, Fb.Geometry.AddOffset);
+                    AddVec2(builder, rectangle.Size, Fb.Geometry.AddSize);
+                    break;
+                case CompositionRoundedRectangleGeometry roundedRectangle:
+                    AddVec2(builder, roundedRectangle.Offset, Fb.Geometry.AddOffset);
+                    AddVec2(builder, roundedRectangle.Size, Fb.Geometry.AddSize);
+                    AddVec2(builder, roundedRectangle.CornerRadius, Fb.Geometry.AddCornerRadius);
+                    break;
+                case CompositionEllipseGeometry ellipse:
+                    AddVec2(builder, ellipse.Center, Fb.Geometry.AddCenter);
+                    AddVec2(builder, ellipse.Radius, Fb.Geometry.AddRadius);
+                    break;
+            }
+
+            return Fb.Geometry.EndGeometry(builder);
+        }
+
+        static Offset<Fb.Brush> WriteBrush(FlatBufferBuilder builder, GraphIndexer graph, CompositionBrush value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            var gradientBrush = value as CompositionGradientBrush;
+
+            var colorStops = gradientBrush is not null && gradientBrush.ColorStops.Count > 0
+                ? Fb.Brush.CreateColorStopsVector(builder, gradientBrush.ColorStops.Select(graph.GetGradientStop).ToArray())
+                : default;
+
+            var sourceParameters = default(VectorOffset);
+            if (value is CompositionEffectBrush effectBrush)
+            {
+                var sources = effectBrush.GetEffectFactory().Effect.Sources;
+                var offsets = new Offset<Fb.SourceParameter>[sources.Count];
+                for (var i = 0; i < sources.Count; i++)
+                {
+                    var name = sources[i].Name;
+                    Fb.SourceParameter.StartSourceParameter(builder);
+                    Fb.SourceParameter.AddName(builder, graph.GetString(name));
+                    Fb.SourceParameter.AddBrush(builder, graph.GetBrush(effectBrush.GetSourceParameter(name)));
+                    offsets[i] = Fb.SourceParameter.EndSourceParameter(builder);
+                }
+
+                if (offsets.Length > 0)
+                {
+                    sourceParameters = Fb.Brush.CreateSourceParametersVector(builder, offsets);
+                }
+            }
+
+            Fb.Brush.StartBrush(builder);
+            AddBase(builder, compObj, Fb.Brush.AddBase);
+            Fb.Brush.AddKind(builder, value switch
+            {
+                CompositionLinearGradientBrush _ => Fb.BrushKind.LinearGradient,
+                CompositionRadialGradientBrush _ => Fb.BrushKind.RadialGradient,
+                CompositionSurfaceBrush _ => Fb.BrushKind.Surface,
+                CompositionMaskBrush _ => Fb.BrushKind.Mask,
+                CompositionEffectBrush _ => Fb.BrushKind.Effect,
+                _ => Fb.BrushKind.Color,
+            });
+
+            switch (value)
+            {
+                case CompositionColorBrush colorBrush:
+                    AddColor(builder, colorBrush.Color, Fb.Brush.AddColor);
+                    break;
+                case CompositionSurfaceBrush surfaceBrush:
+                    Fb.Brush.AddSurface(builder, graph.GetSurface(surfaceBrush.Surface));
+                    break;
+                case CompositionMaskBrush maskBrush:
+                    Fb.Brush.AddSource(builder, graph.GetBrush(maskBrush.Source));
+                    Fb.Brush.AddMask(builder, graph.GetBrush(maskBrush.Mask));
+                    break;
+                case CompositionEffectBrush effect:
+                    Fb.Brush.AddEffect(builder, graph.GetEffect(effect.GetEffectFactory().Effect));
+
+                    if (sourceParameters.Value != 0)
+                    {
+                        Fb.Brush.AddSourceParameters(builder, sourceParameters);
+                    }
+
+                    break;
+            }
+
+            if (gradientBrush is not null)
+            {
+                AddVec2(builder, gradientBrush.AnchorPoint, Fb.Brush.AddAnchorPoint);
+                AddVec2(builder, gradientBrush.CenterPoint, Fb.Brush.AddCenterPoint);
+
+                if (colorStops.Value != 0)
+                {
+                    Fb.Brush.AddColorStops(builder, colorStops);
+                }
+
+                Fb.Brush.AddExtendMode(builder, (byte?)gradientBrush.ExtendMode);
+                Fb.Brush.AddInterpolationSpace(builder, (byte?)gradientBrush.InterpolationSpace);
+                Fb.Brush.AddMappingMode(builder, (byte?)gradientBrush.MappingMode);
+                AddVec2(builder, gradientBrush.Offset, Fb.Brush.AddOffset);
+                Fb.Brush.AddRotationAngleInDegrees(builder, gradientBrush.RotationAngleInDegrees);
+                AddVec2(builder, gradientBrush.Scale, Fb.Brush.AddScale);
+                AddMat3x2(builder, gradientBrush.TransformMatrix, Fb.Brush.AddTransformMatrix);
+
+                switch (gradientBrush)
+                {
+                    case CompositionLinearGradientBrush linear:
+                        AddVec2(builder, linear.StartPoint, Fb.Brush.AddStartPoint);
+                        AddVec2(builder, linear.EndPoint, Fb.Brush.AddEndPoint);
+                        break;
+                    case CompositionRadialGradientBrush radial:
+                        AddVec2(builder, radial.EllipseCenter, Fb.Brush.AddEllipseCenter);
+                        AddVec2(builder, radial.EllipseRadius, Fb.Brush.AddEllipseRadius);
+                        AddVec2(builder, radial.GradientOriginOffset, Fb.Brush.AddGradientOriginOffset);
+                        break;
+                }
+            }
+
+            return Fb.Brush.EndBrush(builder);
+        }
+
+        static Offset<Fb.GradientStop> WriteGradientStop(FlatBufferBuilder builder, GraphIndexer graph, CompositionColorGradientStop value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            Fb.GradientStop.StartGradientStop(builder);
+            AddBase(builder, compObj, Fb.GradientStop.AddBase);
+            AddColor(builder, value.Color, Fb.GradientStop.AddColor);
+            Fb.GradientStop.AddOffset(builder, value.Offset);
+            return Fb.GradientStop.EndGradientStop(builder);
+        }
+
+        static Offset<Fb.ViewBox> WriteViewBox(FlatBufferBuilder builder, GraphIndexer graph, CompositionViewBox value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            Fb.ViewBox.StartViewBox(builder);
+            AddBase(builder, compObj, Fb.ViewBox.AddBase);
+            AddVec2(builder, value.Size, Fb.ViewBox.AddSize);
+            return Fb.ViewBox.EndViewBox(builder);
+        }
+
+        static Offset<Fb.Clip> WriteClip(FlatBufferBuilder builder, GraphIndexer graph, CompositionClip value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            Fb.Clip.StartClip(builder);
+            AddBase(builder, compObj, Fb.Clip.AddBase);
+            Fb.Clip.AddKind(builder, value is CompositionGeometricClip ? Fb.ClipKind.Geometric : Fb.ClipKind.Inset);
+            AddVec2(builder, value.CenterPoint, Fb.Clip.AddCenterPoint);
+            AddVec2(builder, value.Scale, Fb.Clip.AddScale);
+
+            switch (value)
+            {
+                case InsetClip inset:
+                    Fb.Clip.AddLeftInset(builder, inset.LeftInset);
+                    Fb.Clip.AddRightInset(builder, inset.RightInset);
+                    Fb.Clip.AddTopInset(builder, inset.TopInset);
+                    Fb.Clip.AddBottomInset(builder, inset.BottomInset);
+                    break;
+                case CompositionGeometricClip geometric:
+                    Fb.Clip.AddGeometry(builder, graph.GetGeometry(geometric.Geometry));
+                    break;
+            }
+
+            return Fb.Clip.EndClip(builder);
+        }
+
+        static Offset<Fb.Shadow> WriteShadow(FlatBufferBuilder builder, GraphIndexer graph, CompositionShadow value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            Fb.Shadow.StartShadow(builder);
+            AddBase(builder, compObj, Fb.Shadow.AddBase);
+            Fb.Shadow.AddKind(builder, Fb.ShadowKind.Drop);
+
+            if (value is DropShadow dropShadow)
+            {
+                Fb.Shadow.AddBlurRadius(builder, dropShadow.BlurRadius);
+                AddColor(builder, dropShadow.Color, Fb.Shadow.AddColor);
+                Fb.Shadow.AddMask(builder, graph.GetBrush(dropShadow.Mask));
+                AddVec3(builder, dropShadow.Offset, Fb.Shadow.AddOffset);
+                Fb.Shadow.AddOpacity(builder, dropShadow.Opacity);
+                Fb.Shadow.AddSourcePolicy(builder, (byte?)dropShadow.SourcePolicy);
+            }
+
+            return Fb.Shadow.EndShadow(builder);
+        }
+
+        static Offset<Fb.Surface> WriteSurface(FlatBufferBuilder builder, GraphIndexer graph, ICompositionSurface value, StringOffset[] strings)
+        {
+            var compObj = value is CompositionObject compositionObject
+                ? WriteCompObj(builder, graph, compositionObject)
+                : default;
+
+            var bytes = value is LoadedImageSurfaceFromStream fromStream
+                ? Fb.Surface.CreateBytesVector(builder, fromStream.Bytes)
+                : default;
+
+            Fb.Surface.StartSurface(builder);
+            AddBase(builder, compObj, Fb.Surface.AddBase);
+            Fb.Surface.AddKind(builder, value switch
+            {
+                LoadedImageSurfaceFromUri _ => Fb.SurfaceKind.LoadedImageFromUri,
+                LoadedImageSurfaceFromStream _ => Fb.SurfaceKind.LoadedImageFromStream,
+                _ => Fb.SurfaceKind.VisualSurface,
+            });
+
+            switch (value)
+            {
+                case CompositionVisualSurface visualSurface:
+                    Fb.Surface.AddSourceVisual(builder, graph.GetVisual(visualSurface.SourceVisual));
+                    AddVec2(builder, visualSurface.SourceSize, Fb.Surface.AddSourceSize);
+                    AddVec2(builder, visualSurface.SourceOffset, Fb.Surface.AddSourceOffset);
+                    break;
+                case LoadedImageSurfaceFromUri fromUri:
+                    Fb.Surface.AddUri(builder, graph.GetString(fromUri.Uri.ToString()));
+                    break;
+                case LoadedImageSurfaceFromStream _:
+                    Fb.Surface.AddBytes(builder, bytes);
+                    break;
+            }
+
+            return Fb.Surface.EndSurface(builder);
+        }
+
+        static Offset<Fb.Effect> WriteEffect(FlatBufferBuilder builder, GraphIndexer graph, GraphicsEffectBase value)
+        {
+            var sources = Fb.Effect.CreateSourcesVector(
+                builder,
+                value.Sources.Select(s => graph.GetString(s.Name)).ToArray());
+
+            Fb.Effect.StartEffect(builder);
+            Fb.Effect.AddKind(builder, value switch
+            {
+                GaussianBlurEffect _ => Fb.EffectKind.GaussianBlur,
+                _ => Fb.EffectKind.Composite,
+            });
+
+            Fb.Effect.AddSources(builder, sources);
+
+            switch (value)
+            {
+                case CompositeEffect composite:
+                    Fb.Effect.AddMode(builder, (byte)composite.Mode);
+                    break;
+                case GaussianBlurEffect blur:
+                    Fb.Effect.AddBlurAmount(builder, blur.BlurAmount);
+                    break;
+            }
+
+            return Fb.Effect.EndEffect(builder);
+        }
+
+        static Offset<Fb.Easing> WriteEasing(FlatBufferBuilder builder, GraphIndexer graph, CompositionEasingFunction value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            Fb.Easing.StartEasing(builder);
+            AddBase(builder, compObj, Fb.Easing.AddBase);
+            Fb.Easing.AddKind(builder, value switch
+            {
+                CubicBezierEasingFunction _ => Fb.EasingKind.CubicBezier,
+                StepEasingFunction _ => Fb.EasingKind.Step,
+                _ => Fb.EasingKind.Linear,
+            });
+
+            switch (value)
+            {
+                case CubicBezierEasingFunction cubicBezier:
+                    AddVec2(builder, cubicBezier.ControlPoint1, Fb.Easing.AddControlPoint1);
+                    AddVec2(builder, cubicBezier.ControlPoint2, Fb.Easing.AddControlPoint2);
+                    break;
+                case StepEasingFunction step:
+                    Fb.Easing.AddStepCount(builder, step.StepCount);
+                    Fb.Easing.AddInitialStep(builder, step.InitialStep);
+                    Fb.Easing.AddFinalStep(builder, step.FinalStep);
+                    Fb.Easing.AddIsInitialStepSingleFrame(builder, step.IsInitialStepSingleFrame);
+                    Fb.Easing.AddIsFinalStepSingleFrame(builder, step.IsFinalStepSingleFrame);
+                    break;
+            }
+
+            return Fb.Easing.EndEasing(builder);
+        }
+
+        static Offset<Fb.Animation> WriteAnimation(FlatBufferBuilder builder, GraphIndexer graph, CompositionAnimation value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            // ReferenceParameters is a dictionary, so it is sorted by name to keep the
+            // output deterministic.
+            var parameters = value.ReferenceParameters.OrderBy(p => p.Key, StringComparer.Ordinal).ToArray();
+            var parameterOffsets = new Offset<Fb.ReferenceParameter>[parameters.Length];
+            for (var i = 0; i < parameters.Length; i++)
+            {
+                Fb.ReferenceParameter.StartReferenceParameter(builder);
+                Fb.ReferenceParameter.AddName(builder, graph.GetString(parameters[i].Key));
+                Fb.ReferenceParameter.AddTarget(builder, graph.GetObjectReference(parameters[i].Value));
+                parameterOffsets[i] = Fb.ReferenceParameter.EndReferenceParameter(builder);
+            }
+
+            var parametersVector = parameters.Length == 0
+                ? default
+                : Fb.Animation.CreateReferenceParametersVector(builder, parameterOffsets);
+
+            var keyFramesVector = default(VectorOffset);
+            if (value is KeyFrameAnimation_ keyFrameAnimation)
+            {
+                var keyFrames = keyFrameAnimation.KeyFrames.ToArray();
+                var keyFrameOffsets = new Offset<Fb.KeyFrame>[keyFrames.Length];
+                for (var i = 0; i < keyFrames.Length; i++)
+                {
+                    keyFrameOffsets[i] = WriteKeyFrame(builder, graph, keyFrames[i]);
+                }
+
+                if (keyFrameOffsets.Length > 0)
+                {
+                    keyFramesVector = Fb.Animation.CreateKeyFramesVector(builder, keyFrameOffsets);
+                }
+            }
+
+            Fb.Animation.StartAnimation(builder);
+            AddBase(builder, compObj, Fb.Animation.AddBase);
+            Fb.Animation.AddKind(builder, value switch
+            {
+                ExpressionAnimation _ => Fb.AnimationKind.Expression,
+                ColorKeyFrameAnimation _ => Fb.AnimationKind.Color,
+                BooleanKeyFrameAnimation _ => Fb.AnimationKind.Boolean,
+                PathKeyFrameAnimation _ => Fb.AnimationKind.Path,
+                ScalarKeyFrameAnimation _ => Fb.AnimationKind.Scalar,
+                Vector2KeyFrameAnimation _ => Fb.AnimationKind.Vector2,
+                Vector3KeyFrameAnimation _ => Fb.AnimationKind.Vector3,
+                Vector4KeyFrameAnimation _ => Fb.AnimationKind.Vector4,
+                _ => throw new InvalidOperationException($"Unsupported animation {value.Type}."),
+            });
+
+            Fb.Animation.AddTarget(builder, graph.GetString(value.Target));
+
+            if (parametersVector.Value != 0)
+            {
+                Fb.Animation.AddReferenceParameters(builder, parametersVector);
+            }
+
+            if (value is ExpressionAnimation expressionAnimation)
+            {
+                Fb.Animation.AddExpression(builder, graph.GetString(expressionAnimation.Expression.ToText()));
+            }
+
+            if (value is KeyFrameAnimation_ keyFrames_)
+            {
+                Fb.Animation.AddDurationTicks(builder, keyFrames_.Duration.Ticks);
+
+                if (keyFramesVector.Value != 0)
+                {
+                    Fb.Animation.AddKeyFrames(builder, keyFramesVector);
+                }
+            }
+
+            if (value is ColorKeyFrameAnimation color)
+            {
+                Fb.Animation.AddInterpolationColorSpace(builder, (byte)color.InterpolationColorSpace);
+            }
+
+            return Fb.Animation.EndAnimation(builder);
+        }
+
+        static Offset<Fb.KeyFrame> WriteKeyFrame(FlatBufferBuilder builder, GraphIndexer graph, KeyFrameAnimation_.KeyFrame value)
+        {
+            Fb.KeyFrame.StartKeyFrame(builder);
+            Fb.KeyFrame.AddProgress(builder, value.Progress);
+            Fb.KeyFrame.AddEasing(builder, graph.GetEasing(value.Easing));
+            Fb.KeyFrame.AddKind(builder, value.Type == KeyFrameType.Expression ? Fb.KeyFrameKind.Expression : Fb.KeyFrameKind.Value);
+
+            switch (value)
+            {
+                case KeyFrameAnimation_.ExpressionKeyFrame expression:
+                    Fb.KeyFrame.AddExpression(builder, graph.GetString(expression.Expression.ToText()));
+                    break;
+                case KeyFrameAnimation<float, Expressions.Scalar>.ValueKeyFrame scalar:
+                    Fb.KeyFrame.AddScalar(builder, scalar.Value);
+                    break;
+                case KeyFrameAnimation<bool, Expressions.Boolean>.ValueKeyFrame boolean:
+                    Fb.KeyFrame.AddScalar(builder, boolean.Value ? 1f : 0f);
+                    break;
+                case KeyFrameAnimation<Vector2, Expressions.Vector2>.ValueKeyFrame vector2:
+                    Fb.KeyFrame.AddVector(builder, Fb.Vec4.CreateVec4(builder, vector2.Value.X, vector2.Value.Y, 0, 0));
+                    break;
+                case KeyFrameAnimation<Vector3, Expressions.Vector3>.ValueKeyFrame vector3:
+                    Fb.KeyFrame.AddVector(builder, Fb.Vec4.CreateVec4(builder, vector3.Value.X, vector3.Value.Y, vector3.Value.Z, 0));
+                    break;
+                case KeyFrameAnimation<Vector4, Expressions.Vector4>.ValueKeyFrame vector4:
+                    Fb.KeyFrame.AddVector(builder, Fb.Vec4.CreateVec4(builder, vector4.Value.X, vector4.Value.Y, vector4.Value.Z, vector4.Value.W));
+                    break;
+                case KeyFrameAnimation<Wui.Color, Expressions.Color>.ValueKeyFrame colorFrame:
+                    Fb.KeyFrame.AddColor(builder, CreateColor(builder, colorFrame.Value));
+                    break;
+                case KeyFrameAnimation<CompositionPath, Expressions.Void>.ValueKeyFrame path:
+                    Fb.KeyFrame.AddPath(builder, graph.GetCanvasGeometry((CanvasGeometry)path.Value.Source));
+                    break;
+            }
+
+            return Fb.KeyFrame.EndKeyFrame(builder);
+        }
+
+        static Offset<Fb.PropertySet> WritePropertySet(FlatBufferBuilder builder, GraphIndexer graph, CompositionPropertySet value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            // Names is a SortedDictionary, so enumeration order is already deterministic.
+            var names = value.Names.ToArray();
+            var valueOffsets = new Offset<Fb.PropertyValue>[names.Length];
+            for (var i = 0; i < names.Length; i++)
+            {
+                valueOffsets[i] = WritePropertyValue(builder, graph, value, names[i].Key, names[i].Value);
+            }
+
+            var valuesVector = names.Length == 0
+                ? default
+                : Fb.PropertySet.CreateValuesVector(builder, valueOffsets);
+
+            Fb.PropertySet.StartPropertySet(builder);
+            AddBase(builder, compObj, Fb.PropertySet.AddBase);
+            Fb.PropertySet.AddOwner(builder, graph.GetObjectReference(value.Owner));
+
+            if (valuesVector.Value != 0)
+            {
+                Fb.PropertySet.AddValues(builder, valuesVector);
+            }
+
+            return Fb.PropertySet.EndPropertySet(builder);
+        }
+
+        static Offset<Fb.PropertyValue> WritePropertyValue(
+            FlatBufferBuilder builder,
+            GraphIndexer graph,
+            CompositionPropertySet propertySet,
+            string name,
+            PropertySetValueType type)
+        {
+            Fb.PropertyValue.StartPropertyValue(builder);
+            Fb.PropertyValue.AddName(builder, graph.GetString(name));
+            Fb.PropertyValue.AddType(builder, (Fb.PropertyValueType)type);
+
+            switch (type)
+            {
+                case PropertySetValueType.Color:
+                    propertySet.TryGetColor(name, out var color);
+                    Fb.PropertyValue.AddColor(builder, CreateColor(builder, color!.Value));
+                    break;
+                case PropertySetValueType.Scalar:
+                    propertySet.TryGetScalar(name, out var scalar);
+                    Fb.PropertyValue.AddScalar(builder, scalar!.Value);
+                    break;
+                case PropertySetValueType.Vector2:
+                    propertySet.TryGetVector2(name, out var vector2);
+                    Fb.PropertyValue.AddVector(builder, Fb.Vec4.CreateVec4(builder, vector2!.Value.X, vector2.Value.Y, 0, 0));
+                    break;
+                case PropertySetValueType.Vector3:
+                    propertySet.TryGetVector3(name, out var vector3);
+                    Fb.PropertyValue.AddVector(builder, Fb.Vec4.CreateVec4(builder, vector3!.Value.X, vector3.Value.Y, vector3.Value.Z, 0));
+                    break;
+                case PropertySetValueType.Vector4:
+                    propertySet.TryGetVector4(name, out var vector4);
+                    Fb.PropertyValue.AddVector(builder, Fb.Vec4.CreateVec4(builder, vector4!.Value.X, vector4.Value.Y, vector4.Value.Z, vector4.Value.W));
+                    break;
+            }
+
+            return Fb.PropertyValue.EndPropertyValue(builder);
+        }
+
+        static Offset<Fb.Controller> WriteController(FlatBufferBuilder builder, GraphIndexer graph, AnimationController value)
+        {
+            var compObj = WriteCompObj(builder, graph, value);
+
+            Fb.Controller.StartController(builder);
+            AddBase(builder, compObj, Fb.Controller.AddBase);
+            Fb.Controller.AddTargetObject(builder, graph.GetObjectReference(value.TargetObject));
+            Fb.Controller.AddTargetProperty(builder, graph.GetString(value.TargetProperty));
+            Fb.Controller.AddIsPaused(builder, value.IsPaused);
+            Fb.Controller.AddIsCustom(builder, value.IsCustom);
+            return Fb.Controller.EndController(builder);
+        }
+
+        static Offset<Fb.CanvasGeometry> WriteCanvasGeometry(FlatBufferBuilder builder, GraphIndexer graph, CanvasGeometry value)
+        {
+            var geometries = value is CanvasGeometry.Group group
+                ? Fb.CanvasGeometry.CreateGeometriesVector(builder, group.Geometries.Select(graph.GetCanvasGeometry).ToArray())
+                : default;
+
+            var ops = default(VectorOffset);
+            var operands = default(VectorOffset);
+            if (value is CanvasGeometry.Path pathGeometry)
+            {
+                var (opBytes, operandFloats) = FlattenPath(pathGeometry);
+                ops = Fb.CanvasGeometry.CreateOpsVector(builder, opBytes);
+                operands = Fb.CanvasGeometry.CreateOperandsVector(builder, operandFloats);
+            }
+
+            Fb.CanvasGeometry.StartCanvasGeometry(builder);
+            Fb.CanvasGeometry.AddKind(builder, value.Type switch
+            {
+                CanvasGeometry.GeometryType.Combination => Fb.CanvasGeometryKind.Combination,
+                CanvasGeometry.GeometryType.Ellipse => Fb.CanvasGeometryKind.Ellipse,
+                CanvasGeometry.GeometryType.Group => Fb.CanvasGeometryKind.Group,
+                CanvasGeometry.GeometryType.RoundedRectangle => Fb.CanvasGeometryKind.RoundedRectangle,
+                CanvasGeometry.GeometryType.TransformedGeometry => Fb.CanvasGeometryKind.TransformedGeometry,
+                _ => Fb.CanvasGeometryKind.Path,
+            });
+
+            switch (value)
+            {
+                case CanvasGeometry.Combination combination:
+                    Fb.CanvasGeometry.AddA(builder, graph.GetCanvasGeometry(combination.A));
+                    Fb.CanvasGeometry.AddB(builder, graph.GetCanvasGeometry(combination.B));
+                    Fb.CanvasGeometry.AddCombineMode(builder, (byte)combination.CombineMode);
+                    AddMat3x2(builder, combination.Matrix, Fb.CanvasGeometry.AddMatrix);
+                    break;
+                case CanvasGeometry.TransformedGeometry transformed:
+                    Fb.CanvasGeometry.AddSource(builder, graph.GetCanvasGeometry(transformed.SourceGeometry));
+                    AddMat3x2(builder, transformed.TransformMatrix, Fb.CanvasGeometry.AddMatrix);
+                    break;
+                case CanvasGeometry.Group groupGeometry:
+                    Fb.CanvasGeometry.AddGeometries(builder, geometries);
+                    Fb.CanvasGeometry.AddFillRule(builder, (byte)groupGeometry.FilledRegionDetermination);
+                    break;
+                case CanvasGeometry.Path path:
+                    Fb.CanvasGeometry.AddFillRule(builder, (byte)path.FilledRegionDetermination);
+                    Fb.CanvasGeometry.AddOps(builder, ops);
+                    Fb.CanvasGeometry.AddOperands(builder, operands);
+                    break;
+                case CanvasGeometry.Ellipse ellipse:
+                    Fb.CanvasGeometry.AddX(builder, ellipse.X);
+                    Fb.CanvasGeometry.AddY(builder, ellipse.Y);
+                    Fb.CanvasGeometry.AddRadiusX(builder, ellipse.RadiusX);
+                    Fb.CanvasGeometry.AddRadiusY(builder, ellipse.RadiusY);
+                    break;
+                case CanvasGeometry.RoundedRectangle roundedRectangle:
+                    Fb.CanvasGeometry.AddX(builder, roundedRectangle.X);
+                    Fb.CanvasGeometry.AddY(builder, roundedRectangle.Y);
+                    Fb.CanvasGeometry.AddW(builder, roundedRectangle.W);
+                    Fb.CanvasGeometry.AddH(builder, roundedRectangle.H);
+                    Fb.CanvasGeometry.AddRadiusX(builder, roundedRectangle.RadiusX);
+                    Fb.CanvasGeometry.AddRadiusY(builder, roundedRectangle.RadiusY);
+                    break;
+            }
+
+            return Fb.CanvasGeometry.EndCanvasGeometry(builder);
+        }
+
+        // Flattens the command list of a path into an opcode stream and a parallel
+        // operand stream. This avoids a table per command, which would dominate the
+        // size of a typical animation.
+        static (byte[] Ops, float[] Operands) FlattenPath(CanvasGeometry.Path value)
+        {
+            var ops = new List<byte>(value.Commands.Length);
+            var operands = new List<float>(value.Commands.Length * 2);
+
+            foreach (var command in value.Commands)
+            {
+                switch (command)
+                {
+                    case CanvasPathBuilder.Command.BeginFigure begin:
+                        ops.Add((byte)Fb.PathOp.BeginFigure);
+                        operands.Add(begin.StartPoint.X);
+                        operands.Add(begin.StartPoint.Y);
+                        break;
+                    case CanvasPathBuilder.Command.EndFigure end:
+                        ops.Add((byte)Fb.PathOp.EndFigure);
+                        operands.Add((float)end.FigureLoop);
+                        break;
+                    case CanvasPathBuilder.Command.AddLine line:
+                        ops.Add((byte)Fb.PathOp.AddLine);
+                        operands.Add(line.EndPoint.X);
+                        operands.Add(line.EndPoint.Y);
+                        break;
+                    case CanvasPathBuilder.Command.AddCubicBezier bezier:
+                        ops.Add((byte)Fb.PathOp.AddCubicBezier);
+                        operands.Add(bezier.ControlPoint1.X);
+                        operands.Add(bezier.ControlPoint1.Y);
+                        operands.Add(bezier.ControlPoint2.X);
+                        operands.Add(bezier.ControlPoint2.Y);
+                        operands.Add(bezier.EndPoint.X);
+                        operands.Add(bezier.EndPoint.Y);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unsupported path command {command.Type}.");
+                }
+            }
+
+            return (ops.ToArray(), operands.ToArray());
+        }
+
+        static Offset<Fb.Metadata> WriteMetadata(
+            FlatBufferBuilder builder,
+            GraphIndexer graph,
+            LottieCompositionMetadata? metadata,
+            IReadOnlyList<PropertyBinding>? propertyBindings)
+        {
+            var bindings = propertyBindings ?? Array.Empty<PropertyBinding>();
+            var bindingOffsets = new Offset<Fb.PropertyBinding>[bindings.Count];
+            for (var i = 0; i < bindings.Count; i++)
+            {
+                var binding = bindings[i];
+                Fb.PropertyBinding.StartPropertyBinding(builder);
+                Fb.PropertyBinding.AddName(builder, graph.GetString(binding.BindingName));
+                Fb.PropertyBinding.AddDisplayName(builder, graph.GetString(binding.DisplayName));
+                Fb.PropertyBinding.AddActualType(builder, (Fb.PropertyValueType)binding.ActualType);
+                Fb.PropertyBinding.AddExposedType(builder, (Fb.PropertyValueType)binding.ExposedType);
+
+                switch (binding.DefaultValue)
+                {
+                    case float scalar:
+                        Fb.PropertyBinding.AddDefaultScalar(builder, scalar);
+                        break;
+                    case Vector2 vector2:
+                        Fb.PropertyBinding.AddDefaultVector(builder, Fb.Vec4.CreateVec4(builder, vector2.X, vector2.Y, 0, 0));
+                        break;
+                    case Vector3 vector3:
+                        Fb.PropertyBinding.AddDefaultVector(builder, Fb.Vec4.CreateVec4(builder, vector3.X, vector3.Y, vector3.Z, 0));
+                        break;
+                    case Vector4 vector4:
+                        Fb.PropertyBinding.AddDefaultVector(builder, Fb.Vec4.CreateVec4(builder, vector4.X, vector4.Y, vector4.Z, vector4.W));
+                        break;
+                    case Wui.Color color:
+                        Fb.PropertyBinding.AddDefaultColor(builder, CreateColor(builder, color));
+                        break;
+                }
+
+                bindingOffsets[i] = Fb.PropertyBinding.EndPropertyBinding(builder);
+            }
+
+            var markers = metadata?.Markers ?? (IReadOnlyList<LottieMetadata.Marker>)Array.Empty<LottieMetadata.Marker>();
+            var markerOffsets = new Offset<Fb.Marker>[markers.Count];
+            for (var i = 0; i < markers.Count; i++)
+            {
+                var marker = markers[i];
+                Fb.Marker.StartMarker(builder);
+                Fb.Marker.AddName(builder, graph.GetString(marker.Name));
+                Fb.Marker.AddProgress(builder, (float)marker.Frame.Progress);
+                Fb.Marker.AddDurationProgress(builder, (float)(marker.Duration.Frames / Math.Max(1, marker.Duration.FPS)));
+                markerOffsets[i] = Fb.Marker.EndMarker(builder);
+            }
+
+            var name = graph.GetString(metadata?.CompositionName);
+
+            var bindingsVector = bindings.Count == 0
+                ? default
+                : Fb.Metadata.CreatePropertyBindingsVector(builder, bindingOffsets);
+
+            var markersVector = markers.Count == 0
+                ? default
+                : Fb.Metadata.CreateMarkersVector(builder, markerOffsets);
+
+            // The theming property set is the one that has no owner, i.e. the one that was
+            // created by Compositor.CreatePropertySet rather than by a composition object.
+            var themingPropertySet = Format.NullIndex;
+            for (var i = 0; i < graph.PropertySetList.Count; i++)
+            {
+                if (graph.PropertySetList[i].Owner is null)
+                {
+                    themingPropertySet = (uint)i;
+                    break;
+                }
+            }
+
+            Fb.Metadata.StartMetadata(builder);
+            Fb.Metadata.AddName(builder, name);
+            Fb.Metadata.AddDurationTicks(builder, metadata is null ? 0L : metadata.Duration.Time.Ticks);
+            Fb.Metadata.AddFramesPerSecond(builder, (float)(metadata?.Duration.FPS ?? 0));
+
+            if (bindingsVector.Value != 0)
+            {
+                Fb.Metadata.AddPropertyBindings(builder, bindingsVector);
+            }
+
+            if (markersVector.Value != 0)
+            {
+                Fb.Metadata.AddMarkers(builder, markersVector);
+            }
+
+            Fb.Metadata.AddThemingPropertySet(builder, themingPropertySet);
+            return Fb.Metadata.EndMetadata(builder);
+        }
+
+        // ---------------------------------------------------------------------
+        // Value helpers. A struct field is written only when the source property has a
+        // value, so that "never set" and "set to the default" stay distinguishable.
+        // ---------------------------------------------------------------------
+        static Offset<Fb.Color> CreateColor(FlatBufferBuilder builder, Wui.Color value)
+            => Fb.Color.CreateColor(builder, value.A, value.R, value.G, value.B);
+
+        static void AddColor(FlatBufferBuilder builder, Wui.Color? value, Action<FlatBufferBuilder, Offset<Fb.Color>> add)
+        {
+            if (value.HasValue)
+            {
+                add(builder, CreateColor(builder, value.Value));
+            }
+        }
+
+        static void AddVec2(FlatBufferBuilder builder, Vector2? value, Action<FlatBufferBuilder, Offset<Fb.Vec2>> add)
+        {
+            if (value.HasValue)
+            {
+                add(builder, Fb.Vec2.CreateVec2(builder, value.Value.X, value.Value.Y));
+            }
+        }
+
+        static void AddVec2(FlatBufferBuilder builder, Vector2 value, Action<FlatBufferBuilder, Offset<Fb.Vec2>> add)
+        {
+            // A non-nullable property always has a value, but writing a zero is the same
+            // as leaving the field out, so the zero case is skipped to save space.
+            if (value != Vector2.Zero)
+            {
+                add(builder, Fb.Vec2.CreateVec2(builder, value.X, value.Y));
+            }
+        }
+
+        static void AddVec3(FlatBufferBuilder builder, Vector3? value, Action<FlatBufferBuilder, Offset<Fb.Vec3>> add)
+        {
+            if (value.HasValue)
+            {
+                add(builder, Fb.Vec3.CreateVec3(builder, value.Value.X, value.Value.Y, value.Value.Z));
+            }
+        }
+
+        static void AddMat3x2(FlatBufferBuilder builder, Matrix3x2? value, Action<FlatBufferBuilder, Offset<Fb.Mat3x2>> add)
+        {
+            if (value.HasValue)
+            {
+                var m = value.Value;
+                add(builder, Fb.Mat3x2.CreateMat3x2(builder, m.M11, m.M12, m.M21, m.M22, m.M31, m.M32));
+            }
+        }
+
+        static void AddMat3x2(FlatBufferBuilder builder, Matrix3x2 value, Action<FlatBufferBuilder, Offset<Fb.Mat3x2>> add)
+        {
+            if (!value.IsIdentity)
+            {
+                add(builder, Fb.Mat3x2.CreateMat3x2(builder, value.M11, value.M12, value.M21, value.M22, value.M31, value.M32));
+            }
+        }
+
+        static void AddMat4x4(FlatBufferBuilder builder, Matrix4x4? value, Action<FlatBufferBuilder, Offset<Fb.Mat4x4>> add)
+        {
+            if (value.HasValue)
+            {
+                var m = value.Value;
+                add(builder, Fb.Mat4x4.CreateMat4x4(
+                    builder,
+                    m.M11, m.M12, m.M13, m.M14,
+                    m.M21, m.M22, m.M23, m.M24,
+                    m.M31, m.M32, m.M33, m.M34,
+                    m.M41, m.M42, m.M43, m.M44));
+            }
+        }
+    }
+}
diff --git a/source/CompDataFlatbuffer/GraphIndexer.cs b/source/CompDataFlatbuffer/GraphIndexer.cs
index aea762e5..82a5b438 100644
--- a/source/CompDataFlatbuffer/GraphIndexer.cs
+++ b/source/CompDataFlatbuffer/GraphIndexer.cs
@@ -121,15 +121,15 @@ internal uint GetString(string? value)
             return (uint)index;
         }
 
-        internal uint GetVisual(Visual? value) => Reference(_visuals, value, Schema.ObjectCategory.Visual);
+        internal uint GetVisual(Visual? value) => Index(_visuals, value);
 
-        internal uint GetShape(CompositionShape? value) => Reference(_shapes, value, Schema.ObjectCategory.Shape);
+        internal uint GetShape(CompositionShape? value) => Index(_shapes, value);
 
-        internal uint GetGeometry(CompositionGeometry? value) => Reference(_geometries, value, Schema.ObjectCategory.Geometry);
+        internal uint GetGeometry(CompositionGeometry? value) => Index(_geometries, value);
 
         internal uint GetCanvasGeometry(CanvasGeometry? value) => Index(_canvasGeometries, value);
 
-        internal uint GetBrush(CompositionBrush? value) => Reference(_brushes, value, Schema.ObjectCategory.Brush);
+        internal uint GetBrush(CompositionBrush? value) => Index(_brushes, value);
 
         internal uint GetGradientStop(CompositionColorGradientStop? value) => Index(_gradientStops, value);
 
@@ -160,41 +160,31 @@ internal uint GetString(string? value)
         /// <returns>The packed object reference, or <see cref="Format.NullIndex"/>.</returns>
         internal uint GetObjectReference(CompositionObject? value)
         {
-            switch (value)
+            if (value is null)
             {
-                case null: return Format.NullIndex;
-                case Visual visual: return GetVisual(visual);
-                case CompositionShape shape: return GetShape(shape);
-                case CompositionGeometry geometry: return GetGeometry(geometry);
-                case CompositionBrush brush: return GetBrush(brush);
-                case CompositionAnimation animation:
-                    return Format.PackObjectReference(Schema.ObjectCategory.Animation, (int)GetAnimation(animation));
-                case CompositionEasingFunction easing:
-                    return Format.PackObjectReference(Schema.ObjectCategory.Easing, (int)GetEasing(easing));
-                case CompositionPropertySet propertySet:
-                    return Format.PackObjectReference(Schema.ObjectCategory.PropertySet, (int)GetPropertySet(propertySet));
-                case CompositionVisualSurface surface:
-                    return Format.PackObjectReference(Schema.ObjectCategory.Surface, (int)GetSurface(surface));
-                case CompositionClip clip:
-                    return Format.PackObjectReference(Schema.ObjectCategory.Clip, (int)GetClip(clip));
-                case AnimationController controller:
-                    return Format.PackObjectReference(Schema.ObjectCategory.Controller, (int)GetController(controller));
-                case CompositionShadow shadow:
-                    return Format.PackObjectReference(Schema.ObjectCategory.Shadow, (int)GetShadow(shadow));
-                case CompositionColorGradientStop stop:
-                    return Format.PackObjectReference(Schema.ObjectCategory.GradientStop, (int)GetGradientStop(stop));
-                case CompositionViewBox viewBox:
-                    return Format.PackObjectReference(Schema.ObjectCategory.ViewBox, (int)GetViewBox(viewBox));
-                default:
-                    throw new InvalidOperationException($"Cannot reference {value.Type}.");
+                return Format.NullIndex;
             }
-        }
 
-        // Returns the packed object reference for a node in a category whose index is
-        // also used directly by strongly typed fields.
-        uint Reference<T>(Dictionary<object, int> map, T? value, Schema.ObjectCategory category)
-            where T : class
-            => value is null ? Format.NullIndex : Format.PackObjectReference(category, (int)Index(map, value));
+            var (category, index) = value switch
+            {
+                Visual visual => (Schema.ObjectCategory.Visual, GetVisual(visual)),
+                CompositionShape shape => (Schema.ObjectCategory.Shape, GetShape(shape)),
+                CompositionGeometry geometry => (Schema.ObjectCategory.Geometry, GetGeometry(geometry)),
+                CompositionBrush brush => (Schema.ObjectCategory.Brush, GetBrush(brush)),
+                CompositionAnimation animation => (Schema.ObjectCategory.Animation, GetAnimation(animation)),
+                CompositionEasingFunction easing => (Schema.ObjectCategory.Easing, GetEasing(easing)),
+                CompositionPropertySet propertySet => (Schema.ObjectCategory.PropertySet, GetPropertySet(propertySet)),
+                CompositionVisualSurface surface => (Schema.ObjectCategory.Surface, GetSurface(surface)),
+                CompositionClip clip => (Schema.ObjectCategory.Clip, GetClip(clip)),
+                AnimationController controller => (Schema.ObjectCategory.Controller, GetController(controller)),
+                CompositionShadow shadow => (Schema.ObjectCategory.Shadow, GetShadow(shadow)),
+                CompositionColorGradientStop stop => (Schema.ObjectCategory.GradientStop, GetGradientStop(stop)),
+                CompositionViewBox viewBox => (Schema.ObjectCategory.ViewBox, GetViewBox(viewBox)),
+                _ => throw new InvalidOperationException($"Cannot reference {value.Type}."),
+            };
+
+            return Format.PackObjectReference(category, (int)index);
+        }
 
         // Returns the plain index of a node, adding it to the graph if it has not been
         // seen before. The node is registered before its children are walked so that

From fc62c844f5e2bb17993e5d6bf897319df232879b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 18:14:25 +0000
Subject: [PATCH 05/39] Fix metadata string interning and marker duration;
 validate against C++ verifier

Metadata is serialized last but its strings must be present in the string
table, which is written first. Intern them up front, then freeze the table
so a missed interning site throws instead of handing out an out of range
index. Also store marker durations as a proportion of the animation and
carry the composition width and height through to the metadata.

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 .../CompositionSerializer.cs                  | 57 +++++++++++++++++--
 source/CompDataFlatbuffer/GraphIndexer.cs     | 19 +++++++
 2 files changed, 72 insertions(+), 4 deletions(-)

diff --git a/source/CompDataFlatbuffer/CompositionSerializer.cs b/source/CompDataFlatbuffer/CompositionSerializer.cs
index 19260209..db618fbf 100644
--- a/source/CompDataFlatbuffer/CompositionSerializer.cs
+++ b/source/CompDataFlatbuffer/CompositionSerializer.cs
@@ -42,12 +42,16 @@ static class CompositionSerializer
         /// <param name="requiredUapVersion">The minimum UAP version required to instantiate the graph.</param>
         /// <param name="metadata">Metadata describing the source Lottie animation, or null.</param>
         /// <param name="propertyBindings">The property bindings exposed by the graph, or null.</param>
+        /// <param name="width">The width of the source Lottie animation.</param>
+        /// <param name="height">The height of the source Lottie animation.</param>
         /// <returns>The serialized graph.</returns>
         public static byte[] Serialize(
             Visual root,
             ushort requiredUapVersion,
             LottieCompositionMetadata? metadata = null,
-            IReadOnlyList<PropertyBinding>? propertyBindings = null)
+            IReadOnlyList<PropertyBinding>? propertyBindings = null,
+            float width = 0,
+            float height = 0)
         {
             if (root is null)
             {
@@ -59,6 +63,10 @@ public static byte[] Serialize(
             // 1024 is a starting size only - the builder grows as needed.
             var builder = new FlatBufferBuilder(1024);
 
+            // Metadata strings are interned before the table is written, because the
+            // metadata is serialized last but its strings must be in the table.
+            InternMetadataStrings(graph, metadata, propertyBindings);
+
             // Strings are created first because a string cannot be created while a table
             // is under construction, and almost every table refers to one.
             var strings = new StringOffset[graph.StringList.Count];
@@ -67,6 +75,10 @@ public static byte[] Serialize(
                 strings[i] = builder.CreateString(graph.StringList[i]);
             }
 
+            // From here on, interning a new string would produce an index past the end of
+            // the table that was just written, so the table is closed to additions.
+            graph.FreezeStrings();
+
             // The node lists grow as the graph is walked, so they are indexed by position
             // rather than iterated, and the walk is complete before serialization starts.
             var visuals = Map(graph.VisualList, v => WriteVisual(builder, graph, v));
@@ -85,7 +97,7 @@ public static byte[] Serialize(
             var propertySets = Map(graph.PropertySetList, v => WritePropertySet(builder, graph, v));
             var controllers = Map(graph.ControllerList, v => WriteController(builder, graph, v));
 
-            var metadataOffset = WriteMetadata(builder, graph, metadata, propertyBindings);
+            var metadataOffset = WriteMetadata(builder, graph, metadata, propertyBindings, width, height);
 
             // The indices of the controllers that a host must supply, in index order.
             var customControllers = graph.ControllerList
@@ -141,6 +153,33 @@ public static byte[] Serialize(
             return builder.SizedByteArray();
         }
 
+        // Interns every string that WriteMetadata will need. Kept adjacent to
+        // WriteMetadata so that the two stay in step.
+        static void InternMetadataStrings(
+            GraphIndexer graph,
+            LottieCompositionMetadata? metadata,
+            IReadOnlyList<PropertyBinding>? propertyBindings)
+        {
+            graph.GetString(metadata?.CompositionName);
+
+            if (metadata is not null)
+            {
+                foreach (var marker in metadata.Markers)
+                {
+                    graph.GetString(marker.Name);
+                }
+            }
+
+            if (propertyBindings is not null)
+            {
+                foreach (var binding in propertyBindings)
+                {
+                    graph.GetString(binding.BindingName);
+                    graph.GetString(binding.DisplayName);
+                }
+            }
+        }
+
         static TResult[] Map<T, TResult>(List<T> source, Func<T, TResult> selector)
         {
             // The list is indexed rather than enumerated because writing a node can
@@ -947,7 +986,9 @@ path.Path is null
             FlatBufferBuilder builder,
             GraphIndexer graph,
             LottieCompositionMetadata? metadata,
-            IReadOnlyList<PropertyBinding>? propertyBindings)
+            IReadOnlyList<PropertyBinding>? propertyBindings,
+            float width,
+            float height)
         {
             var bindings = propertyBindings ?? Array.Empty<PropertyBinding>();
             var bindingOffsets = new Offset<Fb.PropertyBinding>[bindings.Count];
@@ -990,7 +1031,13 @@ path.Path is null
                 Fb.Marker.StartMarker(builder);
                 Fb.Marker.AddName(builder, graph.GetString(marker.Name));
                 Fb.Marker.AddProgress(builder, (float)marker.Frame.Progress);
-                Fb.Marker.AddDurationProgress(builder, (float)(marker.Duration.Frames / Math.Max(1, marker.Duration.FPS)));
+
+                // Marker durations are stored as a proportion of the whole animation, to
+                // match Frame.Progress, so that a player needs no frame rate arithmetic.
+                var totalFrames = metadata!.Duration.Frames;
+                Fb.Marker.AddDurationProgress(
+                    builder,
+                    totalFrames == 0 ? 0f : (float)(marker.Duration.Frames / totalFrames));
                 markerOffsets[i] = Fb.Marker.EndMarker(builder);
             }
 
@@ -1018,6 +1065,8 @@ path.Path is null
 
             Fb.Metadata.StartMetadata(builder);
             Fb.Metadata.AddName(builder, name);
+            Fb.Metadata.AddWidth(builder, width);
+            Fb.Metadata.AddHeight(builder, height);
             Fb.Metadata.AddDurationTicks(builder, metadata is null ? 0L : metadata.Duration.Time.Ticks);
             Fb.Metadata.AddFramesPerSecond(builder, (float)(metadata?.Duration.FPS ?? 0));
 
diff --git a/source/CompDataFlatbuffer/GraphIndexer.cs b/source/CompDataFlatbuffer/GraphIndexer.cs
index 82a5b438..20b56d93 100644
--- a/source/CompDataFlatbuffer/GraphIndexer.cs
+++ b/source/CompDataFlatbuffer/GraphIndexer.cs
@@ -51,6 +51,12 @@ sealed class GraphIndexer
 
         readonly Dictionary<string, int> _strings = new Dictionary<string, int>(StringComparer.Ordinal);
 
+        // Set once the string table has been written to the buffer. Interning a new
+        // string after that point would hand out an index that is past the end of the
+        // serialized table, so it is treated as a programming error rather than being
+        // allowed to silently corrupt the output.
+        bool _stringsAreFrozen;
+
         GraphIndexer()
         {
         }
@@ -113,6 +119,12 @@ internal uint GetString(string? value)
 
             if (!_strings.TryGetValue(value, out var index))
             {
+                if (_stringsAreFrozen)
+                {
+                    throw new InvalidOperationException(
+                        $"The string \"{value}\" was interned after the string table was written.");
+                }
+
                 index = StringList.Count;
                 StringList.Add(value);
                 _strings.Add(value, index);
@@ -121,6 +133,13 @@ internal uint GetString(string? value)
             return (uint)index;
         }
 
+        /// <summary>
+        /// Prevents any further strings from being added. Called once the string table has
+        /// been written, so that a missed interning site fails loudly instead of producing
+        /// an out of range string index.
+        /// </summary>
+        internal void FreezeStrings() => _stringsAreFrozen = true;
+
         internal uint GetVisual(Visual? value) => Index(_visuals, value);
 
         internal uint GetShape(CompositionShape? value) => Index(_shapes, value);

From 9badd65b4411458f0f9b62dddc718b3cbd44fb1c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 18:21:08 +0000
Subject: [PATCH 06/39] Add the managed FlatBuffer to WinCompData deserializer

The managed counterpart of the native interpreter. It exists so that the
wire format can be round tripped and compared with the original graph,
which is a much stronger check than testing the serializer alone. Every
index is bounds checked and the buffer is verified before it is read,
because buffers are untrusted input.

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 LottieGen/DotnetTool/LottieGen.csproj         |    4 +
 LottieGen/win-x64/LottieGen.win-x64.csproj    |    4 +
 .../CompDataFlatbuffer.projitems              |    2 +
 .../CompositionDeserializer.cs                | 1294 +++++++++++++++++
 .../FlatBufferFormatException.cs              |   32 +
 source/LottieGen/CommandLineOptions.cs        |    1 +
 source/LottieGen/Glob.cs                      |    8 +-
 source/LottieGen/Language.cs                  |    1 +
 source/LottieGen/LottieJsonFileProcessor.cs   |   57 +
 source/LottieGenExe/Usage.cs                  |    2 +-
 10 files changed, 1400 insertions(+), 5 deletions(-)
 create mode 100644 source/CompDataFlatbuffer/CompositionDeserializer.cs
 create mode 100644 source/CompDataFlatbuffer/FlatBufferFormatException.cs

diff --git a/LottieGen/DotnetTool/LottieGen.csproj b/LottieGen/DotnetTool/LottieGen.csproj
index 9eb44636..6ae9c9ac 100644
--- a/LottieGen/DotnetTool/LottieGen.csproj
+++ b/LottieGen/DotnetTool/LottieGen.csproj
@@ -18,6 +18,7 @@
 
   <Import Project="..\Common.proj" />
   <Import Project="$(_SourceDir)Animatables\Animatables.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)CompDataFlatbuffer\CompDataFlatbuffer.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)CompMetadata\CompMetadata.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)DotLottie\DotLottie.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)GenericData\GenericData.projitems" Label="Shared" />
@@ -33,4 +34,7 @@
   <Import Project="$(_SourceDir)WinUIXamlMediaData\WinUIXamlMediaData.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)YamlData\YamlData.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)UIDataCodeGen\UIDataCodeGen.projitems" Label="Shared" />
+  <ItemGroup>
+    <PackageReference Include="Google.FlatBuffers" Version="25.2.10" />
+  </ItemGroup>
 </Project>
diff --git a/LottieGen/win-x64/LottieGen.win-x64.csproj b/LottieGen/win-x64/LottieGen.win-x64.csproj
index 6d0dfe5a..fb44ba06 100644
--- a/LottieGen/win-x64/LottieGen.win-x64.csproj
+++ b/LottieGen/win-x64/LottieGen.win-x64.csproj
@@ -35,6 +35,7 @@
 
   <Import Project="..\Common.proj" />
   <Import Project="$(_SourceDir)Animatables\Animatables.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)CompDataFlatbuffer\CompDataFlatbuffer.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)CompMetadata\CompMetadata.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)DotLottie\DotLottie.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)GenericData\GenericData.projitems" Label="Shared" />
@@ -50,4 +51,7 @@
   <Import Project="$(_SourceDir)WinUIXamlMediaData\WinUIXamlMediaData.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)YamlData\YamlData.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)UIDataCodeGen\UIDataCodeGen.projitems" Label="Shared" />
+  <ItemGroup>
+    <PackageReference Include="Google.FlatBuffers" Version="25.2.10" />
+  </ItemGroup>
 </Project>
diff --git a/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems b/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
index 074a62df..90d3537b 100644
--- a/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
+++ b/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
@@ -9,8 +9,10 @@
     <Import_RootNamespace>CompDataFlatbuffer</Import_RootNamespace>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)FlatBufferFormatException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Format.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)GraphIndexer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)CompositionDeserializer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CompositionSerializer.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/source/CompDataFlatbuffer/CompositionDeserializer.cs b/source/CompDataFlatbuffer/CompositionDeserializer.cs
new file mode 100644
index 00000000..8d2d502d
--- /dev/null
+++ b/source/CompDataFlatbuffer/CompositionDeserializer.cs
@@ -0,0 +1,1294 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using CommunityToolkit.WinUI.Lottie.WinCompData;
+using CommunityToolkit.WinUI.Lottie.WinCompData.MetaData;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgc;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgce;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg;
+using CommunityToolkit.WinUI.Lottie.WinUIXamlMediaData;
+using Google.FlatBuffers;
+using Expressions = CommunityToolkit.WinUI.Lottie.WinCompData.Expressions;
+using Fb = CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema;
+using Wui = CommunityToolkit.WinUI.Lottie.WinCompData.Wui;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
+{
+    /// <summary>
+    /// Rebuilds a WinCompData object graph from a FlatBuffer produced by
+    /// <see cref="CompositionSerializer"/>.
+    /// </summary>
+    /// <remarks>
+    /// This is the managed counterpart of the native interpreter. It exists so that the
+    /// wire format can be tested by round tripping a graph through it and comparing the
+    /// result with the original, which is a much stronger check than testing the
+    /// serializer alone.
+    /// <para/>
+    /// Expressions are stored in the buffer as text - which is all that
+    /// Windows.UI.Composition itself accepts - so the static type of an expression tree
+    /// is not preserved. Rebuilt expressions are "asserted" expressions with the same
+    /// text, which compare equal to the originals.
+    /// </remarks>
+#if PUBLIC_CompDataFlatbuffer
+    public
+#endif
+    sealed class CompositionDeserializer
+    {
+        readonly Compositor _compositor = new Compositor();
+        readonly Fb.LottieComposition _root;
+        readonly string[] _strings;
+
+        // Realization caches. These are indexed identically to the node vectors in the
+        // buffer, so looking up an already realized node is an array index rather than a
+        // hash lookup, and shared nodes are realized exactly once.
+        readonly Visual?[] _visuals;
+        readonly CompositionShape?[] _shapes;
+        readonly CompositionGeometry?[] _geometries;
+        readonly CanvasGeometry?[] _canvasGeometries;
+        readonly CompositionBrush?[] _brushes;
+        readonly CompositionColorGradientStop?[] _gradientStops;
+        readonly CompositionViewBox?[] _viewBoxes;
+        readonly CompositionClip?[] _clips;
+        readonly CompositionShadow?[] _shadows;
+        readonly ICompositionSurface?[] _surfaces;
+        readonly GraphicsEffectBase?[] _effects;
+        readonly CompositionEasingFunction?[] _easings;
+        readonly CompositionAnimation?[] _animations;
+        readonly CompositionPropertySet?[] _propertySets;
+        readonly AnimationController?[] _controllers;
+
+        CompositionDeserializer(Fb.LottieComposition root)
+        {
+            _root = root;
+
+            _strings = new string[root.StringsLength];
+            for (var i = 0; i < _strings.Length; i++)
+            {
+                _strings[i] = root.Strings(i) ?? string.Empty;
+            }
+
+            _visuals = new Visual?[root.VisualsLength];
+            _shapes = new CompositionShape?[root.ShapesLength];
+            _geometries = new CompositionGeometry?[root.GeometriesLength];
+            _canvasGeometries = new CanvasGeometry?[root.CanvasGeometriesLength];
+            _brushes = new CompositionBrush?[root.BrushesLength];
+            _gradientStops = new CompositionColorGradientStop?[root.GradientStopsLength];
+            _viewBoxes = new CompositionViewBox?[root.ViewBoxesLength];
+            _clips = new CompositionClip?[root.ClipsLength];
+            _shadows = new CompositionShadow?[root.ShadowsLength];
+            _surfaces = new ICompositionSurface?[root.SurfacesLength];
+            _effects = new GraphicsEffectBase?[root.EffectsLength];
+            _easings = new CompositionEasingFunction?[root.EasingsLength];
+            _animations = new CompositionAnimation?[root.AnimationsLength];
+            _propertySets = new CompositionPropertySet?[root.PropertySetsLength];
+            _controllers = new AnimationController?[root.ControllersLength];
+        }
+
+        /// <summary>
+        /// Rebuilds the graph described by a FlatBuffer.
+        /// </summary>
+        /// <param name="bytes">A buffer produced by <see cref="CompositionSerializer"/>.</param>
+        /// <returns>The root visual of the rebuilt graph.</returns>
+        /// <exception cref="FlatBufferFormatException">The buffer is not a well formed composition.</exception>
+        public static Visual Deserialize(ReadOnlySpan<byte> bytes)
+        {
+            // The buffer is untrusted, so it is fully verified before any of it is read.
+            var buffer = new ByteBuffer(bytes.ToArray());
+
+            // This checks the file identifier as well as the structure, so a buffer that
+            // is not a composition at all is rejected here.
+            if (!Fb.LottieComposition.VerifyLottieComposition(buffer))
+            {
+                throw new FlatBufferFormatException("The buffer is not a valid composition.");
+            }
+
+            var root = Fb.LottieComposition.GetRootAsLottieComposition(buffer);
+
+            if (root.SchemaVersion > Format.Version)
+            {
+                throw new FlatBufferFormatException(
+                    $"Schema version {root.SchemaVersion} is newer than the supported version {Format.Version}.");
+            }
+
+            var deserializer = new CompositionDeserializer(root);
+            var rootVisual = deserializer.GetVisual(root.RootVisual);
+
+            return rootVisual ?? throw new FlatBufferFormatException("The composition has no root visual.");
+        }
+
+        // ---------------------------------------------------------------------
+        // Table accessors. Every index is bounds checked, because a buffer that
+        // passes verification can still contain an out of range index.
+        // ---------------------------------------------------------------------
+        static T Require<T>(T? value, string what)
+            where T : struct
+            => value ?? throw new FlatBufferFormatException($"A {what} is missing.");
+
+        string? GetString(uint index)
+            => index == Format.NullIndex
+                ? null
+                : index < (uint)_strings.Length
+                    ? _strings[index]
+                    : throw new FlatBufferFormatException($"String index {index} is out of range.");
+
+        string GetRequiredString(uint index)
+            => GetString(index) ?? throw new FlatBufferFormatException("A required string is missing.");
+
+        // ---------------------------------------------------------------------
+        // Shared state.
+        // ---------------------------------------------------------------------
+        // Applies the state that is common to every CompositionObject. Called after the
+        // object has been placed in its realization cache, so that a cycle through a
+        // reference parameter terminates.
+        void InitializeCompositionObject(CompositionObject target, Fb.CompObj? source)
+        {
+            if (source is null)
+            {
+                return;
+            }
+
+            var value = source.Value;
+
+            target.Comment = GetString(value.Comment);
+
+            // The property set is realized through the object that owns it, so that the
+            // owner and its property set can never be created twice.
+            if (value.Properties != Format.NullIndex)
+            {
+                RealizePropertySet(value.Properties, target.Properties);
+            }
+
+            // Animations are started last, because setting a property stops any animation
+            // that is running on it.
+            for (var i = 0; i < value.AnimatorsLength; i++)
+            {
+                var animator = Require(value.Animators(i), "animator");
+                var property = GetRequiredString(animator.Property);
+                var animation = GetAnimation(animator.Animation)
+                    ?? throw new FlatBufferFormatException($"Animator '{property}' has no animation.");
+
+                // A non custom controller is created by StartAnimation, so only a custom
+                // one is passed in. Either way the resulting controller is cached under
+                // the index that the buffer gave it.
+                var controllerIndex = animator.Controller;
+                var customController = controllerIndex != Format.NullIndex && IsCustomController(controllerIndex)
+                    ? GetController(controllerIndex)
+                    : null;
+
+                var created = target.StartAnimation(property, animation, customController);
+
+                if (controllerIndex != Format.NullIndex && created.Controller is not null)
+                {
+                    RealizeController(controllerIndex, created.Controller);
+                }
+            }
+        }
+
+        bool IsCustomController(uint index)
+            => GetControllerTable(index).IsCustom;
+
+        Fb.Controller GetControllerTable(uint index)
+            => index < (uint)_controllers.Length
+                ? Require(_root.Controllers((int)index), "controller")
+                : throw new FlatBufferFormatException($"Controller index {index} is out of range.");
+
+        void RealizeController(uint index, AnimationController controller)
+        {
+            if (_controllers[index] is not null)
+            {
+                return;
+            }
+
+            _controllers[index] = controller;
+
+            var table = GetControllerTable(index);
+
+            if (table.IsPaused)
+            {
+                controller.Pause();
+            }
+
+            InitializeCompositionObject(controller, table.Base);
+        }
+
+        AnimationController? GetController(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            var table = GetControllerTable(index);
+
+            if (_controllers[index] is null)
+            {
+                if (table.IsCustom)
+                {
+                    RealizeController(index, _compositor.CreateAnimationController());
+                }
+                else
+                {
+                    // A non custom controller comes into existence when its target object
+                    // starts the animation, so realizing the target realizes the controller.
+                    GetObjectReference(table.TargetObject);
+                }
+            }
+
+            return _controllers[index]
+                ?? throw new FlatBufferFormatException($"Controller {index} could not be realized.");
+        }
+
+        void RealizePropertySet(uint index, CompositionPropertySet propertySet)
+        {
+            if (index >= (uint)_propertySets.Length)
+            {
+                throw new FlatBufferFormatException($"Property set index {index} is out of range.");
+            }
+
+            if (_propertySets[index] is not null)
+            {
+                return;
+            }
+
+            _propertySets[index] = propertySet;
+
+            var table = Require(_root.PropertySets((int)index), "property set");
+
+            for (var i = 0; i < table.ValuesLength; i++)
+            {
+                var value = Require(table.Values(i), "property value");
+                var name = GetRequiredString(value.Name);
+
+                switch (value.Type)
+                {
+                    case Fb.PropertyValueType.Color:
+                        propertySet.InsertColor(name, ToColor(Require(value.Color, "color")));
+                        break;
+                    case Fb.PropertyValueType.Scalar:
+                        propertySet.InsertScalar(name, value.Scalar);
+                        break;
+                    case Fb.PropertyValueType.Vector2:
+                        propertySet.InsertVector2(name, ToVector2(value.Vector));
+                        break;
+                    case Fb.PropertyValueType.Vector3:
+                        propertySet.InsertVector3(name, ToVector3(value.Vector));
+                        break;
+                    case Fb.PropertyValueType.Vector4:
+                        propertySet.InsertVector4(name, ToVector4(value.Vector));
+                        break;
+                }
+            }
+
+            InitializeCompositionObject(propertySet, table.Base);
+        }
+
+        CompositionPropertySet? GetPropertySet(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_propertySets.Length)
+            {
+                throw new FlatBufferFormatException($"Property set index {index} is out of range.");
+            }
+
+            if (_propertySets[index] is null)
+            {
+                var table = Require(_root.PropertySets((int)index), "property set");
+
+                if (table.Owner == Format.NullIndex)
+                {
+                    RealizePropertySet(index, _compositor.CreatePropertySet());
+                }
+                else
+                {
+                    // Realizing the owner realizes its property set as a side effect.
+                    GetObjectReference(table.Owner);
+                }
+            }
+
+            return _propertySets[index]
+                ?? throw new FlatBufferFormatException($"Property set {index} could not be realized.");
+        }
+
+        // Resolves a packed (category, index) reference. Only used by the three fields
+        // that can point at an object of any category.
+        CompositionObject? GetObjectReference(uint reference)
+        {
+            if (reference == Format.NullIndex)
+            {
+                return null;
+            }
+
+            var category = Format.UnpackCategory(reference);
+            var index = (uint)Format.UnpackIndex(reference);
+
+            return category switch
+            {
+                Fb.ObjectCategory.Visual => GetVisual(index),
+                Fb.ObjectCategory.Shape => GetShape(index),
+                Fb.ObjectCategory.Geometry => GetGeometry(index),
+                Fb.ObjectCategory.Brush => GetBrush(index),
+                Fb.ObjectCategory.Animation => GetAnimation(index),
+                Fb.ObjectCategory.Easing => GetEasing(index),
+                Fb.ObjectCategory.PropertySet => GetPropertySet(index),
+                Fb.ObjectCategory.Surface => GetSurface(index) as CompositionObject,
+                Fb.ObjectCategory.Clip => GetClip(index),
+                Fb.ObjectCategory.Controller => GetController(index),
+                Fb.ObjectCategory.Shadow => GetShadow(index),
+                Fb.ObjectCategory.GradientStop => GetGradientStop(index),
+                Fb.ObjectCategory.ViewBox => GetViewBox(index),
+                _ => throw new FlatBufferFormatException($"Unsupported object category {category}."),
+            };
+        }
+
+        // ---------------------------------------------------------------------
+        // Nodes.
+        // ---------------------------------------------------------------------
+        Visual? GetVisual(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_visuals.Length)
+            {
+                throw new FlatBufferFormatException($"Visual index {index} is out of range.");
+            }
+
+            if (_visuals[index] is Visual cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Visuals((int)index), "visual");
+
+            Visual result = table.Kind switch
+            {
+                Fb.VisualKind.Shape => _compositor.CreateShapeVisual(),
+                Fb.VisualKind.Sprite => _compositor.CreateSpriteVisual(),
+                Fb.VisualKind.Layer => _compositor.CreateLayerVisual(),
+                Fb.VisualKind.Container => _compositor.CreateContainerVisual(),
+                _ => throw new FlatBufferFormatException($"Unsupported visual kind {table.Kind}."),
+            };
+
+            _visuals[index] = result;
+
+            if (table.BorderMode.HasValue)
+            {
+                result.BorderMode = (CompositionBorderMode)table.BorderMode.Value;
+            }
+
+            result.CenterPoint = ToVector3(table.CenterPoint);
+            result.Clip = GetClip(table.Clip);
+            result.IsVisible = table.IsVisible;
+            result.Offset = ToVector3(table.Offset);
+            result.Opacity = table.Opacity;
+            result.RotationAngleInDegrees = table.RotationAngleInDegrees;
+            result.RotationAxis = ToVector3(table.RotationAxis);
+            result.Scale = ToVector3(table.Scale);
+            result.Size = ToVector2(table.Size);
+            result.TransformMatrix = ToMatrix4x4(table.TransformMatrix);
+
+            if (result is ContainerVisual container)
+            {
+                for (var i = 0; i < table.ChildrenLength; i++)
+                {
+                    container.Children.Add(
+                        GetVisual(table.Children(i))
+                        ?? throw new FlatBufferFormatException("A visual child is missing."));
+                }
+            }
+
+            switch (result)
+            {
+                case ShapeVisual shapeVisual:
+                    for (var i = 0; i < table.ShapesLength; i++)
+                    {
+                        shapeVisual.Shapes.Add(
+                            GetShape(table.Shapes(i))
+                            ?? throw new FlatBufferFormatException("A shape is missing."));
+                    }
+
+                    shapeVisual.ViewBox = GetViewBox(table.ViewBox);
+                    break;
+                case SpriteVisual spriteVisual:
+                    spriteVisual.Brush = GetBrush(table.Brush);
+                    spriteVisual.Shadow = GetShadow(table.Shadow);
+                    break;
+                case LayerVisual layerVisual:
+                    layerVisual.Shadow = GetShadow(table.Shadow);
+                    break;
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        CompositionShape? GetShape(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_shapes.Length)
+            {
+                throw new FlatBufferFormatException($"Shape index {index} is out of range.");
+            }
+
+            if (_shapes[index] is CompositionShape cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Shapes((int)index), "shape");
+
+            CompositionShape result = table.Kind switch
+            {
+                Fb.ShapeKind.Sprite => _compositor.CreateSpriteShape(),
+                Fb.ShapeKind.Container => _compositor.CreateContainerShape(),
+                _ => throw new FlatBufferFormatException($"Unsupported shape kind {table.Kind}."),
+            };
+
+            _shapes[index] = result;
+
+            result.CenterPoint = ToVector2(table.CenterPoint);
+            result.Offset = ToVector2(table.Offset);
+            result.RotationAngleInDegrees = table.RotationAngleInDegrees;
+            result.Scale = ToVector2(table.Scale);
+            result.TransformMatrix = ToMatrix3x2(table.TransformMatrix);
+
+            switch (result)
+            {
+                case CompositionContainerShape containerShape:
+                    for (var i = 0; i < table.ShapesLength; i++)
+                    {
+                        containerShape.Shapes.Add(
+                            GetShape(table.Shapes(i))
+                            ?? throw new FlatBufferFormatException("A shape is missing."));
+                    }
+
+                    break;
+                case CompositionSpriteShape spriteShape:
+                    spriteShape.FillBrush = GetBrush(table.FillBrush);
+                    spriteShape.StrokeBrush = GetBrush(table.StrokeBrush);
+                    spriteShape.Geometry = GetGeometry(table.Geometry);
+                    spriteShape.IsStrokeNonScaling = table.IsStrokeNonScaling;
+                    spriteShape.StrokeDashOffset = table.StrokeDashOffset;
+
+                    for (var i = 0; i < table.StrokeDashArrayLength; i++)
+                    {
+                        spriteShape.StrokeDashArray.Add(table.StrokeDashArray(i));
+                    }
+
+                    if (table.StrokeDashCap.HasValue)
+                    {
+                        spriteShape.StrokeDashCap = (CompositionStrokeCap)table.StrokeDashCap.Value;
+                    }
+
+                    if (table.StrokeStartCap.HasValue)
+                    {
+                        spriteShape.StrokeStartCap = (CompositionStrokeCap)table.StrokeStartCap.Value;
+                    }
+
+                    if (table.StrokeEndCap.HasValue)
+                    {
+                        spriteShape.StrokeEndCap = (CompositionStrokeCap)table.StrokeEndCap.Value;
+                    }
+
+                    if (table.StrokeLineJoin.HasValue)
+                    {
+                        spriteShape.StrokeLineJoin = (CompositionStrokeLineJoin)table.StrokeLineJoin.Value;
+                    }
+
+                    spriteShape.StrokeMiterLimit = table.StrokeMiterLimit;
+                    spriteShape.StrokeThickness = table.StrokeThickness;
+                    break;
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        CompositionGeometry? GetGeometry(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_geometries.Length)
+            {
+                throw new FlatBufferFormatException($"Geometry index {index} is out of range.");
+            }
+
+            if (_geometries[index] is CompositionGeometry cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Geometries((int)index), "geometry");
+
+            CompositionGeometry result = table.Kind switch
+            {
+                Fb.GeometryKind.Rectangle => _compositor.CreateRectangleGeometry(),
+                Fb.GeometryKind.RoundedRectangle => _compositor.CreateRoundedRectangleGeometry(),
+                Fb.GeometryKind.Ellipse => _compositor.CreateEllipseGeometry(),
+                Fb.GeometryKind.Path => _compositor.CreatePathGeometry(),
+                _ => throw new FlatBufferFormatException($"Unsupported geometry kind {table.Kind}."),
+            };
+
+            _geometries[index] = result;
+
+            result.TrimStart = table.TrimStart;
+            result.TrimEnd = table.TrimEnd;
+            result.TrimOffset = table.TrimOffset;
+
+            switch (result)
+            {
+                case CompositionPathGeometry pathGeometry:
+                    var path = GetCanvasGeometry(table.Path);
+                    pathGeometry.Path = path is null ? null : new CompositionPath(path);
+                    break;
+                case CompositionRoundedRectangleGeometry roundedRectangle:
+                    roundedRectangle.Offset = ToVector2(table.Offset);
+                    roundedRectangle.Size = ToVector2(table.Size);
+                    roundedRectangle.CornerRadius = ToVector2(table.CornerRadius) ?? Vector2.Zero;
+                    break;
+                case CompositionRectangleGeometry rectangle:
+                    rectangle.Offset = ToVector2(table.Offset);
+                    rectangle.Size = ToVector2(table.Size);
+                    break;
+                case CompositionEllipseGeometry ellipse:
+                    ellipse.Center = ToVector2(table.Center) ?? Vector2.Zero;
+                    ellipse.Radius = ToVector2(table.Radius) ?? Vector2.Zero;
+                    break;
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        CompositionBrush? GetBrush(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_brushes.Length)
+            {
+                throw new FlatBufferFormatException($"Brush index {index} is out of range.");
+            }
+
+            if (_brushes[index] is CompositionBrush cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Brushes((int)index), "brush");
+
+            CompositionBrush result;
+            switch (table.Kind)
+            {
+                case Fb.BrushKind.Color:
+                    result = _compositor.CreateColorBrush();
+                    break;
+                case Fb.BrushKind.LinearGradient:
+                    result = _compositor.CreateLinearGradientBrush();
+                    break;
+                case Fb.BrushKind.RadialGradient:
+                    result = _compositor.CreateRadialGradientBrush();
+                    break;
+                case Fb.BrushKind.Mask:
+                    result = _compositor.CreateMaskBrush();
+                    break;
+                case Fb.BrushKind.Surface:
+                    // The surface is needed to construct the brush, so it is realized
+                    // before the brush is placed in the cache.
+                    result = _compositor.CreateSurfaceBrush(
+                        GetSurface(table.Surface)
+                        ?? throw new FlatBufferFormatException("A surface brush has no surface."));
+                    break;
+                case Fb.BrushKind.Effect:
+                    var effect = GetEffect(table.Effect)
+                        ?? throw new FlatBufferFormatException("An effect brush has no effect.");
+                    result = CompositionEffectFactory.GetFactoryCached(effect).CreateBrush();
+                    break;
+                default:
+                    throw new FlatBufferFormatException($"Unsupported brush kind {table.Kind}.");
+            }
+
+            _brushes[index] = result;
+
+            switch (result)
+            {
+                case CompositionColorBrush colorBrush:
+                    colorBrush.Color = ToColorOrNull(table.Color);
+                    break;
+                case CompositionMaskBrush maskBrush:
+                    maskBrush.Source = GetBrush(table.Source);
+                    maskBrush.Mask = GetBrush(table.Mask);
+                    break;
+                case CompositionEffectBrush effectBrush:
+                    for (var i = 0; i < table.SourceParametersLength; i++)
+                    {
+                        var parameter = Require(table.SourceParameters(i), "source parameter");
+                        effectBrush.SetSourceParameter(
+                            GetRequiredString(parameter.Name),
+                            GetBrush(parameter.Brush)
+                            ?? throw new FlatBufferFormatException("An effect source has no brush."));
+                    }
+
+                    break;
+            }
+
+            if (result is CompositionGradientBrush gradientBrush)
+            {
+                gradientBrush.AnchorPoint = ToVector2(table.AnchorPoint);
+                gradientBrush.CenterPoint = ToVector2(table.CenterPoint);
+
+                for (var i = 0; i < table.ColorStopsLength; i++)
+                {
+                    gradientBrush.ColorStops.Add(
+                        GetGradientStop(table.ColorStops(i))
+                        ?? throw new FlatBufferFormatException("A gradient stop is missing."));
+                }
+
+                if (table.ExtendMode.HasValue)
+                {
+                    gradientBrush.ExtendMode = (CompositionGradientExtendMode)table.ExtendMode.Value;
+                }
+
+                if (table.InterpolationSpace.HasValue)
+                {
+                    gradientBrush.InterpolationSpace = (CompositionColorSpace)table.InterpolationSpace.Value;
+                }
+
+                if (table.MappingMode.HasValue)
+                {
+                    gradientBrush.MappingMode = (CompositionMappingMode)table.MappingMode.Value;
+                }
+
+                gradientBrush.Offset = ToVector2(table.Offset);
+                gradientBrush.RotationAngleInDegrees = table.RotationAngleInDegrees;
+                gradientBrush.Scale = ToVector2(table.Scale);
+                gradientBrush.TransformMatrix = ToMatrix3x2(table.TransformMatrix);
+
+                switch (gradientBrush)
+                {
+                    case CompositionLinearGradientBrush linear:
+                        linear.StartPoint = ToVector2(table.StartPoint);
+                        linear.EndPoint = ToVector2(table.EndPoint);
+                        break;
+                    case CompositionRadialGradientBrush radial:
+                        radial.EllipseCenter = ToVector2(table.EllipseCenter);
+                        radial.EllipseRadius = ToVector2(table.EllipseRadius);
+                        radial.GradientOriginOffset = ToVector2(table.GradientOriginOffset);
+                        break;
+                }
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        CompositionColorGradientStop? GetGradientStop(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_gradientStops.Length)
+            {
+                throw new FlatBufferFormatException($"Gradient stop index {index} is out of range.");
+            }
+
+            if (_gradientStops[index] is CompositionColorGradientStop cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.GradientStops((int)index), "gradient stop");
+            var result = _compositor.CreateColorGradientStop();
+            _gradientStops[index] = result;
+
+            result.Color = ToColor(Require(table.Color, "color"));
+            result.Offset = table.Offset;
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        CompositionViewBox? GetViewBox(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_viewBoxes.Length)
+            {
+                throw new FlatBufferFormatException($"View box index {index} is out of range.");
+            }
+
+            if (_viewBoxes[index] is CompositionViewBox cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.ViewBoxes((int)index), "view box");
+            var result = _compositor.CreateViewBox();
+            _viewBoxes[index] = result;
+
+            result.Size = ToVector2(table.Size) ?? Vector2.Zero;
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        CompositionClip? GetClip(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_clips.Length)
+            {
+                throw new FlatBufferFormatException($"Clip index {index} is out of range.");
+            }
+
+            if (_clips[index] is CompositionClip cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Clips((int)index), "clip");
+
+            CompositionClip result = table.Kind switch
+            {
+                Fb.ClipKind.Geometric => _compositor.CreateGeometricClip(),
+                Fb.ClipKind.Inset => _compositor.CreateInsetClip(),
+                _ => throw new FlatBufferFormatException($"Unsupported clip kind {table.Kind}."),
+            };
+
+            _clips[index] = result;
+
+            result.CenterPoint = ToVector2(table.CenterPoint);
+            result.Scale = ToVector2(table.Scale);
+
+            switch (result)
+            {
+                case InsetClip inset:
+                    inset.LeftInset = table.LeftInset;
+                    inset.RightInset = table.RightInset;
+                    inset.TopInset = table.TopInset;
+                    inset.BottomInset = table.BottomInset;
+                    break;
+                case CompositionGeometricClip geometric:
+                    geometric.Geometry = GetGeometry(table.Geometry);
+                    break;
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        CompositionShadow? GetShadow(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_shadows.Length)
+            {
+                throw new FlatBufferFormatException($"Shadow index {index} is out of range.");
+            }
+
+            if (_shadows[index] is CompositionShadow cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Shadows((int)index), "shadow");
+
+            CompositionShadow result = table.Kind switch
+            {
+                Fb.ShadowKind.Drop => _compositor.CreateDropShadow(),
+                _ => throw new FlatBufferFormatException($"Unsupported shadow kind {table.Kind}."),
+            };
+
+            _shadows[index] = result;
+
+            if (result is DropShadow dropShadow)
+            {
+                dropShadow.BlurRadius = table.BlurRadius;
+                dropShadow.Color = ToColorOrNull(table.Color);
+                dropShadow.Mask = GetBrush(table.Mask);
+                dropShadow.Offset = ToVector3(table.Offset);
+                dropShadow.Opacity = table.Opacity;
+
+                if (table.SourcePolicy.HasValue)
+                {
+                    dropShadow.SourcePolicy = (CompositionDropShadowSourcePolicy)table.SourcePolicy.Value;
+                }
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        ICompositionSurface? GetSurface(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_surfaces.Length)
+            {
+                throw new FlatBufferFormatException($"Surface index {index} is out of range.");
+            }
+
+            if (_surfaces[index] is ICompositionSurface cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Surfaces((int)index), "surface");
+
+            switch (table.Kind)
+            {
+                case Fb.SurfaceKind.VisualSurface:
+                    var visualSurface = _compositor.CreateVisualSurface();
+                    _surfaces[index] = visualSurface;
+                    visualSurface.SourceVisual = GetVisual(table.SourceVisual);
+                    visualSurface.SourceSize = ToVector2(table.SourceSize);
+                    visualSurface.SourceOffset = ToVector2(table.SourceOffset);
+                    InitializeCompositionObject(visualSurface, table.Base);
+                    return visualSurface;
+
+                case Fb.SurfaceKind.LoadedImageFromUri:
+                    var uri = GetRequiredString(table.Uri);
+                    var fromUri = LoadedImageSurface.StartLoadFromUri(new Uri(uri, UriKind.RelativeOrAbsolute));
+                    _surfaces[index] = fromUri;
+                    return fromUri;
+
+                case Fb.SurfaceKind.LoadedImageFromStream:
+                    var bytes = new byte[table.BytesLength];
+                    for (var i = 0; i < bytes.Length; i++)
+                    {
+                        bytes[i] = table.Bytes(i);
+                    }
+
+                    var fromStream = LoadedImageSurface.StartLoadFromStream(bytes);
+                    _surfaces[index] = fromStream;
+                    return fromStream;
+
+                default:
+                    throw new FlatBufferFormatException($"Unsupported surface kind {table.Kind}.");
+            }
+        }
+
+        GraphicsEffectBase? GetEffect(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_effects.Length)
+            {
+                throw new FlatBufferFormatException($"Effect index {index} is out of range.");
+            }
+
+            if (_effects[index] is GraphicsEffectBase cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Effects((int)index), "effect");
+
+            var sources = new List<CompositionEffectSourceParameter>(table.SourcesLength);
+            for (var i = 0; i < table.SourcesLength; i++)
+            {
+                sources.Add(new CompositionEffectSourceParameter(GetRequiredString(table.Sources(i))));
+            }
+
+            GraphicsEffectBase result = table.Kind switch
+            {
+                Fb.EffectKind.Composite => new CompositeEffect((CanvasComposite)table.Mode, sources),
+                Fb.EffectKind.GaussianBlur => new GaussianBlurEffect(
+                    table.BlurAmount,
+                    sources.Count == 1
+                        ? sources[0]
+                        : throw new FlatBufferFormatException("A blur effect must have exactly one source.")),
+                _ => throw new FlatBufferFormatException($"Unsupported effect kind {table.Kind}."),
+            };
+
+            _effects[index] = result;
+            return result;
+        }
+
+        CompositionEasingFunction? GetEasing(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_easings.Length)
+            {
+                throw new FlatBufferFormatException($"Easing index {index} is out of range.");
+            }
+
+            if (_easings[index] is CompositionEasingFunction cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Easings((int)index), "easing");
+
+            CompositionEasingFunction result;
+            switch (table.Kind)
+            {
+                case Fb.EasingKind.Linear:
+                    result = _compositor.CreateLinearEasingFunction();
+                    break;
+                case Fb.EasingKind.CubicBezier:
+                    result = _compositor.CreateCubicBezierEasingFunction(
+                        ToVector2(table.ControlPoint1) ?? Vector2.Zero,
+                        ToVector2(table.ControlPoint2) ?? Vector2.Zero);
+                    break;
+                case Fb.EasingKind.Step:
+                    var step = _compositor.CreateStepEasingFunction();
+                    step.StepCount = table.StepCount;
+                    step.InitialStep = table.InitialStep;
+                    step.FinalStep = table.FinalStep;
+                    step.IsInitialStepSingleFrame = table.IsInitialStepSingleFrame;
+                    step.IsFinalStepSingleFrame = table.IsFinalStepSingleFrame;
+                    result = step;
+                    break;
+                default:
+                    throw new FlatBufferFormatException($"Unsupported easing kind {table.Kind}.");
+            }
+
+            _easings[index] = result;
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        CompositionAnimation? GetAnimation(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_animations.Length)
+            {
+                throw new FlatBufferFormatException($"Animation index {index} is out of range.");
+            }
+
+            if (_animations[index] is CompositionAnimation cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Animations((int)index), "animation");
+
+            var result = table.Kind == Fb.AnimationKind.Expression
+                ? (CompositionAnimation)_compositor.CreateExpressionAnimation(
+                    Expressions.Expression.Scalar(GetRequiredString(table.Expression)))
+                : CreateKeyFrameAnimation(table);
+
+            _animations[index] = result;
+
+            result.Target = GetString(table.Target);
+
+            for (var i = 0; i < table.ReferenceParametersLength; i++)
+            {
+                var parameter = Require(table.ReferenceParameters(i), "reference parameter");
+                result.SetReferenceParameter(
+                    GetRequiredString(parameter.Name),
+                    GetObjectReference(parameter.Target)
+                    ?? throw new FlatBufferFormatException("A reference parameter has no target."));
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        CompositionAnimation CreateKeyFrameAnimation(Fb.Animation table)
+        {
+            KeyFrameAnimation_ result = table.Kind switch
+            {
+                Fb.AnimationKind.Scalar => _compositor.CreateScalarKeyFrameAnimation(),
+                Fb.AnimationKind.Vector2 => _compositor.CreateVector2KeyFrameAnimation(),
+                Fb.AnimationKind.Vector3 => _compositor.CreateVector3KeyFrameAnimation(),
+                Fb.AnimationKind.Vector4 => _compositor.CreateVector4KeyFrameAnimation(),
+                Fb.AnimationKind.Color => _compositor.CreateColorKeyFrameAnimation(),
+                Fb.AnimationKind.Boolean => _compositor.CreateBooleanKeyFrameAnimation(),
+                Fb.AnimationKind.Path => _compositor.CreatePathKeyFrameAnimation(),
+                _ => throw new FlatBufferFormatException($"Unsupported animation kind {table.Kind}."),
+            };
+
+            result.Duration = TimeSpan.FromTicks(table.DurationTicks);
+
+            if (result is ColorKeyFrameAnimation colorAnimation && table.InterpolationColorSpace.HasValue)
+            {
+                colorAnimation.InterpolationColorSpace =
+                    (CompositionColorSpace)table.InterpolationColorSpace.Value;
+            }
+
+            for (var i = 0; i < table.KeyFramesLength; i++)
+            {
+                InsertKeyFrame(result, Require(table.KeyFrames(i), "key frame"));
+            }
+
+            return result;
+        }
+
+        void InsertKeyFrame(KeyFrameAnimation_ animation, Fb.KeyFrame frame)
+        {
+            var progress = frame.Progress;
+            var easing = GetEasing(frame.Easing);
+
+            if (frame.Kind == Fb.KeyFrameKind.Expression)
+            {
+                var text = GetRequiredString(frame.Expression);
+
+                switch (animation)
+                {
+                    case ScalarKeyFrameAnimation scalar:
+                        scalar.InsertExpressionKeyFrame(progress, Expressions.Expression.Scalar(text), easing);
+                        break;
+                    case Vector2KeyFrameAnimation vector2:
+                        vector2.InsertExpressionKeyFrame(progress, Expressions.Expression.Vector2(text), easing);
+                        break;
+                    case Vector3KeyFrameAnimation vector3:
+                        vector3.InsertExpressionKeyFrame(progress, Expressions.Expression.Vector3(text), easing);
+                        break;
+                    case Vector4KeyFrameAnimation vector4:
+                        vector4.InsertExpressionKeyFrame(progress, Expressions.Expression.Vector4(text), easing);
+                        break;
+                    case ColorKeyFrameAnimation color:
+                        color.InsertExpressionKeyFrame(progress, Expressions.Expression.Color(text), easing);
+                        break;
+                    case BooleanKeyFrameAnimation boolean:
+                        boolean.InsertExpressionKeyFrame(progress, Expressions.Expression.Boolean(text), easing);
+                        break;
+                    default:
+                        throw new FlatBufferFormatException(
+                            $"{animation.Type} does not support expression key frames.");
+                }
+
+                return;
+            }
+
+            switch (animation)
+            {
+                case ScalarKeyFrameAnimation scalar:
+                    scalar.InsertKeyFrame(progress, frame.Scalar, easing);
+                    break;
+                case Vector2KeyFrameAnimation vector2:
+                    vector2.InsertKeyFrame(progress, ToVector2(frame.Vector), easing);
+                    break;
+                case Vector3KeyFrameAnimation vector3:
+                    vector3.InsertKeyFrame(progress, ToVector3(frame.Vector), easing);
+                    break;
+                case Vector4KeyFrameAnimation vector4:
+                    vector4.InsertKeyFrame(progress, ToVector4(frame.Vector), easing);
+                    break;
+                case ColorKeyFrameAnimation color:
+                    color.InsertKeyFrame(progress, ToColor(Require(frame.Color, "color")), easing);
+                    break;
+                case BooleanKeyFrameAnimation boolean:
+                    boolean.InsertKeyFrame(progress, frame.Scalar != 0, easing);
+                    break;
+                case PathKeyFrameAnimation path:
+                    path.InsertKeyFrame(
+                        progress,
+                        new CompositionPath(
+                            GetCanvasGeometry(frame.Path)
+                            ?? throw new FlatBufferFormatException("A path key frame has no path.")),
+                        easing);
+                    break;
+                default:
+                    throw new FlatBufferFormatException($"Unsupported animation {animation.Type}.");
+            }
+        }
+
+        CanvasGeometry? GetCanvasGeometry(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_canvasGeometries.Length)
+            {
+                throw new FlatBufferFormatException($"Canvas geometry index {index} is out of range.");
+            }
+
+            if (_canvasGeometries[index] is CanvasGeometry cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.CanvasGeometries((int)index), "canvas geometry");
+
+            CanvasGeometry result;
+            switch (table.Kind)
+            {
+                case Fb.CanvasGeometryKind.Combination:
+                    var a = GetCanvasGeometry(table.A)
+                        ?? throw new FlatBufferFormatException("A combination has no first geometry.");
+                    var b = GetCanvasGeometry(table.B)
+                        ?? throw new FlatBufferFormatException("A combination has no second geometry.");
+                    result = a.CombineWith(
+                        b,
+                        ToMatrix3x2(table.Matrix) ?? Matrix3x2.Identity,
+                        (CanvasGeometryCombine)table.CombineMode);
+                    break;
+
+                case Fb.CanvasGeometryKind.TransformedGeometry:
+                    var source = GetCanvasGeometry(table.Source)
+                        ?? throw new FlatBufferFormatException("A transformed geometry has no source.");
+                    result = source.Transform(ToMatrix3x2(table.Matrix) ?? Matrix3x2.Identity);
+                    break;
+
+                case Fb.CanvasGeometryKind.Group:
+                    var geometries = new CanvasGeometry[table.GeometriesLength];
+                    for (var i = 0; i < geometries.Length; i++)
+                    {
+                        geometries[i] = GetCanvasGeometry(table.Geometries(i))
+                            ?? throw new FlatBufferFormatException("A grouped geometry is missing.");
+                    }
+
+                    result = CanvasGeometry.CreateGroup(
+                        null,
+                        geometries,
+                        (CanvasFilledRegionDetermination)table.FillRule);
+                    break;
+
+                case Fb.CanvasGeometryKind.Path:
+                    result = CreatePath(table);
+                    break;
+
+                case Fb.CanvasGeometryKind.Ellipse:
+                    result = CanvasGeometry.CreateEllipse(null, table.X, table.Y, table.RadiusX, table.RadiusY);
+                    break;
+
+                case Fb.CanvasGeometryKind.RoundedRectangle:
+                    result = CanvasGeometry.CreateRoundedRectangle(
+                        null, table.X, table.Y, table.W, table.H, table.RadiusX, table.RadiusY);
+                    break;
+
+                default:
+                    throw new FlatBufferFormatException($"Unsupported canvas geometry kind {table.Kind}.");
+            }
+
+            _canvasGeometries[index] = result;
+            return result;
+        }
+
+        // Replays the flattened opcode and operand streams of a path.
+        static CanvasGeometry CreatePath(Fb.CanvasGeometry table)
+        {
+            using var builder = new CanvasPathBuilder(null);
+            builder.SetFilledRegionDetermination((CanvasFilledRegionDetermination)table.FillRule);
+
+            var operand = 0;
+
+            float Next()
+                => operand < table.OperandsLength
+                    ? table.Operands(operand++)
+                    : throw new FlatBufferFormatException("A path ran out of operands.");
+
+            for (var i = 0; i < table.OpsLength; i++)
+            {
+                switch ((Fb.PathOp)table.Ops(i))
+                {
+                    case Fb.PathOp.BeginFigure:
+                        builder.BeginFigure(new Vector2(Next(), Next()));
+                        break;
+                    case Fb.PathOp.EndFigure:
+                        builder.EndFigure((CanvasFigureLoop)Next());
+                        break;
+                    case Fb.PathOp.AddLine:
+                        builder.AddLine(new Vector2(Next(), Next()));
+                        break;
+                    case Fb.PathOp.AddCubicBezier:
+                        builder.AddCubicBezier(
+                            new Vector2(Next(), Next()),
+                            new Vector2(Next(), Next()),
+                            new Vector2(Next(), Next()));
+                        break;
+                    default:
+                        throw new FlatBufferFormatException($"Unsupported path opcode {table.Ops(i)}.");
+                }
+            }
+
+            return CanvasGeometry.CreatePath(builder);
+        }
+
+        // ---------------------------------------------------------------------
+        // Value helpers. An absent struct field means the property was never set,
+        // so these return null rather than a default value.
+        // ---------------------------------------------------------------------
+        static Wui.Color ToColor(Fb.Color value)
+            => Wui.Color.FromArgb(value.A, value.R, value.G, value.B);
+
+        static Wui.Color? ToColorOrNull(Fb.Color? value)
+            => value.HasValue ? ToColor(value.Value) : null;
+
+        static Vector2? ToVector2(Fb.Vec2? value)
+            => value.HasValue ? new Vector2(value.Value.X, value.Value.Y) : null;
+
+        static Vector3? ToVector3(Fb.Vec3? value)
+            => value.HasValue ? new Vector3(value.Value.X, value.Value.Y, value.Value.Z) : null;
+
+        static Vector2 ToVector2(Fb.Vec4? value)
+            => value.HasValue ? new Vector2(value.Value.X, value.Value.Y) : Vector2.Zero;
+
+        static Vector3 ToVector3(Fb.Vec4? value)
+            => value.HasValue ? new Vector3(value.Value.X, value.Value.Y, value.Value.Z) : Vector3.Zero;
+
+        static Vector4 ToVector4(Fb.Vec4? value)
+            => value.HasValue
+                ? new Vector4(value.Value.X, value.Value.Y, value.Value.Z, value.Value.W)
+                : Vector4.Zero;
+
+        static Matrix3x2? ToMatrix3x2(Fb.Mat3x2? value)
+            => value.HasValue
+                ? new Matrix3x2(
+                    value.Value.M11, value.Value.M12,
+                    value.Value.M21, value.Value.M22,
+                    value.Value.M31, value.Value.M32)
+                : null;
+
+        static Matrix4x4? ToMatrix4x4(Fb.Mat4x4? value)
+            => value.HasValue
+                ? new Matrix4x4(
+                    value.Value.M11, value.Value.M12, value.Value.M13, value.Value.M14,
+                    value.Value.M21, value.Value.M22, value.Value.M23, value.Value.M24,
+                    value.Value.M31, value.Value.M32, value.Value.M33, value.Value.M34,
+                    value.Value.M41, value.Value.M42, value.Value.M43, value.Value.M44)
+                : null;
+    }
+}
diff --git a/source/CompDataFlatbuffer/FlatBufferFormatException.cs b/source/CompDataFlatbuffer/FlatBufferFormatException.cs
new file mode 100644
index 00000000..5a7c9531
--- /dev/null
+++ b/source/CompDataFlatbuffer/FlatBufferFormatException.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
+{
+    /// <summary>
+    /// Thrown when a buffer is not a well formed serialized composition.
+    /// </summary>
+    /// <remarks>
+    /// Buffers are untrusted input, so every failure to read one is reported as this
+    /// exception rather than being allowed to surface as an index or cast failure.
+    /// </remarks>
+#if PUBLIC_CompDataFlatbuffer
+    public
+#endif
+    sealed class FlatBufferFormatException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FlatBufferFormatException"/> class.
+        /// </summary>
+        /// <param name="message">A description of what was wrong with the buffer.</param>
+        public FlatBufferFormatException(string message)
+            : base(message)
+        {
+        }
+    }
+}
diff --git a/source/LottieGen/CommandLineOptions.cs b/source/LottieGen/CommandLineOptions.cs
index 125efc44..755438fa 100644
--- a/source/LottieGen/CommandLineOptions.cs
+++ b/source/LottieGen/CommandLineOptions.cs
@@ -214,6 +214,7 @@ internal static CommandLineOptions ParseCommandLine(string[] args)
                     .AddKeyword(Language.Cx)
                     .AddKeyword(Language.Cppwinrt)
                     .AddKeyword(Language.Cppwinrt, "winrtcpp")
+                    .AddKeyword(Language.Flatbuffer)
                     .AddKeyword(Language.LottieYaml)
                     .AddKeyword(Language.WinCompDgml, "dgml")
                     .AddKeyword(Language.Stats);
diff --git a/source/LottieGen/Glob.cs b/source/LottieGen/Glob.cs
index 162e1180..e8ccd0c8 100644
--- a/source/LottieGen/Glob.cs
+++ b/source/LottieGen/Glob.cs
@@ -161,7 +161,7 @@ static Regex WildcardToRegex(string wildcard)
 
             if (string.IsNullOrEmpty(directoryPath))
             {
-                directoryPath = @".\";
+                directoryPath = $".{Path.DirectorySeparatorChar}";
             }
 
             if (directoryPath.EndsWith(":"))
@@ -171,10 +171,10 @@ static Regex WildcardToRegex(string wildcard)
                 directoryPath += @".\";
             }
 
-            // Ensure that we always have a trailing backslash. Callers expect this.
-            if (!directoryPath.EndsWith(@"\"))
+            // Ensure that we always have a trailing directory separator. Callers expect this.
+            if (!directoryPath.EndsWith(Path.DirectorySeparatorChar.ToString()))
             {
-                directoryPath += @"\";
+                directoryPath += Path.DirectorySeparatorChar;
             }
 
             return (Path.GetFullPath(directoryPath), pattern);
diff --git a/source/LottieGen/Language.cs b/source/LottieGen/Language.cs
index 3cca53c3..4cad27ac 100644
--- a/source/LottieGen/Language.cs
+++ b/source/LottieGen/Language.cs
@@ -15,6 +15,7 @@ enum Language
         CSharp,
         Cx,
         Cppwinrt,
+        Flatbuffer,
         LottieYaml,
         WinCompDgml,
         Stats,
diff --git a/source/LottieGen/LottieJsonFileProcessor.cs b/source/LottieGen/LottieJsonFileProcessor.cs
index 3d6db369..e778c86c 100644
--- a/source/LottieGen/LottieJsonFileProcessor.cs
+++ b/source/LottieGen/LottieJsonFileProcessor.cs
@@ -8,6 +8,7 @@
 using System.IO;
 using System.Linq;
 using System.Text;
+using CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer;
 using CommunityToolkit.WinUI.Lottie.LottieData;
 using CommunityToolkit.WinUI.Lottie.LottieData.Optimization;
 using CommunityToolkit.WinUI.Lottie.LottieData.Serialization;
@@ -201,6 +202,11 @@ bool TryGenerateCode(LottieComposition lottieComposition)
                         _profiler.OnCodeGenFinished();
                         break;
 
+                    case Language.Flatbuffer:
+                        codeGenSucceeded &= TryGenerateFlatbuffer(lottieComposition, $"{outputFileBase}.lcomp");
+                        _profiler.OnSerializationFinished();
+                        break;
+
                     case Language.LottieYaml:
                         codeGenSucceeded &= TryGenerateLottieYaml(lottieComposition, $"{outputFileBase}-Lottie.yaml");
                         _profiler.OnSerializationFinished();
@@ -425,6 +431,38 @@ bool TryGenerateLottieYaml(LottieComposition lottieComposition, string outputFil
             return result;
         }
 
+        bool TryGenerateFlatbuffer(LottieComposition lottieComposition, string outputFilePath)
+        {
+            if (!TryEnsureTranslated(lottieComposition))
+            {
+                return false;
+            }
+
+            // NOTE: this only writes the latest version of a multi-version translation.
+            var translationResult = _translationResults[0];
+            var sourceMetadata = new SourceMetadata(translationResult.SourceMetadata);
+            var result = TryWriteBinaryFile(
+                outputFilePath,
+                CompositionSerializer.Serialize(
+                    translationResult.RootVisual!,
+                    checked((ushort)translationResult.MinimumRequiredUapVersion),
+                    sourceMetadata.LottieMetadata,
+                    sourceMetadata.PropertyBindings,
+                    (float)lottieComposition.Width,
+                    (float)lottieComposition.Height));
+
+            if (result)
+            {
+                using (_reporter.InfoStream.Lock())
+                {
+                    _reporter.WriteInfo($"Flatbuffer data for class {_className} written to:");
+                    _reporter.WriteInfo(InfoType.FilePath, $" {outputFilePath}");
+                }
+            }
+
+            return result;
+        }
+
         bool TryGenerateWincompDgml(
             LottieComposition lottieComposition,
             string outputFilePath)
@@ -617,6 +655,25 @@ bool TryWriteTextFile(string filePath, Action<StreamWriter> writer)
             }
         }
 
+        bool TryWriteBinaryFile(string filePath, byte[] contents)
+        {
+            try
+            {
+                File.WriteAllBytes(filePath, contents);
+                return true;
+            }
+            catch (Exception e)
+            {
+                using (_reporter.ErrorStream.Lock())
+                {
+                    _reporter.WriteError($"Failed to write to {filePath}");
+                    _reporter.WriteError(e.Message);
+                }
+
+                return false;
+            }
+        }
+
         bool TryWriteTextFile(string filePath, string contents)
         {
             try
diff --git a/source/LottieGenExe/Usage.cs b/source/LottieGenExe/Usage.cs
index 5d267b10..0cbf7543 100644
--- a/source/LottieGenExe/Usage.cs
+++ b/source/LottieGenExe/Usage.cs
@@ -24,7 +24,7 @@ internal static string Text
 OVERVIEW:
        Generates source code from Lottie files for playing in the AnimatedVisualPlayer.
        LOTTIEFILE is a Lottie .json file or .lottie file. LOTTIEFILE may contain wildcards.
-       LANG is one of cs, cppcx, cppwinrt, lottieyaml, dgml, or stats.
+       LANG is one of cs, cppcx, cppwinrt, flatbuffer, lottieyaml, dgml, or stats.
        -Language LANG may be specified multiple times.
 
        [Other options]

From 30619a526520859a8c171c391a5a1adffd810c03 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 18:28:59 +0000
Subject: [PATCH 07/39] Add round-trip tests comparing JSON-translated and
 FlatBuffer-restored graphs

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 .../CompDataFlatbuffer.Tests.csproj           |  39 +
 .../CompositionTreeDumper.cs                  | 851 ++++++++++++++++++
 tests/CompDataFlatbuffer.Tests/Corpus.cs      | 141 +++
 .../RoundTripTests.cs                         | 120 +++
 4 files changed, 1151 insertions(+)
 create mode 100644 tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj
 create mode 100644 tests/CompDataFlatbuffer.Tests/CompositionTreeDumper.cs
 create mode 100644 tests/CompDataFlatbuffer.Tests/Corpus.cs
 create mode 100644 tests/CompDataFlatbuffer.Tests/RoundTripTests.cs

diff --git a/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj b/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj
new file mode 100644
index 00000000..5eaab357
--- /dev/null
+++ b/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj
@@ -0,0 +1,39 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <RootNamespace>CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Tests</RootNamespace>
+    <AssemblyName>CompDataFlatbuffer.Tests</AssemblyName>
+    <SignAssembly>false</SignAssembly>
+
+    <!-- The tests exercise the shared projects directly, so they compile the same
+         sources into the test assembly rather than referencing a built DLL. -->
+    <_SourceDir>..\..\source\</_SourceDir>
+  </PropertyGroup>
+
+  <Import Project="$(_SourceDir)Animatables\Animatables.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)CompDataFlatbuffer\CompDataFlatbuffer.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)CompMetadata\CompMetadata.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)GenericData\GenericData.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)LottieData\LottieData.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)LottieMetadata\LottieMetadata.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)LottieReader\LottieReader.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)LottieToWinComp\LottieToWinComp.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)UIData\UIData.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)YamlData\YamlData.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)WinCompData\WinCompData.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)WinStorageStreamsData\WinStorageStreamsData.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)WinUIXamlMediaData\WinUIXamlMediaData.projitems" Label="Shared" />
+
+  <ItemGroup>
+    <PackageReference Include="Google.FlatBuffers" Version="25.2.10" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/CompDataFlatbuffer.Tests/CompositionTreeDumper.cs b/tests/CompDataFlatbuffer.Tests/CompositionTreeDumper.cs
new file mode 100644
index 00000000..ccc2fab0
--- /dev/null
+++ b/tests/CompDataFlatbuffer.Tests/CompositionTreeDumper.cs
@@ -0,0 +1,851 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using CommunityToolkit.WinUI.Lottie.WinCompData;
+using CommunityToolkit.WinUI.Lottie.WinCompData.MetaData;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgce;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg;
+using CommunityToolkit.WinUI.Lottie.WinUIXamlMediaData;
+using Expressions = CommunityToolkit.WinUI.Lottie.WinCompData.Expressions;
+using Wui = CommunityToolkit.WinUI.Lottie.WinCompData.Wui;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Tests
+{
+    /// <summary>
+    /// Renders a WinCompData graph as canonical text.
+    /// </summary>
+    /// <remarks>
+    /// Two graphs produce identical text if and only if they are structurally
+    /// equivalent, including the sharing of nodes: each node is given an id the first
+    /// time it is reached by a depth first walk from the root, and every later reference
+    /// to it is written as that id. So a graph in which two parents share one child
+    /// cannot produce the same text as one in which they have a child each.
+    /// <para/>
+    /// This is the oracle for the round trip tests. It is deliberately independent of
+    /// both the serializer and the deserializer, and it fails loudly on a node type it
+    /// does not know about, so that a type added to WinCompData cannot silently escape
+    /// comparison.
+    /// </remarks>
+    static class CompositionTreeDumper
+    {
+        /// <summary>
+        /// Renders a graph as canonical text.
+        /// </summary>
+        /// <param name="root">The root of the graph.</param>
+        /// <returns>The canonical text of the graph.</returns>
+        public static string Dump(Visual root)
+        {
+            var writer = new Writer();
+            writer.WriteVisual(root);
+            return writer.ToString();
+        }
+
+        sealed class Writer
+        {
+            readonly StringBuilder _builder = new StringBuilder();
+
+            // Ids are assigned per object, in the order that the objects are first
+            // reached. Reference equality is what matters here: two distinct objects with
+            // identical contents are different nodes and must get different ids.
+            readonly Dictionary<object, int> _ids =
+                new Dictionary<object, int>(ReferenceEqualityComparer.Instance);
+
+            int _indent;
+
+            public override string ToString() => _builder.ToString();
+
+            public void WriteVisual(Visual? value)
+            {
+                if (WriteNodeHeader(value, "Visual"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                WriteOptional("BorderMode", value!.BorderMode);
+                WriteOptional("CenterPoint", value.CenterPoint);
+                WriteChild("Clip", value.Clip, WriteClip);
+                WriteOptional("IsVisible", value.IsVisible);
+                WriteOptional("Offset", value.Offset);
+                WriteOptional("Opacity", value.Opacity);
+                WriteOptional("RotationAngleInDegrees", value.RotationAngleInDegrees);
+                WriteOptional("RotationAxis", value.RotationAxis);
+                WriteOptional("Scale", value.Scale);
+                WriteOptional("Size", value.Size);
+                WriteOptional("TransformMatrix", value.TransformMatrix);
+
+                if (value is ContainerVisual container)
+                {
+                    WriteList("Children", container.Children, WriteVisual);
+                }
+
+                switch (value)
+                {
+                    case ShapeVisual shapeVisual:
+                        WriteList("Shapes", shapeVisual.Shapes, WriteShape);
+                        WriteChild("ViewBox", shapeVisual.ViewBox, WriteViewBox);
+                        break;
+                    case SpriteVisual spriteVisual:
+                        WriteChild("Brush", spriteVisual.Brush, WriteBrush);
+                        WriteChild("Shadow", spriteVisual.Shadow, WriteShadow);
+                        break;
+                    case LayerVisual layerVisual:
+                        WriteChild("Shadow", layerVisual.Shadow, WriteShadow);
+                        break;
+                    case ContainerVisual _:
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected visual {value.Type}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteShape(CompositionShape? value)
+            {
+                if (WriteNodeHeader(value, "Shape"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                WriteOptional("CenterPoint", value!.CenterPoint);
+                WriteOptional("Offset", value.Offset);
+                WriteOptional("RotationAngleInDegrees", value.RotationAngleInDegrees);
+                WriteOptional("Scale", value.Scale);
+                WriteOptional("TransformMatrix", value.TransformMatrix);
+
+                switch (value)
+                {
+                    case CompositionContainerShape containerShape:
+                        WriteList("Shapes", containerShape.Shapes, WriteShape);
+                        break;
+                    case CompositionSpriteShape spriteShape:
+                        WriteChild("FillBrush", spriteShape.FillBrush, WriteBrush);
+                        WriteChild("StrokeBrush", spriteShape.StrokeBrush, WriteBrush);
+                        WriteChild("Geometry", spriteShape.Geometry, WriteGeometry);
+                        WriteOptional("IsStrokeNonScaling", spriteShape.IsStrokeNonScaling);
+                        WriteOptional("StrokeDashOffset", spriteShape.StrokeDashOffset);
+                        WriteFloats("StrokeDashArray", spriteShape.StrokeDashArray);
+                        WriteOptional("StrokeDashCap", spriteShape.StrokeDashCap);
+                        WriteOptional("StrokeStartCap", spriteShape.StrokeStartCap);
+                        WriteOptional("StrokeEndCap", spriteShape.StrokeEndCap);
+                        WriteOptional("StrokeLineJoin", spriteShape.StrokeLineJoin);
+                        WriteOptional("StrokeMiterLimit", spriteShape.StrokeMiterLimit);
+                        WriteOptional("StrokeThickness", spriteShape.StrokeThickness);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected shape {value.Type}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteGeometry(CompositionGeometry? value)
+            {
+                if (WriteNodeHeader(value, "Geometry"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                WriteOptional("TrimStart", value!.TrimStart);
+                WriteOptional("TrimEnd", value.TrimEnd);
+                WriteOptional("TrimOffset", value.TrimOffset);
+
+                switch (value)
+                {
+                    case CompositionPathGeometry pathGeometry:
+                        WriteChild(
+                            "Path",
+                            pathGeometry.Path is null ? null : (CanvasGeometry)pathGeometry.Path.Source,
+                            WriteCanvasGeometry);
+                        break;
+                    case CompositionRoundedRectangleGeometry roundedRectangle:
+                        WriteOptional("Offset", roundedRectangle.Offset);
+                        WriteOptional("Size", roundedRectangle.Size);
+                        Write("CornerRadius", roundedRectangle.CornerRadius);
+                        break;
+                    case CompositionRectangleGeometry rectangle:
+                        WriteOptional("Offset", rectangle.Offset);
+                        WriteOptional("Size", rectangle.Size);
+                        break;
+                    case CompositionEllipseGeometry ellipse:
+                        Write("Center", ellipse.Center);
+                        Write("Radius", ellipse.Radius);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected geometry {value.Type}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteBrush(CompositionBrush? value)
+            {
+                if (WriteNodeHeader(value, "Brush"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                switch (value)
+                {
+                    case CompositionColorBrush colorBrush:
+                        WriteOptional("Color", colorBrush.Color);
+                        break;
+                    case CompositionMaskBrush maskBrush:
+                        WriteChild("Source", maskBrush.Source, WriteBrush);
+                        WriteChild("Mask", maskBrush.Mask, WriteBrush);
+                        break;
+                    case CompositionSurfaceBrush surfaceBrush:
+                        WriteChild("Surface", surfaceBrush.Surface, WriteSurface);
+                        break;
+                    case CompositionEffectBrush effectBrush:
+                        var effect = effectBrush.GetEffectFactory().Effect;
+                        WriteChild("Effect", effect, WriteEffect);
+
+                        foreach (var source in effect.Sources)
+                        {
+                            WriteChild(
+                                $"Source({source.Name})",
+                                effectBrush.GetSourceParameter(source.Name),
+                                WriteBrush);
+                        }
+
+                        break;
+                    case CompositionLinearGradientBrush _:
+                    case CompositionRadialGradientBrush _:
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected brush {value!.Type}.");
+                }
+
+                if (value is CompositionGradientBrush gradientBrush)
+                {
+                    WriteOptional("AnchorPoint", gradientBrush.AnchorPoint);
+                    WriteOptional("CenterPoint", gradientBrush.CenterPoint);
+                    WriteList("ColorStops", gradientBrush.ColorStops, WriteGradientStop);
+                    WriteOptional("ExtendMode", gradientBrush.ExtendMode);
+                    WriteOptional("InterpolationSpace", gradientBrush.InterpolationSpace);
+                    WriteOptional("MappingMode", gradientBrush.MappingMode);
+                    WriteOptional("Offset", gradientBrush.Offset);
+                    WriteOptional("RotationAngleInDegrees", gradientBrush.RotationAngleInDegrees);
+                    WriteOptional("Scale", gradientBrush.Scale);
+                    WriteOptional("TransformMatrix", gradientBrush.TransformMatrix);
+
+                    switch (gradientBrush)
+                    {
+                        case CompositionLinearGradientBrush linear:
+                            WriteOptional("StartPoint", linear.StartPoint);
+                            WriteOptional("EndPoint", linear.EndPoint);
+                            break;
+                        case CompositionRadialGradientBrush radial:
+                            WriteOptional("EllipseCenter", radial.EllipseCenter);
+                            WriteOptional("EllipseRadius", radial.EllipseRadius);
+                            WriteOptional("GradientOriginOffset", radial.GradientOriginOffset);
+                            break;
+                    }
+                }
+
+                _indent--;
+            }
+
+            public void WriteGradientStop(CompositionColorGradientStop? value)
+            {
+                if (WriteNodeHeader(value, "GradientStop"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+                Write("Color", value!.Color);
+                Write("Offset", value.Offset);
+                _indent--;
+            }
+
+            public void WriteViewBox(CompositionViewBox? value)
+            {
+                if (WriteNodeHeader(value, "ViewBox"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+                Write("Size", value!.Size);
+                _indent--;
+            }
+
+            public void WriteClip(CompositionClip? value)
+            {
+                if (WriteNodeHeader(value, "Clip"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+                WriteOptional("CenterPoint", value!.CenterPoint);
+                WriteOptional("Scale", value.Scale);
+
+                switch (value)
+                {
+                    case InsetClip inset:
+                        WriteOptional("LeftInset", inset.LeftInset);
+                        WriteOptional("RightInset", inset.RightInset);
+                        WriteOptional("TopInset", inset.TopInset);
+                        WriteOptional("BottomInset", inset.BottomInset);
+                        break;
+                    case CompositionGeometricClip geometric:
+                        WriteChild("Geometry", geometric.Geometry, WriteGeometry);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected clip {value.Type}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteShadow(CompositionShadow? value)
+            {
+                if (WriteNodeHeader(value, "Shadow"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                switch (value)
+                {
+                    case DropShadow dropShadow:
+                        WriteOptional("BlurRadius", dropShadow.BlurRadius);
+                        WriteOptional("Color", dropShadow.Color);
+                        WriteChild("Mask", dropShadow.Mask, WriteBrush);
+                        WriteOptional("Offset", dropShadow.Offset);
+                        WriteOptional("Opacity", dropShadow.Opacity);
+                        WriteOptional("SourcePolicy", dropShadow.SourcePolicy);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected shadow {value!.Type}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteSurface(ICompositionSurface? value)
+            {
+                if (WriteNodeHeader(value, "Surface"))
+                {
+                    return;
+                }
+
+                switch (value)
+                {
+                    case CompositionVisualSurface visualSurface:
+                        WriteCompositionObject(visualSurface);
+                        WriteChild("SourceVisual", visualSurface.SourceVisual, WriteVisual);
+                        WriteOptional("SourceSize", visualSurface.SourceSize);
+                        WriteOptional("SourceOffset", visualSurface.SourceOffset);
+                        break;
+                    case LoadedImageSurfaceFromUri fromUri:
+                        WriteLine($"Kind: FromUri");
+                        WriteLine($"Uri: {fromUri.Uri}");
+                        break;
+                    case LoadedImageSurfaceFromStream fromStream:
+                        WriteLine($"Kind: FromStream");
+                        WriteLine($"Bytes: {Convert.ToBase64String(fromStream.Bytes)}");
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected surface {value!.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteEffect(GraphicsEffectBase? value)
+            {
+                if (WriteNodeHeader(value, "Effect"))
+                {
+                    return;
+                }
+
+                WriteLine($"Sources: {string.Join(", ", value!.Sources.Select(s => s.Name))}");
+
+                switch (value)
+                {
+                    case CompositeEffect composite:
+                        Write("Mode", composite.Mode);
+                        break;
+                    case GaussianBlurEffect blur:
+                        Write("BlurAmount", blur.BlurAmount);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected effect {value.Type}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteEasing(CompositionEasingFunction? value)
+            {
+                if (WriteNodeHeader(value, "Easing"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                switch (value)
+                {
+                    case LinearEasingFunction _:
+                        break;
+                    case CubicBezierEasingFunction cubicBezier:
+                        Write("ControlPoint1", cubicBezier.ControlPoint1);
+                        Write("ControlPoint2", cubicBezier.ControlPoint2);
+                        break;
+                    case StepEasingFunction step:
+                        WriteOptional("StepCount", step.StepCount);
+                        WriteOptional("InitialStep", step.InitialStep);
+                        WriteOptional("FinalStep", step.FinalStep);
+                        WriteOptional("IsInitialStepSingleFrame", step.IsInitialStepSingleFrame);
+                        WriteOptional("IsFinalStepSingleFrame", step.IsFinalStepSingleFrame);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected easing {value!.Type}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteAnimation(CompositionAnimation? value)
+            {
+                if (WriteNodeHeader(value, "Animation"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+                WriteLine($"Target: {Text(value!.Target)}");
+
+                // ReferenceParameters is a dictionary, so it is sorted to make the dump
+                // independent of hash ordering.
+                foreach (var parameter in value.ReferenceParameters.OrderBy(p => p.Key, StringComparer.Ordinal))
+                {
+                    WriteChild($"Reference({parameter.Key})", parameter.Value, WriteCompositionObjectReference);
+                }
+
+                switch (value)
+                {
+                    case ExpressionAnimation expression:
+                        // Expressions are compared as text because that is how they are
+                        // stored in the buffer, and how Windows.UI.Composition accepts them.
+                        WriteLine($"Expression: {expression.Expression.ToText()}");
+                        break;
+                    case KeyFrameAnimation_ keyFrameAnimation:
+                        WriteLine($"Duration: {keyFrameAnimation.Duration.Ticks}");
+
+                        if (value is ColorKeyFrameAnimation color)
+                        {
+                            Write("InterpolationColorSpace", color.InterpolationColorSpace);
+                        }
+
+                        foreach (var keyFrame in keyFrameAnimation.KeyFrames)
+                        {
+                            WriteKeyFrame(keyFrame);
+                        }
+
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected animation {value.Type}.");
+                }
+
+                _indent--;
+            }
+
+            void WriteKeyFrame(KeyFrameAnimation_.KeyFrame value)
+            {
+                WriteLine($"KeyFrame @{Text(value.Progress)}");
+                _indent++;
+                WriteChild("Easing", value.Easing, WriteEasing);
+
+                switch (value)
+                {
+                    case KeyFrameAnimation_.ExpressionKeyFrame expression:
+                        WriteLine($"Expression: {expression.Expression.ToText()}");
+                        break;
+                    case KeyFrameAnimation<float, Expressions.Scalar>.ValueKeyFrame scalar:
+                        WriteLine($"Value: {Text(scalar.Value)}");
+                        break;
+                    case KeyFrameAnimation<bool, Expressions.Boolean>.ValueKeyFrame boolean:
+                        WriteLine($"Value: {boolean.Value}");
+                        break;
+                    case KeyFrameAnimation<Vector2, Expressions.Vector2>.ValueKeyFrame vector2:
+                        WriteLine($"Value: {Text(vector2.Value)}");
+                        break;
+                    case KeyFrameAnimation<Vector3, Expressions.Vector3>.ValueKeyFrame vector3:
+                        WriteLine($"Value: {Text(vector3.Value)}");
+                        break;
+                    case KeyFrameAnimation<Vector4, Expressions.Vector4>.ValueKeyFrame vector4:
+                        WriteLine($"Value: {Text(vector4.Value)}");
+                        break;
+                    case KeyFrameAnimation<Wui.Color, Expressions.Color>.ValueKeyFrame color:
+                        WriteLine($"Value: {Text(color.Value)}");
+                        break;
+                    case KeyFrameAnimation<CompositionPath, Expressions.Void>.ValueKeyFrame path:
+                        WriteChild("Value", (CanvasGeometry)path.Value.Source, WriteCanvasGeometry);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected key frame {value.Type}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteCanvasGeometry(CanvasGeometry? value)
+            {
+                if (WriteNodeHeader(value, "CanvasGeometry"))
+                {
+                    return;
+                }
+
+                switch (value)
+                {
+                    case CanvasGeometry.Combination combination:
+                        WriteChild("A", combination.A, WriteCanvasGeometry);
+                        WriteChild("B", combination.B, WriteCanvasGeometry);
+                        Write("CombineMode", combination.CombineMode);
+                        Write("Matrix", combination.Matrix);
+                        break;
+                    case CanvasGeometry.TransformedGeometry transformed:
+                        WriteChild("Source", transformed.SourceGeometry, WriteCanvasGeometry);
+                        Write("TransformMatrix", transformed.TransformMatrix);
+                        break;
+                    case CanvasGeometry.Group group:
+                        Write("FilledRegionDetermination", group.FilledRegionDetermination);
+                        WriteList("Geometries", group.Geometries, WriteCanvasGeometry);
+                        break;
+                    case CanvasGeometry.Path path:
+                        Write("FilledRegionDetermination", path.FilledRegionDetermination);
+
+                        foreach (var command in path.Commands)
+                        {
+                            WriteLine(Text(command));
+                        }
+
+                        break;
+                    case CanvasGeometry.Ellipse ellipse:
+                        WriteLine(
+                            $"Ellipse: {Text(ellipse.X)} {Text(ellipse.Y)} " +
+                            $"{Text(ellipse.RadiusX)} {Text(ellipse.RadiusY)}");
+                        break;
+                    case CanvasGeometry.RoundedRectangle rectangle:
+                        WriteLine(
+                            $"RoundedRectangle: {Text(rectangle.X)} {Text(rectangle.Y)} " +
+                            $"{Text(rectangle.W)} {Text(rectangle.H)} " +
+                            $"{Text(rectangle.RadiusX)} {Text(rectangle.RadiusY)}");
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected canvas geometry {value!.Type}.");
+                }
+
+                _indent--;
+            }
+
+            void WriteCompositionObjectReference(CompositionObject? value)
+            {
+                switch (value)
+                {
+                    case null:
+                        WriteLine("null");
+                        break;
+                    case Visual visual:
+                        WriteVisual(visual);
+                        break;
+                    case CompositionShape shape:
+                        WriteShape(shape);
+                        break;
+                    case CompositionGeometry geometry:
+                        WriteGeometry(geometry);
+                        break;
+                    case CompositionBrush brush:
+                        WriteBrush(brush);
+                        break;
+                    case CompositionAnimation animation:
+                        WriteAnimation(animation);
+                        break;
+                    case CompositionEasingFunction easing:
+                        WriteEasing(easing);
+                        break;
+                    case CompositionPropertySet propertySet:
+                        WritePropertySet(propertySet);
+                        break;
+                    case CompositionVisualSurface surface:
+                        WriteSurface(surface);
+                        break;
+                    case CompositionClip clip:
+                        WriteClip(clip);
+                        break;
+                    case AnimationController controller:
+                        WriteController(controller);
+                        break;
+                    case CompositionShadow shadow:
+                        WriteShadow(shadow);
+                        break;
+                    case CompositionColorGradientStop stop:
+                        WriteGradientStop(stop);
+                        break;
+                    case CompositionViewBox viewBox:
+                        WriteViewBox(viewBox);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected reference to {value.Type}.");
+                }
+            }
+
+            void WritePropertySet(CompositionPropertySet? value)
+            {
+                if (WriteNodeHeader(value, "PropertySet"))
+                {
+                    return;
+                }
+
+                WritePropertySetContents(value!);
+                _indent--;
+            }
+
+            void WriteController(AnimationController? value)
+            {
+                if (WriteNodeHeader(value, "Controller"))
+                {
+                    return;
+                }
+
+                WriteLine($"IsCustom: {value!.IsCustom}");
+                WriteLine($"IsPaused: {value.IsPaused}");
+                WriteLine($"TargetProperty: {Text(value.TargetProperty)}");
+                WriteCompositionObject(value);
+                _indent--;
+            }
+
+            // Writes the state that every CompositionObject has. The property set is
+            // written inline rather than as a node, because it belongs to the object.
+            void WriteCompositionObject(CompositionObject value)
+            {
+                if (value.Comment is not null)
+                {
+                    WriteLine($"Comment: {value.Comment}");
+                }
+
+                // Properties is created on demand, so it is only written when the object
+                // actually has some, which is exactly when it is serialized.
+                var properties = value.Properties;
+                if (value.Type != CompositionObjectType.CompositionPropertySet &&
+                    (properties.Names.Count > 0 || properties.Animators.Any()))
+                {
+                    WriteLine("Properties");
+                    _indent++;
+                    WritePropertySetContents(properties);
+                    _indent--;
+                }
+
+                foreach (var animator in value.Animators)
+                {
+                    WriteLine($"Animator: {animator.AnimatedProperty}");
+                    _indent++;
+                    WriteChild("Animation", animator.Animation, WriteAnimation);
+
+                    if (animator.Controller is not null)
+                    {
+                        WriteChild("Controller", animator.Controller, WriteController);
+                    }
+
+                    _indent--;
+                }
+            }
+
+            void WritePropertySetContents(CompositionPropertySet value)
+            {
+                // Names is a SortedDictionary, so this order is already canonical.
+                foreach (var (name, type) in value.Names.Select(n => (n.Key, n.Value)))
+                {
+                    switch (type)
+                    {
+                        case PropertySetValueType.Color:
+                            value.TryGetColor(name, out var color);
+                            WriteLine($"{name}: {Text(color!.Value)}");
+                            break;
+                        case PropertySetValueType.Scalar:
+                            value.TryGetScalar(name, out var scalar);
+                            WriteLine($"{name}: {Text(scalar!.Value)}");
+                            break;
+                        case PropertySetValueType.Vector2:
+                            value.TryGetVector2(name, out var vector2);
+                            WriteLine($"{name}: {Text(vector2!.Value)}");
+                            break;
+                        case PropertySetValueType.Vector3:
+                            value.TryGetVector3(name, out var vector3);
+                            WriteLine($"{name}: {Text(vector3!.Value)}");
+                            break;
+                        case PropertySetValueType.Vector4:
+                            value.TryGetVector4(name, out var vector4);
+                            WriteLine($"{name}: {Text(vector4!.Value)}");
+                            break;
+                        default:
+                            throw new InvalidOperationException($"Unexpected property {type}.");
+                    }
+                }
+
+                foreach (var animator in value.Animators)
+                {
+                    WriteLine($"Animator: {animator.AnimatedProperty}");
+                    _indent++;
+                    WriteChild("Animation", animator.Animation, WriteAnimation);
+                    _indent--;
+                }
+            }
+
+            // Writes the "Kind #id" line that starts a node, and returns true if the node
+            // has been written before, in which case the caller must not write it again.
+            // Leaves the indent increased when it returns false.
+            bool WriteNodeHeader(object? value, string category)
+            {
+                if (value is null)
+                {
+                    WriteLine($"{category}: null");
+                    return true;
+                }
+
+                if (_ids.TryGetValue(value, out var existing))
+                {
+                    WriteLine($"{category} #{existing} (shared)");
+                    return true;
+                }
+
+                var id = _ids.Count;
+                _ids.Add(value, id);
+                WriteLine($"{category} #{id} {TypeNameOf(value)}");
+                _indent++;
+                return false;
+            }
+
+            static string TypeNameOf(object value)
+                => value switch
+                {
+                    CompositionObject compositionObject => compositionObject.Type.ToString(),
+                    CanvasGeometry canvasGeometry => canvasGeometry.Type.ToString(),
+                    GraphicsEffectBase effect => effect.Type.ToString(),
+                    LoadedImageSurface surface => surface.Type.ToString(),
+                    _ => value.GetType().Name,
+                };
+
+            void WriteChild<T>(string name, T? value, Action<T?> write)
+                where T : class
+            {
+                WriteLine($"{name}:");
+                _indent++;
+                write(value);
+                _indent--;
+            }
+
+            void WriteList<T>(string name, IEnumerable<T> values, Action<T?> write)
+                where T : class
+            {
+                var array = values.ToArray();
+                if (array.Length == 0)
+                {
+                    return;
+                }
+
+                WriteLine($"{name}: [{array.Length}]");
+                _indent++;
+                foreach (var value in array)
+                {
+                    write(value);
+                }
+
+                _indent--;
+            }
+
+            // Written only when the property has a value, so that "never set" and "set to
+            // the default" stay distinguishable, exactly as they are in the buffer.
+            void WriteOptional<T>(string name, T? value)
+                where T : struct
+            {
+                if (value.HasValue)
+                {
+                    WriteLine($"{name}: {Text(value.Value)}");
+                }
+            }
+
+            void Write<T>(string name, T value)
+                where T : struct
+                => WriteLine($"{name}: {Text(value)}");
+
+            void WriteFloats(string name, IEnumerable<float> values)
+            {
+                var array = values.ToArray();
+                if (array.Length > 0)
+                {
+                    WriteLine($"{name}: {string.Join(", ", array.Select(v => Text(v)))}");
+                }
+            }
+
+            void WriteLine(string text)
+                => _builder.Append(' ', _indent * 2).Append(text).Append('\n');
+
+            // Values are formatted with round trip precision and the invariant culture, so
+            // that the dump is exact and machine independent.
+            static string Text(object? value)
+                => value switch
+                {
+                    null => "null",
+                    float f => f.ToString("R", CultureInfo.InvariantCulture),
+                    Vector2 v => $"<{Text(v.X)}, {Text(v.Y)}>",
+                    Vector3 v => $"<{Text(v.X)}, {Text(v.Y)}, {Text(v.Z)}>",
+                    Vector4 v => $"<{Text(v.X)}, {Text(v.Y)}, {Text(v.Z)}, {Text(v.W)}>",
+                    Matrix3x2 m =>
+                        $"[{Text(m.M11)}, {Text(m.M12)}, {Text(m.M21)}, " +
+                        $"{Text(m.M22)}, {Text(m.M31)}, {Text(m.M32)}]",
+                    Matrix4x4 m =>
+                        $"[{Text(m.M11)}, {Text(m.M12)}, {Text(m.M13)}, {Text(m.M14)}, " +
+                        $"{Text(m.M21)}, {Text(m.M22)}, {Text(m.M23)}, {Text(m.M24)}, " +
+                        $"{Text(m.M31)}, {Text(m.M32)}, {Text(m.M33)}, {Text(m.M34)}, " +
+                        $"{Text(m.M41)}, {Text(m.M42)}, {Text(m.M43)}, {Text(m.M44)}]",
+                    Wui.Color c => $"#{c.A:X2}{c.R:X2}{c.G:X2}{c.B:X2}",
+                    CanvasPathBuilder.Command.BeginFigure begin => $"BeginFigure {Text(begin.StartPoint)}",
+                    CanvasPathBuilder.Command.EndFigure end => $"EndFigure {end.FigureLoop}",
+                    CanvasPathBuilder.Command.AddLine line => $"AddLine {Text(line.EndPoint)}",
+                    CanvasPathBuilder.Command.AddCubicBezier bezier =>
+                        $"AddCubicBezier {Text(bezier.ControlPoint1)} " +
+                        $"{Text(bezier.ControlPoint2)} {Text(bezier.EndPoint)}",
+                    _ => value.ToString() ?? string.Empty,
+                };
+        }
+
+        sealed class ReferenceEqualityComparer : IEqualityComparer<object>
+        {
+            internal static readonly ReferenceEqualityComparer Instance = new ReferenceEqualityComparer();
+
+            ReferenceEqualityComparer()
+            {
+            }
+
+            bool IEqualityComparer<object>.Equals(object? x, object? y) => ReferenceEquals(x, y);
+
+            int IEqualityComparer<object>.GetHashCode(object obj)
+                => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+        }
+    }
+}
diff --git a/tests/CompDataFlatbuffer.Tests/Corpus.cs b/tests/CompDataFlatbuffer.Tests/Corpus.cs
new file mode 100644
index 00000000..69bddd44
--- /dev/null
+++ b/tests/CompDataFlatbuffer.Tests/Corpus.cs
@@ -0,0 +1,141 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using CommunityToolkit.WinUI.Lottie.CompMetadata;
+using CommunityToolkit.WinUI.Lottie.LottieData;
+using CommunityToolkit.WinUI.Lottie.LottieData.Serialization;
+using CommunityToolkit.WinUI.Lottie.LottieMetadata;
+using CommunityToolkit.WinUI.Lottie.LottieToWinComp;
+using CommunityToolkit.WinUI.Lottie.WinCompData;
+using IoPath = System.IO.Path;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Tests
+{
+    /// <summary>
+    /// Loads the Lottie files that the tests run against and translates them to
+    /// WinCompData graphs.
+    /// </summary>
+    static class Corpus
+    {
+        // The well known keys under which the translator stores its metadata. These are
+        // the same values that LottieGen uses to retrieve it.
+        static readonly Guid LottieMetadataKey = new Guid("EA3D6538-361A-4B1C-960D-50A6C35DC0B4");
+        static readonly Guid PropertyBindingNamesKey = new Guid("A115C46A-254C-43E6-A3C7-9DE516C3C3C8");
+
+        /// <summary>
+        /// Gets the names of the Lottie files that the tests run against.
+        /// </summary>
+        /// <returns>A test case per Lottie file.</returns>
+        public static IEnumerable<object[]> FileNames()
+            => Directory.EnumerateFiles(AssetsFolder, "*.json")
+                .Select(IoPath.GetFileName)
+                .OrderBy(name => name, StringComparer.Ordinal)
+                .Select(name => new object[] { name! });
+
+        static string AssetsFolder
+        {
+            get
+            {
+                // The tests run from the build output folder, so the repository root is
+                // found by walking up to the folder that contains the samples.
+                var directory = new DirectoryInfo(AppContext.BaseDirectory);
+
+                while (directory is not null)
+                {
+                    var candidate = IoPath.Combine(directory.FullName, "LottieSamples", "Assets");
+                    if (Directory.Exists(candidate))
+                    {
+                        return candidate;
+                    }
+
+                    directory = directory.Parent;
+                }
+
+                throw new InvalidOperationException("Could not locate LottieSamples/Assets.");
+            }
+        }
+
+        /// <summary>
+        /// Reads and translates one of the Lottie files.
+        /// </summary>
+        /// <param name="fileName">The name of the file within the samples folder.</param>
+        /// <returns>The translated graph and the metadata that accompanies it.</returns>
+        public static TranslatedLottie Translate(string fileName)
+        {
+            using var stream = File.OpenRead(IoPath.Combine(AssetsFolder, fileName));
+
+            var lottie = LottieCompositionReader.ReadLottieCompositionFromJsonStream(
+                stream,
+                LottieCompositionReader.Options.IgnoreMatchNames,
+                out var readerIssues);
+
+            if (lottie is null)
+            {
+                throw new InvalidOperationException(
+                    $"Failed to read {fileName}: {string.Join("; ", readerIssues.Select(i => i.Description))}");
+            }
+
+            var result = LottieToWinCompTranslator.TryTranslateLottieComposition(
+                lottie,
+                new TranslatorConfiguration
+                {
+                    AddCodegenDescriptions = true,
+                    TranslatePropertyBindings = true,
+
+                    // The newest version is targeted so that the translation uses every
+                    // feature it can, which gives the tests the widest coverage.
+                    TargetUapVersion = uint.MaxValue,
+                });
+
+            if (result.RootVisual is null)
+            {
+                throw new InvalidOperationException($"Failed to translate {fileName}.");
+            }
+
+            return new TranslatedLottie(
+                result.RootVisual,
+                checked((ushort)result.MinimumRequiredUapVersion),
+                result.SourceMetadata.TryGetValue(LottieMetadataKey, out var metadata)
+                    ? (LottieCompositionMetadata)metadata
+                    : null,
+                result.SourceMetadata.TryGetValue(PropertyBindingNamesKey, out var bindings)
+                    ? (IReadOnlyList<PropertyBinding>)bindings
+                    : null,
+                (float)lottie.Width,
+                (float)lottie.Height);
+        }
+
+        /// <summary>
+        /// A translated Lottie file, and everything needed to serialize it.
+        /// </summary>
+        /// <param name="RootVisual">The root of the translated graph.</param>
+        /// <param name="RequiredUapVersion">The minimum UAP version needed to instantiate the graph.</param>
+        /// <param name="Metadata">Metadata about the source animation.</param>
+        /// <param name="PropertyBindings">The property bindings that the graph exposes.</param>
+        /// <param name="Width">The width of the source animation.</param>
+        /// <param name="Height">The height of the source animation.</param>
+        public sealed record TranslatedLottie(
+            Visual RootVisual,
+            ushort RequiredUapVersion,
+            LottieCompositionMetadata? Metadata,
+            IReadOnlyList<PropertyBinding>? PropertyBindings,
+            float Width,
+            float Height)
+        {
+            /// <summary>
+            /// Serializes the graph.
+            /// </summary>
+            /// <returns>The serialized graph.</returns>
+            public byte[] Serialize()
+                => CompositionSerializer.Serialize(
+                    RootVisual, RequiredUapVersion, Metadata, PropertyBindings, Width, Height);
+        }
+    }
+}
diff --git a/tests/CompDataFlatbuffer.Tests/RoundTripTests.cs b/tests/CompDataFlatbuffer.Tests/RoundTripTests.cs
new file mode 100644
index 00000000..24a3ac08
--- /dev/null
+++ b/tests/CompDataFlatbuffer.Tests/RoundTripTests.cs
@@ -0,0 +1,120 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Linq;
+using CommunityToolkit.WinUI.Lottie.WinCompData;
+using Xunit;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Tests
+{
+    /// <summary>
+    /// Verifies that a graph survives a trip through the FlatBuffer format unchanged.
+    /// </summary>
+    /// <remarks>
+    /// This is the test that the FlatBuffer based player produces the same visual tree
+    /// as the JSON based one. The JSON path is Lottie file to translator to
+    /// WinCompData graph. The FlatBuffer path is that same graph serialized and read
+    /// back. If the two graphs are identical then any interpreter that walks one
+    /// produces the same visuals as an interpreter that walks the other, so the
+    /// comparison is made once here rather than being repeated for every player.
+    /// </remarks>
+    public class RoundTripTests
+    {
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void RoundTripPreservesTheGraph(string fileName)
+        {
+            var translated = Corpus.Translate(fileName);
+
+            var expected = CompositionTreeDumper.Dump(translated.RootVisual);
+            var actual = CompositionTreeDumper.Dump(CompositionDeserializer.Deserialize(translated.Serialize()));
+
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void SerializationIsDeterministic(string fileName)
+        {
+            var translated = Corpus.Translate(fileName);
+
+            // The same graph must always produce the same bytes, otherwise builds are
+            // not reproducible and the output cannot be cached or diffed.
+            Assert.Equal(translated.Serialize(), translated.Serialize());
+        }
+
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void RoundTripIsStable(string fileName)
+        {
+            var translated = Corpus.Translate(fileName);
+
+            // Serializing a deserialized graph must reproduce the original bytes. This
+            // catches any state that the deserializer drops but the dump does not cover.
+            var once = translated.Serialize();
+            var twice = CompositionSerializer.Serialize(
+                CompositionDeserializer.Deserialize(once),
+                translated.RequiredUapVersion,
+                translated.Metadata,
+                translated.PropertyBindings,
+                translated.Width,
+                translated.Height);
+
+            Assert.Equal(once, twice);
+        }
+
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void DeserializedGraphSharesNodes(string fileName)
+        {
+            var translated = Corpus.Translate(fileName);
+            var root = CompositionDeserializer.Deserialize(translated.Serialize());
+
+            // A node that is reached by more than one path must be one object, not a
+            // copy per path, otherwise a large animation would expand enormously and
+            // animations bound to a shared object would stop being shared.
+            Assert.Equal(CountDistinct(translated.RootVisual), CountDistinct(root));
+        }
+
+        // Counts the distinct visuals reachable from a root.
+        static int CountDistinct(Visual root)
+        {
+            var seen = new System.Collections.Generic.HashSet<Visual>(
+                ReferenceEqualityComparer<Visual>.Instance);
+
+            void Walk(Visual visual)
+            {
+                if (!seen.Add(visual))
+                {
+                    return;
+                }
+
+                if (visual is ContainerVisual container)
+                {
+                    foreach (var child in container.Children)
+                    {
+                        Walk(child);
+                    }
+                }
+            }
+
+            Walk(root);
+            return seen.Count;
+        }
+
+        sealed class ReferenceEqualityComparer<T> : System.Collections.Generic.IEqualityComparer<T>
+            where T : class
+        {
+            internal static readonly ReferenceEqualityComparer<T> Instance = new ReferenceEqualityComparer<T>();
+
+            public bool Equals(T? x, T? y) => ReferenceEquals(x, y);
+
+            public int GetHashCode(T obj)
+                => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+        }
+    }
+}

From 4de1b91aeb2e540d3a671755bb1d9a02493c869c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 18:34:48 +0000
Subject: [PATCH 08/39] Reject malformed buffers as format errors; add
 robustness tests

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 .../CompositionDeserializer.cs                | 61 +++++++++---
 .../FlatBufferFormatException.cs              | 10 ++
 .../RobustnessTests.cs                        | 92 +++++++++++++++++++
 3 files changed, 150 insertions(+), 13 deletions(-)
 create mode 100644 tests/CompDataFlatbuffer.Tests/RobustnessTests.cs

diff --git a/source/CompDataFlatbuffer/CompositionDeserializer.cs b/source/CompDataFlatbuffer/CompositionDeserializer.cs
index 8d2d502d..efda0849 100644
--- a/source/CompDataFlatbuffer/CompositionDeserializer.cs
+++ b/source/CompDataFlatbuffer/CompositionDeserializer.cs
@@ -40,6 +40,11 @@ namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer
 #endif
     sealed class CompositionDeserializer
     {
+        // The smallest buffer that could possibly be a composition: a root offset
+        // followed by the four byte file identifier. Checked before the identifier is
+        // read so that a short buffer is reported as a format error.
+        const int MinimumBufferLength = 8;
+
         readonly Compositor _compositor = new Compositor();
         readonly Fb.LottieComposition _root;
         readonly string[] _strings;
@@ -101,25 +106,46 @@ public static Visual Deserialize(ReadOnlySpan<byte> bytes)
             // The buffer is untrusted, so it is fully verified before any of it is read.
             var buffer = new ByteBuffer(bytes.ToArray());
 
-            // This checks the file identifier as well as the structure, so a buffer that
-            // is not a composition at all is rejected here.
-            if (!Fb.LottieComposition.VerifyLottieComposition(buffer))
+            if (bytes.Length < MinimumBufferLength ||
+                !Fb.LottieComposition.LottieCompositionBufferHasIdentifier(buffer))
             {
-                throw new FlatBufferFormatException("The buffer is not a valid composition.");
+                throw new FlatBufferFormatException("The buffer is not a composition.");
             }
 
-            var root = Fb.LottieComposition.GetRootAsLottieComposition(buffer);
-
-            if (root.SchemaVersion > Format.Version)
+            // Verification proves that the buffer is structurally sound, but it cannot
+            // prove that the indices stored in it point at the right things. Neither the
+            // verifier nor the reader reports a malformed buffer purely by returning
+            // false; both also throw. Everything is therefore done inside this handler so
+            // that a corrupt buffer always surfaces as a format error and never as an
+            // exception that a caller could not have anticipated. Reading past the end of
+            // the buffer is not a safety problem because ByteBuffer is bounds checked;
+            // the only thing being corrected here is the type of the exception.
+            try
             {
-                throw new FlatBufferFormatException(
-                    $"Schema version {root.SchemaVersion} is newer than the supported version {Format.Version}.");
-            }
+                if (!Fb.LottieComposition.VerifyLottieComposition(buffer))
+                {
+                    throw new FlatBufferFormatException("The buffer is not a valid composition.");
+                }
+
+                var root = Fb.LottieComposition.GetRootAsLottieComposition(buffer);
 
-            var deserializer = new CompositionDeserializer(root);
-            var rootVisual = deserializer.GetVisual(root.RootVisual);
+                if (root.SchemaVersion > Format.Version)
+                {
+                    throw new FlatBufferFormatException(
+                        $"Schema version {root.SchemaVersion} is newer than the supported version {Format.Version}.");
+                }
 
-            return rootVisual ?? throw new FlatBufferFormatException("The composition has no root visual.");
+                var deserializer = new CompositionDeserializer(root);
+                var rootVisual = deserializer.GetVisual(root.RootVisual);
+
+                return rootVisual ?? throw new FlatBufferFormatException("The composition has no root visual.");
+            }
+            catch (Exception e) when (e is ArgumentException or IndexOutOfRangeException or
+                                          InvalidOperationException or OverflowException or
+                                          FormatException or NullReferenceException)
+            {
+                throw new FlatBufferFormatException("The buffer is malformed.", e);
+            }
         }
 
         // ---------------------------------------------------------------------
@@ -181,6 +207,15 @@ void InitializeCompositionObject(CompositionObject target, Fb.CompObj? source)
                     ? GetController(controllerIndex)
                     : null;
 
+                // An expression animation is driven by its inputs and so cannot have a
+                // controller. StartAnimation only asserts this, so it is checked here in
+                // order to reject the buffer rather than build an unusable graph.
+                if (customController is not null && animation is ExpressionAnimation)
+                {
+                    throw new FlatBufferFormatException(
+                        $"Animator '{property}' gives a controller to an expression animation.");
+                }
+
                 var created = target.StartAnimation(property, animation, customController);
 
                 if (controllerIndex != Format.NullIndex && created.Controller is not null)
diff --git a/source/CompDataFlatbuffer/FlatBufferFormatException.cs b/source/CompDataFlatbuffer/FlatBufferFormatException.cs
index 5a7c9531..3779041c 100644
--- a/source/CompDataFlatbuffer/FlatBufferFormatException.cs
+++ b/source/CompDataFlatbuffer/FlatBufferFormatException.cs
@@ -28,5 +28,15 @@ public FlatBufferFormatException(string message)
             : base(message)
         {
         }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FlatBufferFormatException"/> class.
+        /// </summary>
+        /// <param name="message">A description of what was wrong with the buffer.</param>
+        /// <param name="innerException">The failure that revealed the problem.</param>
+        public FlatBufferFormatException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
     }
 }
diff --git a/tests/CompDataFlatbuffer.Tests/RobustnessTests.cs b/tests/CompDataFlatbuffer.Tests/RobustnessTests.cs
new file mode 100644
index 00000000..aa108d25
--- /dev/null
+++ b/tests/CompDataFlatbuffer.Tests/RobustnessTests.cs
@@ -0,0 +1,92 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using Xunit;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Tests
+{
+    /// <summary>
+    /// Verifies that malformed input is rejected rather than being allowed to
+    /// corrupt the reader.
+    /// </summary>
+    /// <remarks>
+    /// A serialized composition is likely to be loaded from a file or downloaded, so
+    /// it has to be treated as untrusted. Every one of these cases must fail with a
+    /// <see cref="FlatBufferFormatException"/>: no other exception type, no crash, and
+    /// no hang. The native interpreter performs the same checks, so this is also a
+    /// specification of what that interpreter has to reject.
+    /// </remarks>
+    public class RobustnessTests
+    {
+        [Fact]
+        public void EmptyBufferIsRejected()
+            => Assert.Throws<FlatBufferFormatException>(() => CompositionDeserializer.Deserialize(Array.Empty<byte>()));
+
+        [Fact]
+        public void GarbageIsRejected()
+        {
+            var garbage = new byte[512];
+            new Random(0).NextBytes(garbage);
+
+            Assert.Throws<FlatBufferFormatException>(() => CompositionDeserializer.Deserialize(garbage));
+        }
+
+        [Fact]
+        public void BufferWithTheWrongFileIdentifierIsRejected()
+        {
+            var buffer = Corpus.Translate("LightBulb.json").Serialize();
+
+            // The file identifier sits at offset 4, immediately after the root offset.
+            buffer[4] = (byte)'X';
+
+            Assert.Throws<FlatBufferFormatException>(() => CompositionDeserializer.Deserialize(buffer));
+        }
+
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void TruncatedBuffersAreRejected(string fileName)
+        {
+            var buffer = Corpus.Translate(fileName).Serialize();
+
+            // Truncation is checked at a spread of lengths rather than at every length,
+            // which would make the test run for minutes without finding anything more.
+            for (var length = 0; length < buffer.Length; length += Math.Max(1, buffer.Length / 64))
+            {
+                var truncated = new byte[length];
+                Array.Copy(buffer, truncated, length);
+
+                Assert.Throws<FlatBufferFormatException>(() => CompositionDeserializer.Deserialize(truncated));
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void CorruptedBuffersDoNotCrash(string fileName)
+        {
+            var original = Corpus.Translate(fileName).Serialize();
+            var random = new Random(fileName.GetHashCode(StringComparison.Ordinal));
+
+            // Unlike truncation, a flipped bit may leave a buffer that is still valid,
+            // just describing a different animation. So the requirement here is weaker:
+            // the reader either succeeds or reports a format error, but never throws
+            // something else and never reads outside the buffer.
+            for (var i = 0; i < 200; i++)
+            {
+                var corrupted = (byte[])original.Clone();
+                corrupted[random.Next(corrupted.Length)] ^= (byte)(1 << random.Next(8));
+
+                try
+                {
+                    CompositionDeserializer.Deserialize(corrupted);
+                }
+                catch (FlatBufferFormatException)
+                {
+                }
+            }
+        }
+    }
+}

From 428db708cc2813c02978fbfeff45c742e8d81274 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 18:39:05 +0000
Subject: [PATCH 09/39] Add coverage tests exercising every
 CompositionObjectType and geometry kind

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 .../CompDataFlatbuffer.Tests/CoverageTests.cs | 474 ++++++++++++++++++
 1 file changed, 474 insertions(+)
 create mode 100644 tests/CompDataFlatbuffer.Tests/CoverageTests.cs

diff --git a/tests/CompDataFlatbuffer.Tests/CoverageTests.cs b/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
new file mode 100644
index 00000000..7dfd7f21
--- /dev/null
+++ b/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
@@ -0,0 +1,474 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using CommunityToolkit.WinUI.Lottie.WinCompData;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgc;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgce;
+using CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg;
+using CommunityToolkit.WinUI.Lottie.WinUIXamlMediaData;
+using Xunit;
+using Expr = CommunityToolkit.WinUI.Lottie.WinCompData.Expressions;
+using Wui = CommunityToolkit.WinUI.Lottie.WinCompData.Wui;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Tests
+{
+    /// <summary>
+    /// Verifies that every kind of node that a graph can contain survives serialization.
+    /// </summary>
+    /// <remarks>
+    /// The sample animations exercise the parts of the object model that the translator
+    /// happens to emit for them, which is not all of it. This builds a graph that
+    /// contains at least one of every <see cref="CompositionObjectType"/>, every
+    /// <see cref="CanvasGeometry"/> shape, every path command and every effect, and
+    /// round trips that. Together with <see cref="AllCompositionObjectTypesAreCovered"/>
+    /// this means a node type cannot be added to WinCompData without either being
+    /// handled here or failing the build.
+    /// </remarks>
+    public class CoverageTests
+    {
+        [Fact]
+        public void AllCompositionObjectTypesAreCovered()
+        {
+            var covered = Collect(BuildGraph())
+                .Select(o => o.Type)
+                .ToHashSet();
+
+            var missing = Enum.GetValues<CompositionObjectType>()
+                .Where(t => !covered.Contains(t))
+                .ToArray();
+
+            Assert.True(
+                missing.Length == 0,
+                $"The coverage graph does not contain: {string.Join(", ", missing)}.");
+        }
+
+        [Fact]
+        public void EveryNodeTypeSurvivesARoundTrip()
+        {
+            var root = BuildGraph();
+
+            var expected = CompositionTreeDumper.Dump(root);
+            var actual = CompositionTreeDumper.Dump(
+                CompositionDeserializer.Deserialize(CompositionSerializer.Serialize(root, 14, null, null, 100, 100)));
+
+            Assert.Equal(expected, actual);
+        }
+
+        // Builds a graph containing one of everything. It is not a sensible animation;
+        // its only job is to reach every branch of the serializer and the deserializer.
+        static Visual BuildGraph()
+        {
+            var c = new Compositor();
+
+            var root = c.CreateContainerVisual();
+            root.Comment = "Root";
+            root.Offset = new Vector3(1, 2, 3);
+            root.CenterPoint = new Vector3(4, 5, 6);
+            root.RotationAngleInDegrees = 45;
+            root.RotationAxis = new Vector3(0, 0, 1);
+            root.Scale = new Vector3(2, 2, 2);
+            root.Size = new Vector2(100, 100);
+            root.Opacity = 0.5f;
+            root.IsVisible = true;
+            root.BorderMode = CompositionBorderMode.Soft;
+            root.TransformMatrix = Matrix4x4.Identity;
+
+            // Clips. An inset clip on the root, a geometric clip further down.
+            var insetClip = c.CreateInsetClip();
+            insetClip.LeftInset = 1;
+            insetClip.RightInset = 2;
+            insetClip.TopInset = 3;
+            insetClip.BottomInset = 4;
+            root.Clip = insetClip;
+
+            // Easings.
+            var linear = c.CreateLinearEasingFunction();
+            var cubic = c.CreateCubicBezierEasingFunction(new Vector2(0.1f, 0.2f), new Vector2(0.3f, 0.4f));
+            var step = c.CreateStepEasingFunction(3);
+            step.IsInitialStepSingleFrame = true;
+            step.IsFinalStepSingleFrame = true;
+            step.InitialStep = 1;
+            step.FinalStep = 2;
+
+            // Every kind of key frame animation, using every kind of easing and both
+            // kinds of key frame (a value and an expression).
+            var scalarAnimation = c.CreateScalarKeyFrameAnimation();
+            scalarAnimation.Duration = TimeSpan.FromSeconds(1);
+            scalarAnimation.InsertKeyFrame(0, 0, linear);
+            scalarAnimation.InsertKeyFrame(0.5f, 1, cubic);
+            scalarAnimation.InsertExpressionKeyFrame(1, Expr.Expression.Scalar("0"), step);
+
+            var booleanAnimation = c.CreateBooleanKeyFrameAnimation();
+            booleanAnimation.Duration = TimeSpan.FromSeconds(1);
+            booleanAnimation.InsertKeyFrame(0, false);
+            booleanAnimation.InsertKeyFrame(1, true);
+
+            var colorAnimation = c.CreateColorKeyFrameAnimation();
+            colorAnimation.Duration = TimeSpan.FromSeconds(1);
+            colorAnimation.InterpolationColorSpace = CompositionColorSpace.Hsl;
+            colorAnimation.InsertKeyFrame(0, Wui.Color.FromArgb(255, 1, 2, 3), linear);
+            colorAnimation.InsertKeyFrame(1, Wui.Color.FromArgb(0, 4, 5, 6), linear);
+
+            var vector2Animation = c.CreateVector2KeyFrameAnimation();
+            vector2Animation.Duration = TimeSpan.FromSeconds(1);
+            vector2Animation.InsertKeyFrame(0, new Vector2(1, 2), linear);
+
+            var vector3Animation = c.CreateVector3KeyFrameAnimation();
+            vector3Animation.Duration = TimeSpan.FromSeconds(1);
+            vector3Animation.InsertKeyFrame(0, new Vector3(1, 2, 3), linear);
+
+            var vector4Animation = c.CreateVector4KeyFrameAnimation();
+            vector4Animation.Duration = TimeSpan.FromSeconds(1);
+            vector4Animation.InsertKeyFrame(0, new Vector4(1, 2, 3, 4), linear);
+
+            var pathAnimation = c.CreatePathKeyFrameAnimation();
+            pathAnimation.Duration = TimeSpan.FromSeconds(1);
+            pathAnimation.InsertKeyFrame(0, new CompositionPath(BuildPathGeometry()), linear);
+
+            // A property set that other objects reference through expressions. This is
+            // how the translator exposes theming properties.
+            var theme = c.CreatePropertySet();
+            theme.InsertScalar("Scalar", 1);
+            theme.InsertVector2("Vector2", new Vector2(1, 2));
+            theme.InsertVector3("Vector3", new Vector3(1, 2, 3));
+            theme.InsertVector4("Vector4", new Vector4(1, 2, 3, 4));
+            theme.InsertColor("Color", Wui.Color.FromArgb(255, 7, 8, 9));
+
+            var expressionAnimation = c.CreateExpressionAnimation(Expr.Expression.Scalar("_.Scalar"));
+            expressionAnimation.SetReferenceParameter("_", theme);
+
+            // A custom controller, which is the only kind the format has to carry, since
+            // a default one is recreated on the other side.
+            var controller = c.CreateAnimationController();
+            controller.Pause();
+
+            // Shapes.
+            var shapeVisual = c.CreateShapeVisual();
+            shapeVisual.Size = new Vector2(100, 100);
+            shapeVisual.ViewBox = c.CreateViewBox();
+            shapeVisual.ViewBox.Size = new Vector2(50, 50);
+
+            var containerShape = c.CreateContainerShape();
+            containerShape.CenterPoint = new Vector2(1, 2);
+            containerShape.Offset = new Vector2(3, 4);
+            containerShape.RotationAngleInDegrees = 90;
+            containerShape.Scale = new Vector2(2, 2);
+            containerShape.TransformMatrix = Matrix3x2.Identity;
+            shapeVisual.Shapes.Add(containerShape);
+
+            // Every geometry type, each on its own sprite shape so that the sprite shape
+            // properties are exercised as well.
+            var ellipse = c.CreateEllipseGeometry();
+            ellipse.Center = new Vector2(1, 2);
+            ellipse.Radius = new Vector2(3, 4);
+            ellipse.TrimStart = 0.1f;
+            ellipse.TrimEnd = 0.9f;
+            ellipse.TrimOffset = 0.05f;
+
+            var rectangle = c.CreateRectangleGeometry();
+            rectangle.Offset = new Vector2(1, 2);
+            rectangle.Size = new Vector2(3, 4);
+
+            var roundedRectangle = c.CreateRoundedRectangleGeometry();
+            roundedRectangle.Offset = new Vector2(1, 2);
+            roundedRectangle.Size = new Vector2(3, 4);
+            roundedRectangle.CornerRadius = new Vector2(5, 6);
+
+            var pathGeometry = c.CreatePathGeometry(new CompositionPath(BuildPathGeometry()));
+
+            var colorBrush = c.CreateColorBrush(Wui.Color.FromArgb(255, 10, 20, 30));
+
+            var linearGradient = c.CreateLinearGradientBrush();
+            linearGradient.StartPoint = new Vector2(0, 0);
+            linearGradient.EndPoint = new Vector2(1, 1);
+            linearGradient.AnchorPoint = new Vector2(0.5f, 0.5f);
+            linearGradient.CenterPoint = new Vector2(0.5f, 0.5f);
+            linearGradient.ExtendMode = CompositionGradientExtendMode.Mirror;
+            linearGradient.InterpolationSpace = CompositionColorSpace.HslLinear;
+            linearGradient.ColorStops.Add(c.CreateColorGradientStop(0, Wui.Color.FromArgb(255, 0, 0, 0)));
+            linearGradient.ColorStops.Add(c.CreateColorGradientStop(1, Wui.Color.FromArgb(255, 255, 255, 255)));
+
+            var radialGradient = c.CreateRadialGradientBrush();
+            radialGradient.EllipseCenter = new Vector2(0.5f, 0.5f);
+            radialGradient.EllipseRadius = new Vector2(0.5f, 0.5f);
+            radialGradient.GradientOriginOffset = new Vector2(0.1f, 0.1f);
+            radialGradient.ColorStops.Add(c.CreateColorGradientStop(0, Wui.Color.FromArgb(255, 1, 2, 3)));
+
+            var strokedShape = AddSpriteShape(c, containerShape, ellipse, colorBrush, linearGradient);
+            strokedShape.StrokeDashArray.Add(1);
+            strokedShape.StrokeDashArray.Add(2);
+            strokedShape.StrokeDashOffset = 3;
+            strokedShape.StrokeDashCap = CompositionStrokeCap.Round;
+            strokedShape.StrokeStartCap = CompositionStrokeCap.Square;
+            strokedShape.StrokeEndCap = CompositionStrokeCap.Triangle;
+            strokedShape.StrokeLineJoin = CompositionStrokeLineJoin.Bevel;
+            strokedShape.StrokeMiterLimit = 4;
+            strokedShape.StrokeThickness = 2;
+            strokedShape.IsStrokeNonScaling = true;
+
+            AddSpriteShape(c, containerShape, rectangle, colorBrush, radialGradient);
+            AddSpriteShape(c, containerShape, roundedRectangle, colorBrush, null);
+            AddSpriteShape(c, containerShape, pathGeometry, colorBrush, null);
+
+            // A geometric clip, which is the other consumer of a geometry.
+            var geometricClip = c.CreateGeometricClip();
+            geometricClip.Geometry = pathGeometry;
+            shapeVisual.Clip = geometricClip;
+
+            // A layer visual with a drop shadow.
+            var layerVisual = c.CreateLayerVisual();
+            layerVisual.Size = new Vector2(100, 100);
+
+            var shadow = c.CreateDropShadow();
+            shadow.BlurRadius = 5;
+            shadow.Color = Wui.Color.FromArgb(128, 0, 0, 0);
+            shadow.Offset = new Vector3(1, 2, 0);
+            shadow.Opacity = 0.5f;
+            shadow.Mask = colorBrush;
+            shadow.SourcePolicy = CompositionDropShadowSourcePolicy.InheritFromVisualContent;
+            layerVisual.Shadow = shadow;
+            layerVisual.Children.Add(shapeVisual);
+
+            // A visual surface, a surface brush over it, and a mask brush combining two
+            // brushes. These are how the translator implements masking.
+            var visualSurface = c.CreateVisualSurface();
+            visualSurface.SourceVisual = shapeVisual;
+            visualSurface.SourceSize = new Vector2(100, 100);
+            visualSurface.SourceOffset = new Vector2(1, 2);
+
+            var surfaceBrush = c.CreateSurfaceBrush(visualSurface);
+
+            // A surface brush over a loaded image, which is the other kind of surface.
+            var imageBrush = c.CreateSurfaceBrush(
+                LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///image.png")));
+
+            var streamBrush = c.CreateSurfaceBrush(
+                LoadedImageSurface.StartLoadFromStream(new byte[] { 1, 2, 3, 4 }));
+
+            var maskBrush = c.CreateMaskBrush();
+            maskBrush.Source = surfaceBrush;
+            maskBrush.Mask = imageBrush;
+
+            // Effects. Both effect types, reached through an effect factory and an
+            // effect brush.
+            var compositeEffect = new CompositeEffect(
+                CanvasComposite.DestinationIn,
+                new List<CompositionEffectSourceParameter>
+                {
+                    new CompositionEffectSourceParameter("source"),
+                    new CompositionEffectSourceParameter("mask"),
+                });
+
+            var compositeBrush = c.CreateEffectFactory(compositeEffect).CreateBrush();
+            compositeBrush.SetSourceParameter("source", surfaceBrush);
+            compositeBrush.SetSourceParameter("mask", streamBrush);
+
+            var blurEffect = new GaussianBlurEffect(3, new CompositionEffectSourceParameter("source"));
+            var blurBrush = c.CreateEffectFactory(blurEffect).CreateBrush();
+            blurBrush.SetSourceParameter("source", maskBrush);
+
+            var effectVisual = c.CreateSpriteVisual();
+            effectVisual.Size = new Vector2(100, 100);
+            effectVisual.Brush = blurBrush;
+
+            var compositeVisual = c.CreateSpriteVisual();
+            compositeVisual.Size = new Vector2(100, 100);
+            compositeVisual.Brush = compositeBrush;
+
+            root.Children.Add(layerVisual);
+            root.Children.Add(effectVisual);
+            root.Children.Add(compositeVisual);
+
+            // Bind an animation of every kind to something, so that the animators and
+            // their controllers are all reachable.
+            root.StartAnimation("Opacity", scalarAnimation, controller);
+            root.StartAnimation("IsVisible", booleanAnimation);
+            root.StartAnimation("Offset", vector3Animation);
+            root.StartAnimation("Size", vector2Animation);
+            root.StartAnimation("RotationAngleInDegrees", expressionAnimation);
+            colorBrush.StartAnimation("Color", colorAnimation);
+            pathGeometry.StartAnimation("Path", pathAnimation);
+            linearGradient.ColorStops[0].StartAnimation("Offset", scalarAnimation);
+            radialGradient.StartAnimation("EllipseCenter", vector2Animation);
+            strokedShape.StartAnimation("StrokeThickness", scalarAnimation);
+            theme.StartAnimation("Vector4", vector4Animation);
+
+            return root;
+        }
+
+        static CompositionSpriteShape AddSpriteShape(
+            Compositor compositor,
+            CompositionContainerShape parent,
+            CompositionGeometry geometry,
+            CompositionBrush fill,
+            CompositionBrush? stroke)
+        {
+            var shape = compositor.CreateSpriteShape();
+            shape.Geometry = geometry;
+            shape.FillBrush = fill;
+            shape.StrokeBrush = stroke;
+            parent.Shapes.Add(shape);
+            return shape;
+        }
+
+        // Builds a geometry that contains every CanvasGeometry shape and every path
+        // command, so that the flattened path encoding is fully exercised.
+        static CanvasGeometry BuildPathGeometry()
+        {
+            using var builder = new CanvasPathBuilder(null);
+            builder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.Winding);
+            builder.BeginFigure(new Vector2(0, 0));
+            builder.AddLine(new Vector2(1, 0));
+            builder.AddCubicBezier(new Vector2(2, 0), new Vector2(3, 1), new Vector2(4, 1));
+            builder.EndFigure(CanvasFigureLoop.Closed);
+            builder.BeginFigure(new Vector2(5, 5));
+            builder.AddLine(new Vector2(6, 6));
+            builder.EndFigure(CanvasFigureLoop.Open);
+
+            var path = CanvasGeometry.CreatePath(builder);
+            var ellipse = CanvasGeometry.CreateEllipse(null, 1, 2, 3, 4);
+            var roundedRectangle = CanvasGeometry.CreateRoundedRectangle(null, 1, 2, 3, 4, 5, 6);
+            var transformed = ellipse.Transform(Matrix3x2.CreateScale(2));
+            var combination = path.CombineWith(
+                roundedRectangle,
+                Matrix3x2.Identity,
+                CanvasGeometryCombine.Union);
+
+            return CanvasGeometry.CreateGroup(
+                null,
+                new[] { combination, transformed },
+                CanvasFilledRegionDetermination.Alternate);
+        }
+
+        // Walks every CompositionObject reachable from a root. This deliberately does not
+        // reuse the serializer's walker, so that a node the serializer cannot see is
+        // still counted as uncovered.
+        static IEnumerable<CompositionObject> Collect(Visual root)
+        {
+            var seen = new HashSet<CompositionObject>();
+            var result = new List<CompositionObject>();
+
+            void Add(CompositionObject? o)
+            {
+                if (o is null || !seen.Add(o))
+                {
+                    return;
+                }
+
+                result.Add(o);
+
+                Add(o.Properties);
+
+                foreach (var animator in o.Animators)
+                {
+                    Add(animator.Animation);
+                    Add(animator.Controller);
+                }
+
+                if (o is CompositionAnimation animation)
+                {
+                    foreach (var parameter in animation.ReferenceParameters)
+                    {
+                        Add(parameter.Value);
+                    }
+
+                    if (o is KeyFrameAnimation_ keyFrameAnimation)
+                    {
+                        foreach (var easing in keyFrameAnimation.KeyFrames.Select(f => f.Easing))
+                        {
+                            Add(easing);
+                        }
+                    }
+                }
+
+                switch (o)
+                {
+                    case SpriteVisual sprite:
+                        Add(sprite.Brush);
+                        Add(sprite.Clip);
+                        foreach (var child in sprite.Children)
+                        {
+                            Add(child);
+                        }
+
+                        break;
+                    case ContainerVisual container:
+                        foreach (var child in container.Children)
+                        {
+                            Add(child);
+                        }
+
+                        Add(container.Clip);
+
+                        if (container is LayerVisual layer)
+                        {
+                            Add(layer.Shadow);
+                        }
+                        else if (container is ShapeVisual shapeVisual)
+                        {
+                            Add(shapeVisual.ViewBox);
+                            foreach (var shape in shapeVisual.Shapes)
+                            {
+                                Add(shape);
+                            }
+                        }
+
+                        break;
+                    case CompositionContainerShape containerShape:
+                        foreach (var shape in containerShape.Shapes)
+                        {
+                            Add(shape);
+                        }
+
+                        break;
+                    case CompositionSpriteShape spriteShape:
+                        Add(spriteShape.Geometry);
+                        Add(spriteShape.FillBrush);
+                        Add(spriteShape.StrokeBrush);
+                        break;
+                    case CompositionGeometricClip geometricClip:
+                        Add(geometricClip.Geometry);
+                        break;
+                    case CompositionGradientBrush gradient:
+                        foreach (var stop in gradient.ColorStops)
+                        {
+                            Add(stop);
+                        }
+
+                        break;
+                    case CompositionMaskBrush mask:
+                        Add(mask.Source);
+                        Add(mask.Mask);
+                        break;
+                    case CompositionSurfaceBrush surfaceBrush:
+                        Add(surfaceBrush.Surface as CompositionObject);
+                        break;
+                    case CompositionEffectBrush effectBrush:
+                        Add(effectBrush.GetEffectFactory());
+                        foreach (var source in effectBrush.GetEffectFactory().Effect.Sources)
+                        {
+                            Add(effectBrush.GetSourceParameter(source.Name));
+                        }
+
+                        break;
+                    case CompositionVisualSurface visualSurface:
+                        Add(visualSurface.SourceVisual);
+                        break;
+                    case DropShadow dropShadow:
+                        Add(dropShadow.Mask);
+                        break;
+                }
+            }
+
+            Add(root);
+            return result;
+        }
+    }
+}

From bf8e9db75e6ebe34360af4247f85417e32b21003 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 18:46:58 +0000
Subject: [PATCH 10/39] Add native C++/WinRT runtime interpreter for serialized
 compositions

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 .../Generated/lottie_comp_generated.h         | 4301 +++++++++++++++++
 dlls/LottieRuntime/LottieRuntime.cpp          | 2014 ++++++++
 dlls/LottieRuntime/LottieRuntime.h            |   54 +
 dlls/LottieRuntime/LottieRuntime.vcxproj      |   81 +
 dlls/LottieRuntime/README.md                  |  135 +
 5 files changed, 6585 insertions(+)
 create mode 100644 dlls/LottieRuntime/Generated/lottie_comp_generated.h
 create mode 100644 dlls/LottieRuntime/LottieRuntime.cpp
 create mode 100644 dlls/LottieRuntime/LottieRuntime.h
 create mode 100644 dlls/LottieRuntime/LottieRuntime.vcxproj
 create mode 100644 dlls/LottieRuntime/README.md

diff --git a/dlls/LottieRuntime/Generated/lottie_comp_generated.h b/dlls/LottieRuntime/Generated/lottie_comp_generated.h
new file mode 100644
index 00000000..b2eba1b4
--- /dev/null
+++ b/dlls/LottieRuntime/Generated/lottie_comp_generated.h
@@ -0,0 +1,4301 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_LOTTIECOMP_COMMUNITYTOOLKIT_WINUI_LOTTIE_COMPDATAFLATBUFFER_SCHEMA_H_
+#define FLATBUFFERS_GENERATED_LOTTIECOMP_COMMUNITYTOOLKIT_WINUI_LOTTIE_COMPDATAFLATBUFFER_SCHEMA_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+              FLATBUFFERS_VERSION_MINOR == 2 &&
+              FLATBUFFERS_VERSION_REVISION == 10,
+             "Non-compatible flatbuffers version included");
+
+namespace CommunityToolkit {
+namespace WinUI {
+namespace Lottie {
+namespace CompDataFlatbuffer {
+namespace Schema {
+
+struct Vec2;
+
+struct Vec3;
+
+struct Vec4;
+
+struct Mat3x2;
+
+struct Mat4x4;
+
+struct Color;
+
+struct Animator;
+struct AnimatorBuilder;
+
+struct CompObj;
+struct CompObjBuilder;
+
+struct PropertyValue;
+struct PropertyValueBuilder;
+
+struct ReferenceParameter;
+struct ReferenceParameterBuilder;
+
+struct SourceParameter;
+struct SourceParameterBuilder;
+
+struct KeyFrame;
+struct KeyFrameBuilder;
+
+struct Visual;
+struct VisualBuilder;
+
+struct Shape;
+struct ShapeBuilder;
+
+struct Geometry;
+struct GeometryBuilder;
+
+struct Brush;
+struct BrushBuilder;
+
+struct GradientStop;
+struct GradientStopBuilder;
+
+struct ViewBox;
+struct ViewBoxBuilder;
+
+struct Clip;
+struct ClipBuilder;
+
+struct Shadow;
+struct ShadowBuilder;
+
+struct Surface;
+struct SurfaceBuilder;
+
+struct Effect;
+struct EffectBuilder;
+
+struct Easing;
+struct EasingBuilder;
+
+struct Animation;
+struct AnimationBuilder;
+
+struct PropertySet;
+struct PropertySetBuilder;
+
+struct Controller;
+struct ControllerBuilder;
+
+struct PropertyBinding;
+struct PropertyBindingBuilder;
+
+struct Marker;
+struct MarkerBuilder;
+
+struct Metadata;
+struct MetadataBuilder;
+
+struct LottieComposition;
+struct LottieCompositionBuilder;
+
+struct CanvasGeometry;
+struct CanvasGeometryBuilder;
+
+enum class ObjectCategory : uint8_t {
+  Visual = 0,
+  Shape = 1,
+  Geometry = 2,
+  Brush = 3,
+  Animation = 4,
+  Easing = 5,
+  PropertySet = 6,
+  Surface = 7,
+  Clip = 8,
+  Controller = 9,
+  Shadow = 10,
+  Effect = 11,
+  GradientStop = 12,
+  ViewBox = 13,
+  MIN = Visual,
+  MAX = ViewBox
+};
+
+inline const ObjectCategory (&EnumValuesObjectCategory())[14] {
+  static const ObjectCategory values[] = {
+    ObjectCategory::Visual,
+    ObjectCategory::Shape,
+    ObjectCategory::Geometry,
+    ObjectCategory::Brush,
+    ObjectCategory::Animation,
+    ObjectCategory::Easing,
+    ObjectCategory::PropertySet,
+    ObjectCategory::Surface,
+    ObjectCategory::Clip,
+    ObjectCategory::Controller,
+    ObjectCategory::Shadow,
+    ObjectCategory::Effect,
+    ObjectCategory::GradientStop,
+    ObjectCategory::ViewBox
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesObjectCategory() {
+  static const char * const names[15] = {
+    "Visual",
+    "Shape",
+    "Geometry",
+    "Brush",
+    "Animation",
+    "Easing",
+    "PropertySet",
+    "Surface",
+    "Clip",
+    "Controller",
+    "Shadow",
+    "Effect",
+    "GradientStop",
+    "ViewBox",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameObjectCategory(ObjectCategory e) {
+  if (::flatbuffers::IsOutRange(e, ObjectCategory::Visual, ObjectCategory::ViewBox)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesObjectCategory()[index];
+}
+
+enum class VisualKind : uint8_t {
+  Container = 0,
+  Sprite = 1,
+  Shape = 2,
+  Layer = 3,
+  MIN = Container,
+  MAX = Layer
+};
+
+inline const VisualKind (&EnumValuesVisualKind())[4] {
+  static const VisualKind values[] = {
+    VisualKind::Container,
+    VisualKind::Sprite,
+    VisualKind::Shape,
+    VisualKind::Layer
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesVisualKind() {
+  static const char * const names[5] = {
+    "Container",
+    "Sprite",
+    "Shape",
+    "Layer",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameVisualKind(VisualKind e) {
+  if (::flatbuffers::IsOutRange(e, VisualKind::Container, VisualKind::Layer)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesVisualKind()[index];
+}
+
+enum class ShapeKind : uint8_t {
+  Container = 0,
+  Sprite = 1,
+  MIN = Container,
+  MAX = Sprite
+};
+
+inline const ShapeKind (&EnumValuesShapeKind())[2] {
+  static const ShapeKind values[] = {
+    ShapeKind::Container,
+    ShapeKind::Sprite
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesShapeKind() {
+  static const char * const names[3] = {
+    "Container",
+    "Sprite",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameShapeKind(ShapeKind e) {
+  if (::flatbuffers::IsOutRange(e, ShapeKind::Container, ShapeKind::Sprite)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesShapeKind()[index];
+}
+
+enum class GeometryKind : uint8_t {
+  Path = 0,
+  Rectangle = 1,
+  RoundedRectangle = 2,
+  Ellipse = 3,
+  MIN = Path,
+  MAX = Ellipse
+};
+
+inline const GeometryKind (&EnumValuesGeometryKind())[4] {
+  static const GeometryKind values[] = {
+    GeometryKind::Path,
+    GeometryKind::Rectangle,
+    GeometryKind::RoundedRectangle,
+    GeometryKind::Ellipse
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesGeometryKind() {
+  static const char * const names[5] = {
+    "Path",
+    "Rectangle",
+    "RoundedRectangle",
+    "Ellipse",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameGeometryKind(GeometryKind e) {
+  if (::flatbuffers::IsOutRange(e, GeometryKind::Path, GeometryKind::Ellipse)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesGeometryKind()[index];
+}
+
+enum class BrushKind : uint8_t {
+  Color = 0,
+  LinearGradient = 1,
+  RadialGradient = 2,
+  Surface = 3,
+  Mask = 4,
+  Effect = 5,
+  MIN = Color,
+  MAX = Effect
+};
+
+inline const BrushKind (&EnumValuesBrushKind())[6] {
+  static const BrushKind values[] = {
+    BrushKind::Color,
+    BrushKind::LinearGradient,
+    BrushKind::RadialGradient,
+    BrushKind::Surface,
+    BrushKind::Mask,
+    BrushKind::Effect
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesBrushKind() {
+  static const char * const names[7] = {
+    "Color",
+    "LinearGradient",
+    "RadialGradient",
+    "Surface",
+    "Mask",
+    "Effect",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameBrushKind(BrushKind e) {
+  if (::flatbuffers::IsOutRange(e, BrushKind::Color, BrushKind::Effect)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesBrushKind()[index];
+}
+
+enum class ClipKind : uint8_t {
+  Inset = 0,
+  Geometric = 1,
+  MIN = Inset,
+  MAX = Geometric
+};
+
+inline const ClipKind (&EnumValuesClipKind())[2] {
+  static const ClipKind values[] = {
+    ClipKind::Inset,
+    ClipKind::Geometric
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesClipKind() {
+  static const char * const names[3] = {
+    "Inset",
+    "Geometric",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameClipKind(ClipKind e) {
+  if (::flatbuffers::IsOutRange(e, ClipKind::Inset, ClipKind::Geometric)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesClipKind()[index];
+}
+
+enum class ShadowKind : uint8_t {
+  Drop = 0,
+  MIN = Drop,
+  MAX = Drop
+};
+
+inline const ShadowKind (&EnumValuesShadowKind())[1] {
+  static const ShadowKind values[] = {
+    ShadowKind::Drop
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesShadowKind() {
+  static const char * const names[2] = {
+    "Drop",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameShadowKind(ShadowKind e) {
+  if (::flatbuffers::IsOutRange(e, ShadowKind::Drop, ShadowKind::Drop)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesShadowKind()[index];
+}
+
+enum class SurfaceKind : uint8_t {
+  VisualSurface = 0,
+  LoadedImageFromUri = 1,
+  LoadedImageFromStream = 2,
+  MIN = VisualSurface,
+  MAX = LoadedImageFromStream
+};
+
+inline const SurfaceKind (&EnumValuesSurfaceKind())[3] {
+  static const SurfaceKind values[] = {
+    SurfaceKind::VisualSurface,
+    SurfaceKind::LoadedImageFromUri,
+    SurfaceKind::LoadedImageFromStream
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesSurfaceKind() {
+  static const char * const names[4] = {
+    "VisualSurface",
+    "LoadedImageFromUri",
+    "LoadedImageFromStream",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameSurfaceKind(SurfaceKind e) {
+  if (::flatbuffers::IsOutRange(e, SurfaceKind::VisualSurface, SurfaceKind::LoadedImageFromStream)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesSurfaceKind()[index];
+}
+
+enum class EffectKind : uint8_t {
+  Composite = 0,
+  GaussianBlur = 1,
+  MIN = Composite,
+  MAX = GaussianBlur
+};
+
+inline const EffectKind (&EnumValuesEffectKind())[2] {
+  static const EffectKind values[] = {
+    EffectKind::Composite,
+    EffectKind::GaussianBlur
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesEffectKind() {
+  static const char * const names[3] = {
+    "Composite",
+    "GaussianBlur",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameEffectKind(EffectKind e) {
+  if (::flatbuffers::IsOutRange(e, EffectKind::Composite, EffectKind::GaussianBlur)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesEffectKind()[index];
+}
+
+enum class EasingKind : uint8_t {
+  Linear = 0,
+  CubicBezier = 1,
+  Step = 2,
+  MIN = Linear,
+  MAX = Step
+};
+
+inline const EasingKind (&EnumValuesEasingKind())[3] {
+  static const EasingKind values[] = {
+    EasingKind::Linear,
+    EasingKind::CubicBezier,
+    EasingKind::Step
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesEasingKind() {
+  static const char * const names[4] = {
+    "Linear",
+    "CubicBezier",
+    "Step",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameEasingKind(EasingKind e) {
+  if (::flatbuffers::IsOutRange(e, EasingKind::Linear, EasingKind::Step)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesEasingKind()[index];
+}
+
+enum class AnimationKind : uint8_t {
+  Scalar = 0,
+  Vector2 = 1,
+  Vector3 = 2,
+  Vector4 = 3,
+  Color = 4,
+  Boolean = 5,
+  Path = 6,
+  Expression = 7,
+  MIN = Scalar,
+  MAX = Expression
+};
+
+inline const AnimationKind (&EnumValuesAnimationKind())[8] {
+  static const AnimationKind values[] = {
+    AnimationKind::Scalar,
+    AnimationKind::Vector2,
+    AnimationKind::Vector3,
+    AnimationKind::Vector4,
+    AnimationKind::Color,
+    AnimationKind::Boolean,
+    AnimationKind::Path,
+    AnimationKind::Expression
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesAnimationKind() {
+  static const char * const names[9] = {
+    "Scalar",
+    "Vector2",
+    "Vector3",
+    "Vector4",
+    "Color",
+    "Boolean",
+    "Path",
+    "Expression",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameAnimationKind(AnimationKind e) {
+  if (::flatbuffers::IsOutRange(e, AnimationKind::Scalar, AnimationKind::Expression)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesAnimationKind()[index];
+}
+
+enum class KeyFrameKind : uint8_t {
+  Value = 0,
+  Expression = 1,
+  MIN = Value,
+  MAX = Expression
+};
+
+inline const KeyFrameKind (&EnumValuesKeyFrameKind())[2] {
+  static const KeyFrameKind values[] = {
+    KeyFrameKind::Value,
+    KeyFrameKind::Expression
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesKeyFrameKind() {
+  static const char * const names[3] = {
+    "Value",
+    "Expression",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameKeyFrameKind(KeyFrameKind e) {
+  if (::flatbuffers::IsOutRange(e, KeyFrameKind::Value, KeyFrameKind::Expression)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesKeyFrameKind()[index];
+}
+
+enum class CanvasGeometryKind : uint8_t {
+  Combination = 0,
+  Ellipse = 1,
+  Group = 2,
+  Path = 3,
+  RoundedRectangle = 4,
+  TransformedGeometry = 5,
+  MIN = Combination,
+  MAX = TransformedGeometry
+};
+
+inline const CanvasGeometryKind (&EnumValuesCanvasGeometryKind())[6] {
+  static const CanvasGeometryKind values[] = {
+    CanvasGeometryKind::Combination,
+    CanvasGeometryKind::Ellipse,
+    CanvasGeometryKind::Group,
+    CanvasGeometryKind::Path,
+    CanvasGeometryKind::RoundedRectangle,
+    CanvasGeometryKind::TransformedGeometry
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesCanvasGeometryKind() {
+  static const char * const names[7] = {
+    "Combination",
+    "Ellipse",
+    "Group",
+    "Path",
+    "RoundedRectangle",
+    "TransformedGeometry",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameCanvasGeometryKind(CanvasGeometryKind e) {
+  if (::flatbuffers::IsOutRange(e, CanvasGeometryKind::Combination, CanvasGeometryKind::TransformedGeometry)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesCanvasGeometryKind()[index];
+}
+
+enum class PathOp : uint8_t {
+  BeginFigure = 0,
+  EndFigure = 1,
+  AddLine = 2,
+  AddCubicBezier = 3,
+  MIN = BeginFigure,
+  MAX = AddCubicBezier
+};
+
+inline const PathOp (&EnumValuesPathOp())[4] {
+  static const PathOp values[] = {
+    PathOp::BeginFigure,
+    PathOp::EndFigure,
+    PathOp::AddLine,
+    PathOp::AddCubicBezier
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesPathOp() {
+  static const char * const names[5] = {
+    "BeginFigure",
+    "EndFigure",
+    "AddLine",
+    "AddCubicBezier",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNamePathOp(PathOp e) {
+  if (::flatbuffers::IsOutRange(e, PathOp::BeginFigure, PathOp::AddCubicBezier)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesPathOp()[index];
+}
+
+enum class PropertyValueType : uint8_t {
+  None = 0,
+  Color = 1,
+  Scalar = 2,
+  Vector2 = 3,
+  Vector3 = 4,
+  Vector4 = 5,
+  MIN = None,
+  MAX = Vector4
+};
+
+inline const PropertyValueType (&EnumValuesPropertyValueType())[6] {
+  static const PropertyValueType values[] = {
+    PropertyValueType::None,
+    PropertyValueType::Color,
+    PropertyValueType::Scalar,
+    PropertyValueType::Vector2,
+    PropertyValueType::Vector3,
+    PropertyValueType::Vector4
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesPropertyValueType() {
+  static const char * const names[7] = {
+    "None",
+    "Color",
+    "Scalar",
+    "Vector2",
+    "Vector3",
+    "Vector4",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNamePropertyValueType(PropertyValueType e) {
+  if (::flatbuffers::IsOutRange(e, PropertyValueType::None, PropertyValueType::Vector4)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesPropertyValueType()[index];
+}
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec2 FLATBUFFERS_FINAL_CLASS {
+ private:
+  float x_;
+  float y_;
+
+ public:
+  Vec2()
+      : x_(0),
+        y_(0) {
+  }
+  Vec2(float _x, float _y)
+      : x_(::flatbuffers::EndianScalar(_x)),
+        y_(::flatbuffers::EndianScalar(_y)) {
+  }
+  float x() const {
+    return ::flatbuffers::EndianScalar(x_);
+  }
+  float y() const {
+    return ::flatbuffers::EndianScalar(y_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Vec2, 8);
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS {
+ private:
+  float x_;
+  float y_;
+  float z_;
+
+ public:
+  Vec3()
+      : x_(0),
+        y_(0),
+        z_(0) {
+  }
+  Vec3(float _x, float _y, float _z)
+      : x_(::flatbuffers::EndianScalar(_x)),
+        y_(::flatbuffers::EndianScalar(_y)),
+        z_(::flatbuffers::EndianScalar(_z)) {
+  }
+  float x() const {
+    return ::flatbuffers::EndianScalar(x_);
+  }
+  float y() const {
+    return ::flatbuffers::EndianScalar(y_);
+  }
+  float z() const {
+    return ::flatbuffers::EndianScalar(z_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Vec3, 12);
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec4 FLATBUFFERS_FINAL_CLASS {
+ private:
+  float x_;
+  float y_;
+  float z_;
+  float w_;
+
+ public:
+  Vec4()
+      : x_(0),
+        y_(0),
+        z_(0),
+        w_(0) {
+  }
+  Vec4(float _x, float _y, float _z, float _w)
+      : x_(::flatbuffers::EndianScalar(_x)),
+        y_(::flatbuffers::EndianScalar(_y)),
+        z_(::flatbuffers::EndianScalar(_z)),
+        w_(::flatbuffers::EndianScalar(_w)) {
+  }
+  float x() const {
+    return ::flatbuffers::EndianScalar(x_);
+  }
+  float y() const {
+    return ::flatbuffers::EndianScalar(y_);
+  }
+  float z() const {
+    return ::flatbuffers::EndianScalar(z_);
+  }
+  float w() const {
+    return ::flatbuffers::EndianScalar(w_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Vec4, 16);
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Mat3x2 FLATBUFFERS_FINAL_CLASS {
+ private:
+  float m11_;
+  float m12_;
+  float m21_;
+  float m22_;
+  float m31_;
+  float m32_;
+
+ public:
+  Mat3x2()
+      : m11_(0),
+        m12_(0),
+        m21_(0),
+        m22_(0),
+        m31_(0),
+        m32_(0) {
+  }
+  Mat3x2(float _m11, float _m12, float _m21, float _m22, float _m31, float _m32)
+      : m11_(::flatbuffers::EndianScalar(_m11)),
+        m12_(::flatbuffers::EndianScalar(_m12)),
+        m21_(::flatbuffers::EndianScalar(_m21)),
+        m22_(::flatbuffers::EndianScalar(_m22)),
+        m31_(::flatbuffers::EndianScalar(_m31)),
+        m32_(::flatbuffers::EndianScalar(_m32)) {
+  }
+  float m11() const {
+    return ::flatbuffers::EndianScalar(m11_);
+  }
+  float m12() const {
+    return ::flatbuffers::EndianScalar(m12_);
+  }
+  float m21() const {
+    return ::flatbuffers::EndianScalar(m21_);
+  }
+  float m22() const {
+    return ::flatbuffers::EndianScalar(m22_);
+  }
+  float m31() const {
+    return ::flatbuffers::EndianScalar(m31_);
+  }
+  float m32() const {
+    return ::flatbuffers::EndianScalar(m32_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Mat3x2, 24);
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Mat4x4 FLATBUFFERS_FINAL_CLASS {
+ private:
+  float m11_;
+  float m12_;
+  float m13_;
+  float m14_;
+  float m21_;
+  float m22_;
+  float m23_;
+  float m24_;
+  float m31_;
+  float m32_;
+  float m33_;
+  float m34_;
+  float m41_;
+  float m42_;
+  float m43_;
+  float m44_;
+
+ public:
+  Mat4x4()
+      : m11_(0),
+        m12_(0),
+        m13_(0),
+        m14_(0),
+        m21_(0),
+        m22_(0),
+        m23_(0),
+        m24_(0),
+        m31_(0),
+        m32_(0),
+        m33_(0),
+        m34_(0),
+        m41_(0),
+        m42_(0),
+        m43_(0),
+        m44_(0) {
+  }
+  Mat4x4(float _m11, float _m12, float _m13, float _m14, float _m21, float _m22, float _m23, float _m24, float _m31, float _m32, float _m33, float _m34, float _m41, float _m42, float _m43, float _m44)
+      : m11_(::flatbuffers::EndianScalar(_m11)),
+        m12_(::flatbuffers::EndianScalar(_m12)),
+        m13_(::flatbuffers::EndianScalar(_m13)),
+        m14_(::flatbuffers::EndianScalar(_m14)),
+        m21_(::flatbuffers::EndianScalar(_m21)),
+        m22_(::flatbuffers::EndianScalar(_m22)),
+        m23_(::flatbuffers::EndianScalar(_m23)),
+        m24_(::flatbuffers::EndianScalar(_m24)),
+        m31_(::flatbuffers::EndianScalar(_m31)),
+        m32_(::flatbuffers::EndianScalar(_m32)),
+        m33_(::flatbuffers::EndianScalar(_m33)),
+        m34_(::flatbuffers::EndianScalar(_m34)),
+        m41_(::flatbuffers::EndianScalar(_m41)),
+        m42_(::flatbuffers::EndianScalar(_m42)),
+        m43_(::flatbuffers::EndianScalar(_m43)),
+        m44_(::flatbuffers::EndianScalar(_m44)) {
+  }
+  float m11() const {
+    return ::flatbuffers::EndianScalar(m11_);
+  }
+  float m12() const {
+    return ::flatbuffers::EndianScalar(m12_);
+  }
+  float m13() const {
+    return ::flatbuffers::EndianScalar(m13_);
+  }
+  float m14() const {
+    return ::flatbuffers::EndianScalar(m14_);
+  }
+  float m21() const {
+    return ::flatbuffers::EndianScalar(m21_);
+  }
+  float m22() const {
+    return ::flatbuffers::EndianScalar(m22_);
+  }
+  float m23() const {
+    return ::flatbuffers::EndianScalar(m23_);
+  }
+  float m24() const {
+    return ::flatbuffers::EndianScalar(m24_);
+  }
+  float m31() const {
+    return ::flatbuffers::EndianScalar(m31_);
+  }
+  float m32() const {
+    return ::flatbuffers::EndianScalar(m32_);
+  }
+  float m33() const {
+    return ::flatbuffers::EndianScalar(m33_);
+  }
+  float m34() const {
+    return ::flatbuffers::EndianScalar(m34_);
+  }
+  float m41() const {
+    return ::flatbuffers::EndianScalar(m41_);
+  }
+  float m42() const {
+    return ::flatbuffers::EndianScalar(m42_);
+  }
+  float m43() const {
+    return ::flatbuffers::EndianScalar(m43_);
+  }
+  float m44() const {
+    return ::flatbuffers::EndianScalar(m44_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Mat4x4, 64);
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Color FLATBUFFERS_FINAL_CLASS {
+ private:
+  uint8_t a_;
+  uint8_t r_;
+  uint8_t g_;
+  uint8_t b_;
+
+ public:
+  Color()
+      : a_(0),
+        r_(0),
+        g_(0),
+        b_(0) {
+  }
+  Color(uint8_t _a, uint8_t _r, uint8_t _g, uint8_t _b)
+      : a_(::flatbuffers::EndianScalar(_a)),
+        r_(::flatbuffers::EndianScalar(_r)),
+        g_(::flatbuffers::EndianScalar(_g)),
+        b_(::flatbuffers::EndianScalar(_b)) {
+  }
+  uint8_t a() const {
+    return ::flatbuffers::EndianScalar(a_);
+  }
+  uint8_t r() const {
+    return ::flatbuffers::EndianScalar(r_);
+  }
+  uint8_t g() const {
+    return ::flatbuffers::EndianScalar(g_);
+  }
+  uint8_t b() const {
+    return ::flatbuffers::EndianScalar(b_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Color, 4);
+
+struct Animator FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef AnimatorBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_PROPERTY = 4,
+    VT_ANIMATION = 6,
+    VT_CONTROLLER = 8
+  };
+  uint32_t property() const {
+    return GetField<uint32_t>(VT_PROPERTY, 0);
+  }
+  uint32_t animation() const {
+    return GetField<uint32_t>(VT_ANIMATION, 0);
+  }
+  uint32_t controller() const {
+    return GetField<uint32_t>(VT_CONTROLLER, 4294967295);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_PROPERTY, 4) &&
+           VerifyField<uint32_t>(verifier, VT_ANIMATION, 4) &&
+           VerifyField<uint32_t>(verifier, VT_CONTROLLER, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct AnimatorBuilder {
+  typedef Animator Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_property(uint32_t property) {
+    fbb_.AddElement<uint32_t>(Animator::VT_PROPERTY, property, 0);
+  }
+  void add_animation(uint32_t animation) {
+    fbb_.AddElement<uint32_t>(Animator::VT_ANIMATION, animation, 0);
+  }
+  void add_controller(uint32_t controller) {
+    fbb_.AddElement<uint32_t>(Animator::VT_CONTROLLER, controller, 4294967295);
+  }
+  explicit AnimatorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Animator> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Animator>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Animator> CreateAnimator(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t property = 0,
+    uint32_t animation = 0,
+    uint32_t controller = 4294967295) {
+  AnimatorBuilder builder_(_fbb);
+  builder_.add_controller(controller);
+  builder_.add_animation(animation);
+  builder_.add_property(property);
+  return builder_.Finish();
+}
+
+struct CompObj FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef CompObjBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_COMMENT = 4,
+    VT_ANIMATORS = 6,
+    VT_PROPERTIES = 8
+  };
+  uint32_t comment() const {
+    return GetField<uint32_t>(VT_COMMENT, 4294967295);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animator>> *animators() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animator>> *>(VT_ANIMATORS);
+  }
+  uint32_t properties() const {
+    return GetField<uint32_t>(VT_PROPERTIES, 4294967295);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_COMMENT, 4) &&
+           VerifyOffset(verifier, VT_ANIMATORS) &&
+           verifier.VerifyVector(animators()) &&
+           verifier.VerifyVectorOfTables(animators()) &&
+           VerifyField<uint32_t>(verifier, VT_PROPERTIES, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct CompObjBuilder {
+  typedef CompObj Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_comment(uint32_t comment) {
+    fbb_.AddElement<uint32_t>(CompObj::VT_COMMENT, comment, 4294967295);
+  }
+  void add_animators(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animator>>> animators) {
+    fbb_.AddOffset(CompObj::VT_ANIMATORS, animators);
+  }
+  void add_properties(uint32_t properties) {
+    fbb_.AddElement<uint32_t>(CompObj::VT_PROPERTIES, properties, 4294967295);
+  }
+  explicit CompObjBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<CompObj> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<CompObj>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<CompObj> CreateCompObj(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t comment = 4294967295,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animator>>> animators = 0,
+    uint32_t properties = 4294967295) {
+  CompObjBuilder builder_(_fbb);
+  builder_.add_properties(properties);
+  builder_.add_animators(animators);
+  builder_.add_comment(comment);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<CompObj> CreateCompObjDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t comment = 4294967295,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animator>> *animators = nullptr,
+    uint32_t properties = 4294967295) {
+  auto animators__ = animators ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animator>>(*animators) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreateCompObj(
+      _fbb,
+      comment,
+      animators__,
+      properties);
+}
+
+struct PropertyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef PropertyValueBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_TYPE = 6,
+    VT_SCALAR = 8,
+    VT_VECTOR = 10,
+    VT_COLOR = 12
+  };
+  uint32_t name() const {
+    return GetField<uint32_t>(VT_NAME, 0);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType type() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType>(GetField<uint8_t>(VT_TYPE, 0));
+  }
+  float scalar() const {
+    return GetField<float>(VT_SCALAR, 0.0f);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *vector() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *>(VT_VECTOR);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *>(VT_COLOR);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
+           VerifyField<uint8_t>(verifier, VT_TYPE, 1) &&
+           VerifyField<float>(verifier, VT_SCALAR, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4>(verifier, VT_VECTOR, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color>(verifier, VT_COLOR, 1) &&
+           verifier.EndTable();
+  }
+};
+
+struct PropertyValueBuilder {
+  typedef PropertyValue Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(uint32_t name) {
+    fbb_.AddElement<uint32_t>(PropertyValue::VT_NAME, name, 0);
+  }
+  void add_type(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType type) {
+    fbb_.AddElement<uint8_t>(PropertyValue::VT_TYPE, static_cast<uint8_t>(type), 0);
+  }
+  void add_scalar(float scalar) {
+    fbb_.AddElement<float>(PropertyValue::VT_SCALAR, scalar, 0.0f);
+  }
+  void add_vector(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *vector) {
+    fbb_.AddStruct(PropertyValue::VT_VECTOR, vector);
+  }
+  void add_color(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color) {
+    fbb_.AddStruct(PropertyValue::VT_COLOR, color);
+  }
+  explicit PropertyValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<PropertyValue> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<PropertyValue>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<PropertyValue> CreatePropertyValue(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t name = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType type = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType::None,
+    float scalar = 0.0f,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *vector = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color = nullptr) {
+  PropertyValueBuilder builder_(_fbb);
+  builder_.add_color(color);
+  builder_.add_vector(vector);
+  builder_.add_scalar(scalar);
+  builder_.add_name(name);
+  builder_.add_type(type);
+  return builder_.Finish();
+}
+
+struct ReferenceParameter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ReferenceParameterBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_TARGET = 6
+  };
+  uint32_t name() const {
+    return GetField<uint32_t>(VT_NAME, 0);
+  }
+  uint32_t target() const {
+    return GetField<uint32_t>(VT_TARGET, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
+           VerifyField<uint32_t>(verifier, VT_TARGET, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct ReferenceParameterBuilder {
+  typedef ReferenceParameter Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(uint32_t name) {
+    fbb_.AddElement<uint32_t>(ReferenceParameter::VT_NAME, name, 0);
+  }
+  void add_target(uint32_t target) {
+    fbb_.AddElement<uint32_t>(ReferenceParameter::VT_TARGET, target, 0);
+  }
+  explicit ReferenceParameterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<ReferenceParameter> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<ReferenceParameter>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<ReferenceParameter> CreateReferenceParameter(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t name = 0,
+    uint32_t target = 0) {
+  ReferenceParameterBuilder builder_(_fbb);
+  builder_.add_target(target);
+  builder_.add_name(name);
+  return builder_.Finish();
+}
+
+struct SourceParameter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef SourceParameterBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_BRUSH = 6
+  };
+  uint32_t name() const {
+    return GetField<uint32_t>(VT_NAME, 0);
+  }
+  uint32_t brush() const {
+    return GetField<uint32_t>(VT_BRUSH, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
+           VerifyField<uint32_t>(verifier, VT_BRUSH, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct SourceParameterBuilder {
+  typedef SourceParameter Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(uint32_t name) {
+    fbb_.AddElement<uint32_t>(SourceParameter::VT_NAME, name, 0);
+  }
+  void add_brush(uint32_t brush) {
+    fbb_.AddElement<uint32_t>(SourceParameter::VT_BRUSH, brush, 0);
+  }
+  explicit SourceParameterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<SourceParameter> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<SourceParameter>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<SourceParameter> CreateSourceParameter(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t name = 0,
+    uint32_t brush = 0) {
+  SourceParameterBuilder builder_(_fbb);
+  builder_.add_brush(brush);
+  builder_.add_name(name);
+  return builder_.Finish();
+}
+
+struct KeyFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef KeyFrameBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_PROGRESS = 4,
+    VT_EASING = 6,
+    VT_KIND = 8,
+    VT_EXPRESSION = 10,
+    VT_SCALAR = 12,
+    VT_VECTOR = 14,
+    VT_COLOR = 16,
+    VT_PATH = 18
+  };
+  float progress() const {
+    return GetField<float>(VT_PROGRESS, 0.0f);
+  }
+  uint32_t easing() const {
+    return GetField<uint32_t>(VT_EASING, 4294967295);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrameKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrameKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  uint32_t expression() const {
+    return GetField<uint32_t>(VT_EXPRESSION, 4294967295);
+  }
+  float scalar() const {
+    return GetField<float>(VT_SCALAR, 0.0f);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *vector() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *>(VT_VECTOR);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *>(VT_COLOR);
+  }
+  uint32_t path() const {
+    return GetField<uint32_t>(VT_PATH, 4294967295);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<float>(verifier, VT_PROGRESS, 4) &&
+           VerifyField<uint32_t>(verifier, VT_EASING, 4) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<uint32_t>(verifier, VT_EXPRESSION, 4) &&
+           VerifyField<float>(verifier, VT_SCALAR, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4>(verifier, VT_VECTOR, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color>(verifier, VT_COLOR, 1) &&
+           VerifyField<uint32_t>(verifier, VT_PATH, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct KeyFrameBuilder {
+  typedef KeyFrame Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_progress(float progress) {
+    fbb_.AddElement<float>(KeyFrame::VT_PROGRESS, progress, 0.0f);
+  }
+  void add_easing(uint32_t easing) {
+    fbb_.AddElement<uint32_t>(KeyFrame::VT_EASING, easing, 4294967295);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrameKind kind) {
+    fbb_.AddElement<uint8_t>(KeyFrame::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_expression(uint32_t expression) {
+    fbb_.AddElement<uint32_t>(KeyFrame::VT_EXPRESSION, expression, 4294967295);
+  }
+  void add_scalar(float scalar) {
+    fbb_.AddElement<float>(KeyFrame::VT_SCALAR, scalar, 0.0f);
+  }
+  void add_vector(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *vector) {
+    fbb_.AddStruct(KeyFrame::VT_VECTOR, vector);
+  }
+  void add_color(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color) {
+    fbb_.AddStruct(KeyFrame::VT_COLOR, color);
+  }
+  void add_path(uint32_t path) {
+    fbb_.AddElement<uint32_t>(KeyFrame::VT_PATH, path, 4294967295);
+  }
+  explicit KeyFrameBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<KeyFrame> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<KeyFrame>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<KeyFrame> CreateKeyFrame(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    float progress = 0.0f,
+    uint32_t easing = 4294967295,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrameKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrameKind::Value,
+    uint32_t expression = 4294967295,
+    float scalar = 0.0f,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *vector = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color = nullptr,
+    uint32_t path = 4294967295) {
+  KeyFrameBuilder builder_(_fbb);
+  builder_.add_path(path);
+  builder_.add_color(color);
+  builder_.add_vector(vector);
+  builder_.add_scalar(scalar);
+  builder_.add_expression(expression);
+  builder_.add_easing(easing);
+  builder_.add_progress(progress);
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+struct Visual FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef VisualBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_KIND = 6,
+    VT_BORDER_MODE = 8,
+    VT_CENTER_POINT = 10,
+    VT_CLIP = 12,
+    VT_IS_VISIBLE = 14,
+    VT_OFFSET = 16,
+    VT_OPACITY = 18,
+    VT_ROTATION_ANGLE_IN_DEGREES = 20,
+    VT_ROTATION_AXIS = 22,
+    VT_SCALE = 24,
+    VT_SIZE = 26,
+    VT_TRANSFORM_MATRIX = 28,
+    VT_CHILDREN = 30,
+    VT_SHAPES = 32,
+    VT_VIEW_BOX = 34,
+    VT_BRUSH = 36,
+    VT_SHADOW = 38
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::VisualKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::VisualKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  ::flatbuffers::Optional<uint8_t> border_mode() const {
+    return GetOptional<uint8_t, uint8_t>(VT_BORDER_MODE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *center_point() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *>(VT_CENTER_POINT);
+  }
+  uint32_t clip() const {
+    return GetField<uint32_t>(VT_CLIP, 4294967295);
+  }
+  ::flatbuffers::Optional<bool> is_visible() const {
+    return GetOptional<uint8_t, bool>(VT_IS_VISIBLE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *offset() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *>(VT_OFFSET);
+  }
+  ::flatbuffers::Optional<float> opacity() const {
+    return GetOptional<float, float>(VT_OPACITY);
+  }
+  ::flatbuffers::Optional<float> rotation_angle_in_degrees() const {
+    return GetOptional<float, float>(VT_ROTATION_ANGLE_IN_DEGREES);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *rotation_axis() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *>(VT_ROTATION_AXIS);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *scale() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *>(VT_SCALE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_SIZE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat4x4 *transform_matrix() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat4x4 *>(VT_TRANSFORM_MATRIX);
+  }
+  const ::flatbuffers::Vector<uint32_t> *children() const {
+    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_CHILDREN);
+  }
+  const ::flatbuffers::Vector<uint32_t> *shapes() const {
+    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_SHAPES);
+  }
+  uint32_t view_box() const {
+    return GetField<uint32_t>(VT_VIEW_BOX, 4294967295);
+  }
+  uint32_t brush() const {
+    return GetField<uint32_t>(VT_BRUSH, 4294967295);
+  }
+  uint32_t shadow() const {
+    return GetField<uint32_t>(VT_SHADOW, 4294967295);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<uint8_t>(verifier, VT_BORDER_MODE, 1) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3>(verifier, VT_CENTER_POINT, 4) &&
+           VerifyField<uint32_t>(verifier, VT_CLIP, 4) &&
+           VerifyField<uint8_t>(verifier, VT_IS_VISIBLE, 1) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3>(verifier, VT_OFFSET, 4) &&
+           VerifyField<float>(verifier, VT_OPACITY, 4) &&
+           VerifyField<float>(verifier, VT_ROTATION_ANGLE_IN_DEGREES, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3>(verifier, VT_ROTATION_AXIS, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3>(verifier, VT_SCALE, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_SIZE, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat4x4>(verifier, VT_TRANSFORM_MATRIX, 4) &&
+           VerifyOffset(verifier, VT_CHILDREN) &&
+           verifier.VerifyVector(children()) &&
+           VerifyOffset(verifier, VT_SHAPES) &&
+           verifier.VerifyVector(shapes()) &&
+           VerifyField<uint32_t>(verifier, VT_VIEW_BOX, 4) &&
+           VerifyField<uint32_t>(verifier, VT_BRUSH, 4) &&
+           VerifyField<uint32_t>(verifier, VT_SHADOW, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct VisualBuilder {
+  typedef Visual Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Visual::VT_BASE, base);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::VisualKind kind) {
+    fbb_.AddElement<uint8_t>(Visual::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_border_mode(uint8_t border_mode) {
+    fbb_.AddElement<uint8_t>(Visual::VT_BORDER_MODE, border_mode);
+  }
+  void add_center_point(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *center_point) {
+    fbb_.AddStruct(Visual::VT_CENTER_POINT, center_point);
+  }
+  void add_clip(uint32_t clip) {
+    fbb_.AddElement<uint32_t>(Visual::VT_CLIP, clip, 4294967295);
+  }
+  void add_is_visible(bool is_visible) {
+    fbb_.AddElement<uint8_t>(Visual::VT_IS_VISIBLE, static_cast<uint8_t>(is_visible));
+  }
+  void add_offset(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *offset) {
+    fbb_.AddStruct(Visual::VT_OFFSET, offset);
+  }
+  void add_opacity(float opacity) {
+    fbb_.AddElement<float>(Visual::VT_OPACITY, opacity);
+  }
+  void add_rotation_angle_in_degrees(float rotation_angle_in_degrees) {
+    fbb_.AddElement<float>(Visual::VT_ROTATION_ANGLE_IN_DEGREES, rotation_angle_in_degrees);
+  }
+  void add_rotation_axis(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *rotation_axis) {
+    fbb_.AddStruct(Visual::VT_ROTATION_AXIS, rotation_axis);
+  }
+  void add_scale(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *scale) {
+    fbb_.AddStruct(Visual::VT_SCALE, scale);
+  }
+  void add_size(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size) {
+    fbb_.AddStruct(Visual::VT_SIZE, size);
+  }
+  void add_transform_matrix(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat4x4 *transform_matrix) {
+    fbb_.AddStruct(Visual::VT_TRANSFORM_MATRIX, transform_matrix);
+  }
+  void add_children(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> children) {
+    fbb_.AddOffset(Visual::VT_CHILDREN, children);
+  }
+  void add_shapes(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> shapes) {
+    fbb_.AddOffset(Visual::VT_SHAPES, shapes);
+  }
+  void add_view_box(uint32_t view_box) {
+    fbb_.AddElement<uint32_t>(Visual::VT_VIEW_BOX, view_box, 4294967295);
+  }
+  void add_brush(uint32_t brush) {
+    fbb_.AddElement<uint32_t>(Visual::VT_BRUSH, brush, 4294967295);
+  }
+  void add_shadow(uint32_t shadow) {
+    fbb_.AddElement<uint32_t>(Visual::VT_SHADOW, shadow, 4294967295);
+  }
+  explicit VisualBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Visual> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Visual>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Visual> CreateVisual(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::VisualKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::VisualKind::Container,
+    ::flatbuffers::Optional<uint8_t> border_mode = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *center_point = nullptr,
+    uint32_t clip = 4294967295,
+    ::flatbuffers::Optional<bool> is_visible = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *offset = nullptr,
+    ::flatbuffers::Optional<float> opacity = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> rotation_angle_in_degrees = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *rotation_axis = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *scale = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat4x4 *transform_matrix = nullptr,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> children = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> shapes = 0,
+    uint32_t view_box = 4294967295,
+    uint32_t brush = 4294967295,
+    uint32_t shadow = 4294967295) {
+  VisualBuilder builder_(_fbb);
+  builder_.add_shadow(shadow);
+  builder_.add_brush(brush);
+  builder_.add_view_box(view_box);
+  builder_.add_shapes(shapes);
+  builder_.add_children(children);
+  builder_.add_transform_matrix(transform_matrix);
+  builder_.add_size(size);
+  builder_.add_scale(scale);
+  builder_.add_rotation_axis(rotation_axis);
+  if(rotation_angle_in_degrees) { builder_.add_rotation_angle_in_degrees(*rotation_angle_in_degrees); }
+  if(opacity) { builder_.add_opacity(*opacity); }
+  builder_.add_offset(offset);
+  builder_.add_clip(clip);
+  builder_.add_center_point(center_point);
+  builder_.add_base(base);
+  if(is_visible) { builder_.add_is_visible(*is_visible); }
+  if(border_mode) { builder_.add_border_mode(*border_mode); }
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Visual> CreateVisualDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::VisualKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::VisualKind::Container,
+    ::flatbuffers::Optional<uint8_t> border_mode = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *center_point = nullptr,
+    uint32_t clip = 4294967295,
+    ::flatbuffers::Optional<bool> is_visible = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *offset = nullptr,
+    ::flatbuffers::Optional<float> opacity = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> rotation_angle_in_degrees = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *rotation_axis = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *scale = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat4x4 *transform_matrix = nullptr,
+    const std::vector<uint32_t> *children = nullptr,
+    const std::vector<uint32_t> *shapes = nullptr,
+    uint32_t view_box = 4294967295,
+    uint32_t brush = 4294967295,
+    uint32_t shadow = 4294967295) {
+  auto children__ = children ? _fbb.CreateVector<uint32_t>(*children) : 0;
+  auto shapes__ = shapes ? _fbb.CreateVector<uint32_t>(*shapes) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreateVisual(
+      _fbb,
+      base,
+      kind,
+      border_mode,
+      center_point,
+      clip,
+      is_visible,
+      offset,
+      opacity,
+      rotation_angle_in_degrees,
+      rotation_axis,
+      scale,
+      size,
+      transform_matrix,
+      children__,
+      shapes__,
+      view_box,
+      brush,
+      shadow);
+}
+
+struct Shape FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ShapeBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_KIND = 6,
+    VT_CENTER_POINT = 8,
+    VT_OFFSET = 10,
+    VT_ROTATION_ANGLE_IN_DEGREES = 12,
+    VT_SCALE = 14,
+    VT_TRANSFORM_MATRIX = 16,
+    VT_SHAPES = 18,
+    VT_FILL_BRUSH = 20,
+    VT_STROKE_BRUSH = 22,
+    VT_GEOMETRY = 24,
+    VT_IS_STROKE_NON_SCALING = 26,
+    VT_STROKE_DASH_OFFSET = 28,
+    VT_STROKE_DASH_ARRAY = 30,
+    VT_STROKE_DASH_CAP = 32,
+    VT_STROKE_START_CAP = 34,
+    VT_STROKE_END_CAP = 36,
+    VT_STROKE_LINE_JOIN = 38,
+    VT_STROKE_MITER_LIMIT = 40,
+    VT_STROKE_THICKNESS = 42
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShapeKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShapeKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_CENTER_POINT);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_OFFSET);
+  }
+  ::flatbuffers::Optional<float> rotation_angle_in_degrees() const {
+    return GetOptional<float, float>(VT_ROTATION_ANGLE_IN_DEGREES);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_SCALE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *transform_matrix() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *>(VT_TRANSFORM_MATRIX);
+  }
+  const ::flatbuffers::Vector<uint32_t> *shapes() const {
+    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_SHAPES);
+  }
+  uint32_t fill_brush() const {
+    return GetField<uint32_t>(VT_FILL_BRUSH, 4294967295);
+  }
+  uint32_t stroke_brush() const {
+    return GetField<uint32_t>(VT_STROKE_BRUSH, 4294967295);
+  }
+  uint32_t geometry() const {
+    return GetField<uint32_t>(VT_GEOMETRY, 4294967295);
+  }
+  ::flatbuffers::Optional<bool> is_stroke_non_scaling() const {
+    return GetOptional<uint8_t, bool>(VT_IS_STROKE_NON_SCALING);
+  }
+  ::flatbuffers::Optional<float> stroke_dash_offset() const {
+    return GetOptional<float, float>(VT_STROKE_DASH_OFFSET);
+  }
+  const ::flatbuffers::Vector<float> *stroke_dash_array() const {
+    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_STROKE_DASH_ARRAY);
+  }
+  ::flatbuffers::Optional<uint8_t> stroke_dash_cap() const {
+    return GetOptional<uint8_t, uint8_t>(VT_STROKE_DASH_CAP);
+  }
+  ::flatbuffers::Optional<uint8_t> stroke_start_cap() const {
+    return GetOptional<uint8_t, uint8_t>(VT_STROKE_START_CAP);
+  }
+  ::flatbuffers::Optional<uint8_t> stroke_end_cap() const {
+    return GetOptional<uint8_t, uint8_t>(VT_STROKE_END_CAP);
+  }
+  ::flatbuffers::Optional<uint8_t> stroke_line_join() const {
+    return GetOptional<uint8_t, uint8_t>(VT_STROKE_LINE_JOIN);
+  }
+  ::flatbuffers::Optional<float> stroke_miter_limit() const {
+    return GetOptional<float, float>(VT_STROKE_MITER_LIMIT);
+  }
+  ::flatbuffers::Optional<float> stroke_thickness() const {
+    return GetOptional<float, float>(VT_STROKE_THICKNESS);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_CENTER_POINT, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_OFFSET, 4) &&
+           VerifyField<float>(verifier, VT_ROTATION_ANGLE_IN_DEGREES, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_SCALE, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2>(verifier, VT_TRANSFORM_MATRIX, 4) &&
+           VerifyOffset(verifier, VT_SHAPES) &&
+           verifier.VerifyVector(shapes()) &&
+           VerifyField<uint32_t>(verifier, VT_FILL_BRUSH, 4) &&
+           VerifyField<uint32_t>(verifier, VT_STROKE_BRUSH, 4) &&
+           VerifyField<uint32_t>(verifier, VT_GEOMETRY, 4) &&
+           VerifyField<uint8_t>(verifier, VT_IS_STROKE_NON_SCALING, 1) &&
+           VerifyField<float>(verifier, VT_STROKE_DASH_OFFSET, 4) &&
+           VerifyOffset(verifier, VT_STROKE_DASH_ARRAY) &&
+           verifier.VerifyVector(stroke_dash_array()) &&
+           VerifyField<uint8_t>(verifier, VT_STROKE_DASH_CAP, 1) &&
+           VerifyField<uint8_t>(verifier, VT_STROKE_START_CAP, 1) &&
+           VerifyField<uint8_t>(verifier, VT_STROKE_END_CAP, 1) &&
+           VerifyField<uint8_t>(verifier, VT_STROKE_LINE_JOIN, 1) &&
+           VerifyField<float>(verifier, VT_STROKE_MITER_LIMIT, 4) &&
+           VerifyField<float>(verifier, VT_STROKE_THICKNESS, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct ShapeBuilder {
+  typedef Shape Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Shape::VT_BASE, base);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShapeKind kind) {
+    fbb_.AddElement<uint8_t>(Shape::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_center_point(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point) {
+    fbb_.AddStruct(Shape::VT_CENTER_POINT, center_point);
+  }
+  void add_offset(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset) {
+    fbb_.AddStruct(Shape::VT_OFFSET, offset);
+  }
+  void add_rotation_angle_in_degrees(float rotation_angle_in_degrees) {
+    fbb_.AddElement<float>(Shape::VT_ROTATION_ANGLE_IN_DEGREES, rotation_angle_in_degrees);
+  }
+  void add_scale(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale) {
+    fbb_.AddStruct(Shape::VT_SCALE, scale);
+  }
+  void add_transform_matrix(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *transform_matrix) {
+    fbb_.AddStruct(Shape::VT_TRANSFORM_MATRIX, transform_matrix);
+  }
+  void add_shapes(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> shapes) {
+    fbb_.AddOffset(Shape::VT_SHAPES, shapes);
+  }
+  void add_fill_brush(uint32_t fill_brush) {
+    fbb_.AddElement<uint32_t>(Shape::VT_FILL_BRUSH, fill_brush, 4294967295);
+  }
+  void add_stroke_brush(uint32_t stroke_brush) {
+    fbb_.AddElement<uint32_t>(Shape::VT_STROKE_BRUSH, stroke_brush, 4294967295);
+  }
+  void add_geometry(uint32_t geometry) {
+    fbb_.AddElement<uint32_t>(Shape::VT_GEOMETRY, geometry, 4294967295);
+  }
+  void add_is_stroke_non_scaling(bool is_stroke_non_scaling) {
+    fbb_.AddElement<uint8_t>(Shape::VT_IS_STROKE_NON_SCALING, static_cast<uint8_t>(is_stroke_non_scaling));
+  }
+  void add_stroke_dash_offset(float stroke_dash_offset) {
+    fbb_.AddElement<float>(Shape::VT_STROKE_DASH_OFFSET, stroke_dash_offset);
+  }
+  void add_stroke_dash_array(::flatbuffers::Offset<::flatbuffers::Vector<float>> stroke_dash_array) {
+    fbb_.AddOffset(Shape::VT_STROKE_DASH_ARRAY, stroke_dash_array);
+  }
+  void add_stroke_dash_cap(uint8_t stroke_dash_cap) {
+    fbb_.AddElement<uint8_t>(Shape::VT_STROKE_DASH_CAP, stroke_dash_cap);
+  }
+  void add_stroke_start_cap(uint8_t stroke_start_cap) {
+    fbb_.AddElement<uint8_t>(Shape::VT_STROKE_START_CAP, stroke_start_cap);
+  }
+  void add_stroke_end_cap(uint8_t stroke_end_cap) {
+    fbb_.AddElement<uint8_t>(Shape::VT_STROKE_END_CAP, stroke_end_cap);
+  }
+  void add_stroke_line_join(uint8_t stroke_line_join) {
+    fbb_.AddElement<uint8_t>(Shape::VT_STROKE_LINE_JOIN, stroke_line_join);
+  }
+  void add_stroke_miter_limit(float stroke_miter_limit) {
+    fbb_.AddElement<float>(Shape::VT_STROKE_MITER_LIMIT, stroke_miter_limit);
+  }
+  void add_stroke_thickness(float stroke_thickness) {
+    fbb_.AddElement<float>(Shape::VT_STROKE_THICKNESS, stroke_thickness);
+  }
+  explicit ShapeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Shape> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Shape>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Shape> CreateShape(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShapeKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShapeKind::Container,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset = nullptr,
+    ::flatbuffers::Optional<float> rotation_angle_in_degrees = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *transform_matrix = nullptr,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> shapes = 0,
+    uint32_t fill_brush = 4294967295,
+    uint32_t stroke_brush = 4294967295,
+    uint32_t geometry = 4294967295,
+    ::flatbuffers::Optional<bool> is_stroke_non_scaling = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> stroke_dash_offset = ::flatbuffers::nullopt,
+    ::flatbuffers::Offset<::flatbuffers::Vector<float>> stroke_dash_array = 0,
+    ::flatbuffers::Optional<uint8_t> stroke_dash_cap = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> stroke_start_cap = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> stroke_end_cap = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> stroke_line_join = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> stroke_miter_limit = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> stroke_thickness = ::flatbuffers::nullopt) {
+  ShapeBuilder builder_(_fbb);
+  if(stroke_thickness) { builder_.add_stroke_thickness(*stroke_thickness); }
+  if(stroke_miter_limit) { builder_.add_stroke_miter_limit(*stroke_miter_limit); }
+  builder_.add_stroke_dash_array(stroke_dash_array);
+  if(stroke_dash_offset) { builder_.add_stroke_dash_offset(*stroke_dash_offset); }
+  builder_.add_geometry(geometry);
+  builder_.add_stroke_brush(stroke_brush);
+  builder_.add_fill_brush(fill_brush);
+  builder_.add_shapes(shapes);
+  builder_.add_transform_matrix(transform_matrix);
+  builder_.add_scale(scale);
+  if(rotation_angle_in_degrees) { builder_.add_rotation_angle_in_degrees(*rotation_angle_in_degrees); }
+  builder_.add_offset(offset);
+  builder_.add_center_point(center_point);
+  builder_.add_base(base);
+  if(stroke_line_join) { builder_.add_stroke_line_join(*stroke_line_join); }
+  if(stroke_end_cap) { builder_.add_stroke_end_cap(*stroke_end_cap); }
+  if(stroke_start_cap) { builder_.add_stroke_start_cap(*stroke_start_cap); }
+  if(stroke_dash_cap) { builder_.add_stroke_dash_cap(*stroke_dash_cap); }
+  if(is_stroke_non_scaling) { builder_.add_is_stroke_non_scaling(*is_stroke_non_scaling); }
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Shape> CreateShapeDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShapeKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShapeKind::Container,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset = nullptr,
+    ::flatbuffers::Optional<float> rotation_angle_in_degrees = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *transform_matrix = nullptr,
+    const std::vector<uint32_t> *shapes = nullptr,
+    uint32_t fill_brush = 4294967295,
+    uint32_t stroke_brush = 4294967295,
+    uint32_t geometry = 4294967295,
+    ::flatbuffers::Optional<bool> is_stroke_non_scaling = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> stroke_dash_offset = ::flatbuffers::nullopt,
+    const std::vector<float> *stroke_dash_array = nullptr,
+    ::flatbuffers::Optional<uint8_t> stroke_dash_cap = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> stroke_start_cap = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> stroke_end_cap = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> stroke_line_join = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> stroke_miter_limit = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> stroke_thickness = ::flatbuffers::nullopt) {
+  auto shapes__ = shapes ? _fbb.CreateVector<uint32_t>(*shapes) : 0;
+  auto stroke_dash_array__ = stroke_dash_array ? _fbb.CreateVector<float>(*stroke_dash_array) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreateShape(
+      _fbb,
+      base,
+      kind,
+      center_point,
+      offset,
+      rotation_angle_in_degrees,
+      scale,
+      transform_matrix,
+      shapes__,
+      fill_brush,
+      stroke_brush,
+      geometry,
+      is_stroke_non_scaling,
+      stroke_dash_offset,
+      stroke_dash_array__,
+      stroke_dash_cap,
+      stroke_start_cap,
+      stroke_end_cap,
+      stroke_line_join,
+      stroke_miter_limit,
+      stroke_thickness);
+}
+
+struct Geometry FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef GeometryBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_KIND = 6,
+    VT_TRIM_START = 8,
+    VT_TRIM_END = 10,
+    VT_TRIM_OFFSET = 12,
+    VT_PATH = 14,
+    VT_OFFSET = 16,
+    VT_SIZE = 18,
+    VT_CORNER_RADIUS = 20,
+    VT_CENTER = 22,
+    VT_RADIUS = 24
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GeometryKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GeometryKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  ::flatbuffers::Optional<float> trim_start() const {
+    return GetOptional<float, float>(VT_TRIM_START);
+  }
+  ::flatbuffers::Optional<float> trim_end() const {
+    return GetOptional<float, float>(VT_TRIM_END);
+  }
+  ::flatbuffers::Optional<float> trim_offset() const {
+    return GetOptional<float, float>(VT_TRIM_OFFSET);
+  }
+  uint32_t path() const {
+    return GetField<uint32_t>(VT_PATH, 4294967295);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_OFFSET);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_SIZE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *corner_radius() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_CORNER_RADIUS);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_CENTER);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *radius() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_RADIUS);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<float>(verifier, VT_TRIM_START, 4) &&
+           VerifyField<float>(verifier, VT_TRIM_END, 4) &&
+           VerifyField<float>(verifier, VT_TRIM_OFFSET, 4) &&
+           VerifyField<uint32_t>(verifier, VT_PATH, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_OFFSET, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_SIZE, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_CORNER_RADIUS, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_CENTER, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_RADIUS, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct GeometryBuilder {
+  typedef Geometry Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Geometry::VT_BASE, base);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GeometryKind kind) {
+    fbb_.AddElement<uint8_t>(Geometry::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_trim_start(float trim_start) {
+    fbb_.AddElement<float>(Geometry::VT_TRIM_START, trim_start);
+  }
+  void add_trim_end(float trim_end) {
+    fbb_.AddElement<float>(Geometry::VT_TRIM_END, trim_end);
+  }
+  void add_trim_offset(float trim_offset) {
+    fbb_.AddElement<float>(Geometry::VT_TRIM_OFFSET, trim_offset);
+  }
+  void add_path(uint32_t path) {
+    fbb_.AddElement<uint32_t>(Geometry::VT_PATH, path, 4294967295);
+  }
+  void add_offset(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset) {
+    fbb_.AddStruct(Geometry::VT_OFFSET, offset);
+  }
+  void add_size(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size) {
+    fbb_.AddStruct(Geometry::VT_SIZE, size);
+  }
+  void add_corner_radius(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *corner_radius) {
+    fbb_.AddStruct(Geometry::VT_CORNER_RADIUS, corner_radius);
+  }
+  void add_center(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center) {
+    fbb_.AddStruct(Geometry::VT_CENTER, center);
+  }
+  void add_radius(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *radius) {
+    fbb_.AddStruct(Geometry::VT_RADIUS, radius);
+  }
+  explicit GeometryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Geometry> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Geometry>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Geometry> CreateGeometry(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GeometryKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GeometryKind::Path,
+    ::flatbuffers::Optional<float> trim_start = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> trim_end = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> trim_offset = ::flatbuffers::nullopt,
+    uint32_t path = 4294967295,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *corner_radius = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *radius = nullptr) {
+  GeometryBuilder builder_(_fbb);
+  builder_.add_radius(radius);
+  builder_.add_center(center);
+  builder_.add_corner_radius(corner_radius);
+  builder_.add_size(size);
+  builder_.add_offset(offset);
+  builder_.add_path(path);
+  if(trim_offset) { builder_.add_trim_offset(*trim_offset); }
+  if(trim_end) { builder_.add_trim_end(*trim_end); }
+  if(trim_start) { builder_.add_trim_start(*trim_start); }
+  builder_.add_base(base);
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+struct Brush FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef BrushBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_KIND = 6,
+    VT_COLOR = 8,
+    VT_ANCHOR_POINT = 10,
+    VT_CENTER_POINT = 12,
+    VT_COLOR_STOPS = 14,
+    VT_EXTEND_MODE = 16,
+    VT_INTERPOLATION_SPACE = 18,
+    VT_MAPPING_MODE = 20,
+    VT_OFFSET = 22,
+    VT_ROTATION_ANGLE_IN_DEGREES = 24,
+    VT_SCALE = 26,
+    VT_TRANSFORM_MATRIX = 28,
+    VT_START_POINT = 30,
+    VT_END_POINT = 32,
+    VT_ELLIPSE_CENTER = 34,
+    VT_ELLIPSE_RADIUS = 36,
+    VT_GRADIENT_ORIGIN_OFFSET = 38,
+    VT_SURFACE = 40,
+    VT_SOURCE = 42,
+    VT_MASK = 44,
+    VT_EFFECT = 46,
+    VT_SOURCE_PARAMETERS = 48
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::BrushKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::BrushKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *>(VT_COLOR);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *anchor_point() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_ANCHOR_POINT);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_CENTER_POINT);
+  }
+  const ::flatbuffers::Vector<uint32_t> *color_stops() const {
+    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_COLOR_STOPS);
+  }
+  ::flatbuffers::Optional<uint8_t> extend_mode() const {
+    return GetOptional<uint8_t, uint8_t>(VT_EXTEND_MODE);
+  }
+  ::flatbuffers::Optional<uint8_t> interpolation_space() const {
+    return GetOptional<uint8_t, uint8_t>(VT_INTERPOLATION_SPACE);
+  }
+  ::flatbuffers::Optional<uint8_t> mapping_mode() const {
+    return GetOptional<uint8_t, uint8_t>(VT_MAPPING_MODE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_OFFSET);
+  }
+  ::flatbuffers::Optional<float> rotation_angle_in_degrees() const {
+    return GetOptional<float, float>(VT_ROTATION_ANGLE_IN_DEGREES);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_SCALE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *transform_matrix() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *>(VT_TRANSFORM_MATRIX);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *start_point() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_START_POINT);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *end_point() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_END_POINT);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *ellipse_center() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_ELLIPSE_CENTER);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *ellipse_radius() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_ELLIPSE_RADIUS);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *gradient_origin_offset() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_GRADIENT_ORIGIN_OFFSET);
+  }
+  uint32_t surface() const {
+    return GetField<uint32_t>(VT_SURFACE, 4294967295);
+  }
+  uint32_t source() const {
+    return GetField<uint32_t>(VT_SOURCE, 4294967295);
+  }
+  uint32_t mask() const {
+    return GetField<uint32_t>(VT_MASK, 4294967295);
+  }
+  uint32_t effect() const {
+    return GetField<uint32_t>(VT_EFFECT, 4294967295);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SourceParameter>> *source_parameters() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SourceParameter>> *>(VT_SOURCE_PARAMETERS);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color>(verifier, VT_COLOR, 1) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_ANCHOR_POINT, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_CENTER_POINT, 4) &&
+           VerifyOffset(verifier, VT_COLOR_STOPS) &&
+           verifier.VerifyVector(color_stops()) &&
+           VerifyField<uint8_t>(verifier, VT_EXTEND_MODE, 1) &&
+           VerifyField<uint8_t>(verifier, VT_INTERPOLATION_SPACE, 1) &&
+           VerifyField<uint8_t>(verifier, VT_MAPPING_MODE, 1) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_OFFSET, 4) &&
+           VerifyField<float>(verifier, VT_ROTATION_ANGLE_IN_DEGREES, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_SCALE, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2>(verifier, VT_TRANSFORM_MATRIX, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_START_POINT, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_END_POINT, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_ELLIPSE_CENTER, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_ELLIPSE_RADIUS, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_GRADIENT_ORIGIN_OFFSET, 4) &&
+           VerifyField<uint32_t>(verifier, VT_SURFACE, 4) &&
+           VerifyField<uint32_t>(verifier, VT_SOURCE, 4) &&
+           VerifyField<uint32_t>(verifier, VT_MASK, 4) &&
+           VerifyField<uint32_t>(verifier, VT_EFFECT, 4) &&
+           VerifyOffset(verifier, VT_SOURCE_PARAMETERS) &&
+           verifier.VerifyVector(source_parameters()) &&
+           verifier.VerifyVectorOfTables(source_parameters()) &&
+           verifier.EndTable();
+  }
+};
+
+struct BrushBuilder {
+  typedef Brush Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Brush::VT_BASE, base);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::BrushKind kind) {
+    fbb_.AddElement<uint8_t>(Brush::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_color(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color) {
+    fbb_.AddStruct(Brush::VT_COLOR, color);
+  }
+  void add_anchor_point(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *anchor_point) {
+    fbb_.AddStruct(Brush::VT_ANCHOR_POINT, anchor_point);
+  }
+  void add_center_point(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point) {
+    fbb_.AddStruct(Brush::VT_CENTER_POINT, center_point);
+  }
+  void add_color_stops(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> color_stops) {
+    fbb_.AddOffset(Brush::VT_COLOR_STOPS, color_stops);
+  }
+  void add_extend_mode(uint8_t extend_mode) {
+    fbb_.AddElement<uint8_t>(Brush::VT_EXTEND_MODE, extend_mode);
+  }
+  void add_interpolation_space(uint8_t interpolation_space) {
+    fbb_.AddElement<uint8_t>(Brush::VT_INTERPOLATION_SPACE, interpolation_space);
+  }
+  void add_mapping_mode(uint8_t mapping_mode) {
+    fbb_.AddElement<uint8_t>(Brush::VT_MAPPING_MODE, mapping_mode);
+  }
+  void add_offset(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset) {
+    fbb_.AddStruct(Brush::VT_OFFSET, offset);
+  }
+  void add_rotation_angle_in_degrees(float rotation_angle_in_degrees) {
+    fbb_.AddElement<float>(Brush::VT_ROTATION_ANGLE_IN_DEGREES, rotation_angle_in_degrees);
+  }
+  void add_scale(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale) {
+    fbb_.AddStruct(Brush::VT_SCALE, scale);
+  }
+  void add_transform_matrix(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *transform_matrix) {
+    fbb_.AddStruct(Brush::VT_TRANSFORM_MATRIX, transform_matrix);
+  }
+  void add_start_point(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *start_point) {
+    fbb_.AddStruct(Brush::VT_START_POINT, start_point);
+  }
+  void add_end_point(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *end_point) {
+    fbb_.AddStruct(Brush::VT_END_POINT, end_point);
+  }
+  void add_ellipse_center(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *ellipse_center) {
+    fbb_.AddStruct(Brush::VT_ELLIPSE_CENTER, ellipse_center);
+  }
+  void add_ellipse_radius(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *ellipse_radius) {
+    fbb_.AddStruct(Brush::VT_ELLIPSE_RADIUS, ellipse_radius);
+  }
+  void add_gradient_origin_offset(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *gradient_origin_offset) {
+    fbb_.AddStruct(Brush::VT_GRADIENT_ORIGIN_OFFSET, gradient_origin_offset);
+  }
+  void add_surface(uint32_t surface) {
+    fbb_.AddElement<uint32_t>(Brush::VT_SURFACE, surface, 4294967295);
+  }
+  void add_source(uint32_t source) {
+    fbb_.AddElement<uint32_t>(Brush::VT_SOURCE, source, 4294967295);
+  }
+  void add_mask(uint32_t mask) {
+    fbb_.AddElement<uint32_t>(Brush::VT_MASK, mask, 4294967295);
+  }
+  void add_effect(uint32_t effect) {
+    fbb_.AddElement<uint32_t>(Brush::VT_EFFECT, effect, 4294967295);
+  }
+  void add_source_parameters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SourceParameter>>> source_parameters) {
+    fbb_.AddOffset(Brush::VT_SOURCE_PARAMETERS, source_parameters);
+  }
+  explicit BrushBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Brush> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Brush>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Brush> CreateBrush(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::BrushKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::BrushKind::Color,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *anchor_point = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point = nullptr,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> color_stops = 0,
+    ::flatbuffers::Optional<uint8_t> extend_mode = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> interpolation_space = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> mapping_mode = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset = nullptr,
+    ::flatbuffers::Optional<float> rotation_angle_in_degrees = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *transform_matrix = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *start_point = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *end_point = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *ellipse_center = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *ellipse_radius = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *gradient_origin_offset = nullptr,
+    uint32_t surface = 4294967295,
+    uint32_t source = 4294967295,
+    uint32_t mask = 4294967295,
+    uint32_t effect = 4294967295,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SourceParameter>>> source_parameters = 0) {
+  BrushBuilder builder_(_fbb);
+  builder_.add_source_parameters(source_parameters);
+  builder_.add_effect(effect);
+  builder_.add_mask(mask);
+  builder_.add_source(source);
+  builder_.add_surface(surface);
+  builder_.add_gradient_origin_offset(gradient_origin_offset);
+  builder_.add_ellipse_radius(ellipse_radius);
+  builder_.add_ellipse_center(ellipse_center);
+  builder_.add_end_point(end_point);
+  builder_.add_start_point(start_point);
+  builder_.add_transform_matrix(transform_matrix);
+  builder_.add_scale(scale);
+  if(rotation_angle_in_degrees) { builder_.add_rotation_angle_in_degrees(*rotation_angle_in_degrees); }
+  builder_.add_offset(offset);
+  builder_.add_color_stops(color_stops);
+  builder_.add_center_point(center_point);
+  builder_.add_anchor_point(anchor_point);
+  builder_.add_color(color);
+  builder_.add_base(base);
+  if(mapping_mode) { builder_.add_mapping_mode(*mapping_mode); }
+  if(interpolation_space) { builder_.add_interpolation_space(*interpolation_space); }
+  if(extend_mode) { builder_.add_extend_mode(*extend_mode); }
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Brush> CreateBrushDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::BrushKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::BrushKind::Color,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *anchor_point = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point = nullptr,
+    const std::vector<uint32_t> *color_stops = nullptr,
+    ::flatbuffers::Optional<uint8_t> extend_mode = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> interpolation_space = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> mapping_mode = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *offset = nullptr,
+    ::flatbuffers::Optional<float> rotation_angle_in_degrees = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *transform_matrix = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *start_point = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *end_point = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *ellipse_center = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *ellipse_radius = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *gradient_origin_offset = nullptr,
+    uint32_t surface = 4294967295,
+    uint32_t source = 4294967295,
+    uint32_t mask = 4294967295,
+    uint32_t effect = 4294967295,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SourceParameter>> *source_parameters = nullptr) {
+  auto color_stops__ = color_stops ? _fbb.CreateVector<uint32_t>(*color_stops) : 0;
+  auto source_parameters__ = source_parameters ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SourceParameter>>(*source_parameters) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreateBrush(
+      _fbb,
+      base,
+      kind,
+      color,
+      anchor_point,
+      center_point,
+      color_stops__,
+      extend_mode,
+      interpolation_space,
+      mapping_mode,
+      offset,
+      rotation_angle_in_degrees,
+      scale,
+      transform_matrix,
+      start_point,
+      end_point,
+      ellipse_center,
+      ellipse_radius,
+      gradient_origin_offset,
+      surface,
+      source,
+      mask,
+      effect,
+      source_parameters__);
+}
+
+struct GradientStop FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef GradientStopBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_COLOR = 6,
+    VT_OFFSET = 8
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *>(VT_COLOR);
+  }
+  float offset() const {
+    return GetField<float>(VT_OFFSET, 0.0f);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color>(verifier, VT_COLOR, 1) &&
+           VerifyField<float>(verifier, VT_OFFSET, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct GradientStopBuilder {
+  typedef GradientStop Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(GradientStop::VT_BASE, base);
+  }
+  void add_color(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color) {
+    fbb_.AddStruct(GradientStop::VT_COLOR, color);
+  }
+  void add_offset(float offset) {
+    fbb_.AddElement<float>(GradientStop::VT_OFFSET, offset, 0.0f);
+  }
+  explicit GradientStopBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<GradientStop> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<GradientStop>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<GradientStop> CreateGradientStop(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color = nullptr,
+    float offset = 0.0f) {
+  GradientStopBuilder builder_(_fbb);
+  builder_.add_offset(offset);
+  builder_.add_color(color);
+  builder_.add_base(base);
+  return builder_.Finish();
+}
+
+struct ViewBox FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ViewBoxBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_SIZE = 6
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_SIZE);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_SIZE, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct ViewBoxBuilder {
+  typedef ViewBox Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(ViewBox::VT_BASE, base);
+  }
+  void add_size(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size) {
+    fbb_.AddStruct(ViewBox::VT_SIZE, size);
+  }
+  explicit ViewBoxBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<ViewBox> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<ViewBox>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<ViewBox> CreateViewBox(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size = nullptr) {
+  ViewBoxBuilder builder_(_fbb);
+  builder_.add_size(size);
+  builder_.add_base(base);
+  return builder_.Finish();
+}
+
+struct Clip FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ClipBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_KIND = 6,
+    VT_CENTER_POINT = 8,
+    VT_SCALE = 10,
+    VT_LEFT_INSET = 12,
+    VT_RIGHT_INSET = 14,
+    VT_TOP_INSET = 16,
+    VT_BOTTOM_INSET = 18,
+    VT_GEOMETRY = 20
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ClipKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ClipKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_CENTER_POINT);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_SCALE);
+  }
+  ::flatbuffers::Optional<float> left_inset() const {
+    return GetOptional<float, float>(VT_LEFT_INSET);
+  }
+  ::flatbuffers::Optional<float> right_inset() const {
+    return GetOptional<float, float>(VT_RIGHT_INSET);
+  }
+  ::flatbuffers::Optional<float> top_inset() const {
+    return GetOptional<float, float>(VT_TOP_INSET);
+  }
+  ::flatbuffers::Optional<float> bottom_inset() const {
+    return GetOptional<float, float>(VT_BOTTOM_INSET);
+  }
+  uint32_t geometry() const {
+    return GetField<uint32_t>(VT_GEOMETRY, 4294967295);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_CENTER_POINT, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_SCALE, 4) &&
+           VerifyField<float>(verifier, VT_LEFT_INSET, 4) &&
+           VerifyField<float>(verifier, VT_RIGHT_INSET, 4) &&
+           VerifyField<float>(verifier, VT_TOP_INSET, 4) &&
+           VerifyField<float>(verifier, VT_BOTTOM_INSET, 4) &&
+           VerifyField<uint32_t>(verifier, VT_GEOMETRY, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct ClipBuilder {
+  typedef Clip Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Clip::VT_BASE, base);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ClipKind kind) {
+    fbb_.AddElement<uint8_t>(Clip::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_center_point(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point) {
+    fbb_.AddStruct(Clip::VT_CENTER_POINT, center_point);
+  }
+  void add_scale(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale) {
+    fbb_.AddStruct(Clip::VT_SCALE, scale);
+  }
+  void add_left_inset(float left_inset) {
+    fbb_.AddElement<float>(Clip::VT_LEFT_INSET, left_inset);
+  }
+  void add_right_inset(float right_inset) {
+    fbb_.AddElement<float>(Clip::VT_RIGHT_INSET, right_inset);
+  }
+  void add_top_inset(float top_inset) {
+    fbb_.AddElement<float>(Clip::VT_TOP_INSET, top_inset);
+  }
+  void add_bottom_inset(float bottom_inset) {
+    fbb_.AddElement<float>(Clip::VT_BOTTOM_INSET, bottom_inset);
+  }
+  void add_geometry(uint32_t geometry) {
+    fbb_.AddElement<uint32_t>(Clip::VT_GEOMETRY, geometry, 4294967295);
+  }
+  explicit ClipBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Clip> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Clip>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Clip> CreateClip(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ClipKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ClipKind::Inset,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *center_point = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *scale = nullptr,
+    ::flatbuffers::Optional<float> left_inset = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> right_inset = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> top_inset = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<float> bottom_inset = ::flatbuffers::nullopt,
+    uint32_t geometry = 4294967295) {
+  ClipBuilder builder_(_fbb);
+  builder_.add_geometry(geometry);
+  if(bottom_inset) { builder_.add_bottom_inset(*bottom_inset); }
+  if(top_inset) { builder_.add_top_inset(*top_inset); }
+  if(right_inset) { builder_.add_right_inset(*right_inset); }
+  if(left_inset) { builder_.add_left_inset(*left_inset); }
+  builder_.add_scale(scale);
+  builder_.add_center_point(center_point);
+  builder_.add_base(base);
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+struct Shadow FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ShadowBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_KIND = 6,
+    VT_BLUR_RADIUS = 8,
+    VT_COLOR = 10,
+    VT_MASK = 12,
+    VT_OFFSET = 14,
+    VT_OPACITY = 16,
+    VT_SOURCE_POLICY = 18
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShadowKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShadowKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  ::flatbuffers::Optional<float> blur_radius() const {
+    return GetOptional<float, float>(VT_BLUR_RADIUS);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *>(VT_COLOR);
+  }
+  uint32_t mask() const {
+    return GetField<uint32_t>(VT_MASK, 4294967295);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *offset() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *>(VT_OFFSET);
+  }
+  ::flatbuffers::Optional<float> opacity() const {
+    return GetOptional<float, float>(VT_OPACITY);
+  }
+  ::flatbuffers::Optional<uint8_t> source_policy() const {
+    return GetOptional<uint8_t, uint8_t>(VT_SOURCE_POLICY);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<float>(verifier, VT_BLUR_RADIUS, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color>(verifier, VT_COLOR, 1) &&
+           VerifyField<uint32_t>(verifier, VT_MASK, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3>(verifier, VT_OFFSET, 4) &&
+           VerifyField<float>(verifier, VT_OPACITY, 4) &&
+           VerifyField<uint8_t>(verifier, VT_SOURCE_POLICY, 1) &&
+           verifier.EndTable();
+  }
+};
+
+struct ShadowBuilder {
+  typedef Shadow Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Shadow::VT_BASE, base);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShadowKind kind) {
+    fbb_.AddElement<uint8_t>(Shadow::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_blur_radius(float blur_radius) {
+    fbb_.AddElement<float>(Shadow::VT_BLUR_RADIUS, blur_radius);
+  }
+  void add_color(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color) {
+    fbb_.AddStruct(Shadow::VT_COLOR, color);
+  }
+  void add_mask(uint32_t mask) {
+    fbb_.AddElement<uint32_t>(Shadow::VT_MASK, mask, 4294967295);
+  }
+  void add_offset(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *offset) {
+    fbb_.AddStruct(Shadow::VT_OFFSET, offset);
+  }
+  void add_opacity(float opacity) {
+    fbb_.AddElement<float>(Shadow::VT_OPACITY, opacity);
+  }
+  void add_source_policy(uint8_t source_policy) {
+    fbb_.AddElement<uint8_t>(Shadow::VT_SOURCE_POLICY, source_policy);
+  }
+  explicit ShadowBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Shadow> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Shadow>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Shadow> CreateShadow(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShadowKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ShadowKind::Drop,
+    ::flatbuffers::Optional<float> blur_radius = ::flatbuffers::nullopt,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color = nullptr,
+    uint32_t mask = 4294967295,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec3 *offset = nullptr,
+    ::flatbuffers::Optional<float> opacity = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<uint8_t> source_policy = ::flatbuffers::nullopt) {
+  ShadowBuilder builder_(_fbb);
+  if(opacity) { builder_.add_opacity(*opacity); }
+  builder_.add_offset(offset);
+  builder_.add_mask(mask);
+  builder_.add_color(color);
+  if(blur_radius) { builder_.add_blur_radius(*blur_radius); }
+  builder_.add_base(base);
+  if(source_policy) { builder_.add_source_policy(*source_policy); }
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+struct Surface FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef SurfaceBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_KIND = 6,
+    VT_SOURCE_VISUAL = 8,
+    VT_SOURCE_SIZE = 10,
+    VT_SOURCE_OFFSET = 12,
+    VT_URI = 14,
+    VT_BYTES = 16
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SurfaceKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SurfaceKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  uint32_t source_visual() const {
+    return GetField<uint32_t>(VT_SOURCE_VISUAL, 4294967295);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *source_size() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_SOURCE_SIZE);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *source_offset() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_SOURCE_OFFSET);
+  }
+  uint32_t uri() const {
+    return GetField<uint32_t>(VT_URI, 4294967295);
+  }
+  const ::flatbuffers::Vector<uint8_t> *bytes() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_BYTES);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<uint32_t>(verifier, VT_SOURCE_VISUAL, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_SOURCE_SIZE, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_SOURCE_OFFSET, 4) &&
+           VerifyField<uint32_t>(verifier, VT_URI, 4) &&
+           VerifyOffset(verifier, VT_BYTES) &&
+           verifier.VerifyVector(bytes()) &&
+           verifier.EndTable();
+  }
+};
+
+struct SurfaceBuilder {
+  typedef Surface Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Surface::VT_BASE, base);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SurfaceKind kind) {
+    fbb_.AddElement<uint8_t>(Surface::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_source_visual(uint32_t source_visual) {
+    fbb_.AddElement<uint32_t>(Surface::VT_SOURCE_VISUAL, source_visual, 4294967295);
+  }
+  void add_source_size(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *source_size) {
+    fbb_.AddStruct(Surface::VT_SOURCE_SIZE, source_size);
+  }
+  void add_source_offset(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *source_offset) {
+    fbb_.AddStruct(Surface::VT_SOURCE_OFFSET, source_offset);
+  }
+  void add_uri(uint32_t uri) {
+    fbb_.AddElement<uint32_t>(Surface::VT_URI, uri, 4294967295);
+  }
+  void add_bytes(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> bytes) {
+    fbb_.AddOffset(Surface::VT_BYTES, bytes);
+  }
+  explicit SurfaceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Surface> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Surface>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Surface> CreateSurface(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SurfaceKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SurfaceKind::VisualSurface,
+    uint32_t source_visual = 4294967295,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *source_size = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *source_offset = nullptr,
+    uint32_t uri = 4294967295,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> bytes = 0) {
+  SurfaceBuilder builder_(_fbb);
+  builder_.add_bytes(bytes);
+  builder_.add_uri(uri);
+  builder_.add_source_offset(source_offset);
+  builder_.add_source_size(source_size);
+  builder_.add_source_visual(source_visual);
+  builder_.add_base(base);
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Surface> CreateSurfaceDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SurfaceKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SurfaceKind::VisualSurface,
+    uint32_t source_visual = 4294967295,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *source_size = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *source_offset = nullptr,
+    uint32_t uri = 4294967295,
+    const std::vector<uint8_t> *bytes = nullptr) {
+  auto bytes__ = bytes ? _fbb.CreateVector<uint8_t>(*bytes) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreateSurface(
+      _fbb,
+      base,
+      kind,
+      source_visual,
+      source_size,
+      source_offset,
+      uri,
+      bytes__);
+}
+
+struct Effect FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef EffectBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_KIND = 6,
+    VT_SOURCES = 8,
+    VT_MODE = 10,
+    VT_BLUR_AMOUNT = 12
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EffectKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EffectKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  const ::flatbuffers::Vector<uint32_t> *sources() const {
+    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_SOURCES);
+  }
+  uint8_t mode() const {
+    return GetField<uint8_t>(VT_MODE, 0);
+  }
+  float blur_amount() const {
+    return GetField<float>(VT_BLUR_AMOUNT, 0.0f);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyOffset(verifier, VT_SOURCES) &&
+           verifier.VerifyVector(sources()) &&
+           VerifyField<uint8_t>(verifier, VT_MODE, 1) &&
+           VerifyField<float>(verifier, VT_BLUR_AMOUNT, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct EffectBuilder {
+  typedef Effect Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Effect::VT_BASE, base);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EffectKind kind) {
+    fbb_.AddElement<uint8_t>(Effect::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_sources(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> sources) {
+    fbb_.AddOffset(Effect::VT_SOURCES, sources);
+  }
+  void add_mode(uint8_t mode) {
+    fbb_.AddElement<uint8_t>(Effect::VT_MODE, mode, 0);
+  }
+  void add_blur_amount(float blur_amount) {
+    fbb_.AddElement<float>(Effect::VT_BLUR_AMOUNT, blur_amount, 0.0f);
+  }
+  explicit EffectBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Effect> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Effect>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Effect> CreateEffect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EffectKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EffectKind::Composite,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> sources = 0,
+    uint8_t mode = 0,
+    float blur_amount = 0.0f) {
+  EffectBuilder builder_(_fbb);
+  builder_.add_blur_amount(blur_amount);
+  builder_.add_sources(sources);
+  builder_.add_base(base);
+  builder_.add_mode(mode);
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Effect> CreateEffectDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EffectKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EffectKind::Composite,
+    const std::vector<uint32_t> *sources = nullptr,
+    uint8_t mode = 0,
+    float blur_amount = 0.0f) {
+  auto sources__ = sources ? _fbb.CreateVector<uint32_t>(*sources) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreateEffect(
+      _fbb,
+      base,
+      kind,
+      sources__,
+      mode,
+      blur_amount);
+}
+
+struct Easing FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef EasingBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_KIND = 6,
+    VT_CONTROL_POINT_1 = 8,
+    VT_CONTROL_POINT_2 = 10,
+    VT_STEP_COUNT = 12,
+    VT_INITIAL_STEP = 14,
+    VT_FINAL_STEP = 16,
+    VT_IS_INITIAL_STEP_SINGLE_FRAME = 18,
+    VT_IS_FINAL_STEP_SINGLE_FRAME = 20
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EasingKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EasingKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *control_point_1() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_CONTROL_POINT_1);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *control_point_2() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_CONTROL_POINT_2);
+  }
+  ::flatbuffers::Optional<int32_t> step_count() const {
+    return GetOptional<int32_t, int32_t>(VT_STEP_COUNT);
+  }
+  ::flatbuffers::Optional<int32_t> initial_step() const {
+    return GetOptional<int32_t, int32_t>(VT_INITIAL_STEP);
+  }
+  ::flatbuffers::Optional<int32_t> final_step() const {
+    return GetOptional<int32_t, int32_t>(VT_FINAL_STEP);
+  }
+  ::flatbuffers::Optional<bool> is_initial_step_single_frame() const {
+    return GetOptional<uint8_t, bool>(VT_IS_INITIAL_STEP_SINGLE_FRAME);
+  }
+  ::flatbuffers::Optional<bool> is_final_step_single_frame() const {
+    return GetOptional<uint8_t, bool>(VT_IS_FINAL_STEP_SINGLE_FRAME);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_CONTROL_POINT_1, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2>(verifier, VT_CONTROL_POINT_2, 4) &&
+           VerifyField<int32_t>(verifier, VT_STEP_COUNT, 4) &&
+           VerifyField<int32_t>(verifier, VT_INITIAL_STEP, 4) &&
+           VerifyField<int32_t>(verifier, VT_FINAL_STEP, 4) &&
+           VerifyField<uint8_t>(verifier, VT_IS_INITIAL_STEP_SINGLE_FRAME, 1) &&
+           VerifyField<uint8_t>(verifier, VT_IS_FINAL_STEP_SINGLE_FRAME, 1) &&
+           verifier.EndTable();
+  }
+};
+
+struct EasingBuilder {
+  typedef Easing Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Easing::VT_BASE, base);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EasingKind kind) {
+    fbb_.AddElement<uint8_t>(Easing::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_control_point_1(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *control_point_1) {
+    fbb_.AddStruct(Easing::VT_CONTROL_POINT_1, control_point_1);
+  }
+  void add_control_point_2(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *control_point_2) {
+    fbb_.AddStruct(Easing::VT_CONTROL_POINT_2, control_point_2);
+  }
+  void add_step_count(int32_t step_count) {
+    fbb_.AddElement<int32_t>(Easing::VT_STEP_COUNT, step_count);
+  }
+  void add_initial_step(int32_t initial_step) {
+    fbb_.AddElement<int32_t>(Easing::VT_INITIAL_STEP, initial_step);
+  }
+  void add_final_step(int32_t final_step) {
+    fbb_.AddElement<int32_t>(Easing::VT_FINAL_STEP, final_step);
+  }
+  void add_is_initial_step_single_frame(bool is_initial_step_single_frame) {
+    fbb_.AddElement<uint8_t>(Easing::VT_IS_INITIAL_STEP_SINGLE_FRAME, static_cast<uint8_t>(is_initial_step_single_frame));
+  }
+  void add_is_final_step_single_frame(bool is_final_step_single_frame) {
+    fbb_.AddElement<uint8_t>(Easing::VT_IS_FINAL_STEP_SINGLE_FRAME, static_cast<uint8_t>(is_final_step_single_frame));
+  }
+  explicit EasingBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Easing> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Easing>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Easing> CreateEasing(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EasingKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::EasingKind::Linear,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *control_point_1 = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *control_point_2 = nullptr,
+    ::flatbuffers::Optional<int32_t> step_count = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<int32_t> initial_step = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<int32_t> final_step = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<bool> is_initial_step_single_frame = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<bool> is_final_step_single_frame = ::flatbuffers::nullopt) {
+  EasingBuilder builder_(_fbb);
+  if(final_step) { builder_.add_final_step(*final_step); }
+  if(initial_step) { builder_.add_initial_step(*initial_step); }
+  if(step_count) { builder_.add_step_count(*step_count); }
+  builder_.add_control_point_2(control_point_2);
+  builder_.add_control_point_1(control_point_1);
+  builder_.add_base(base);
+  if(is_final_step_single_frame) { builder_.add_is_final_step_single_frame(*is_final_step_single_frame); }
+  if(is_initial_step_single_frame) { builder_.add_is_initial_step_single_frame(*is_initial_step_single_frame); }
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+struct Animation FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef AnimationBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_KIND = 6,
+    VT_TARGET = 8,
+    VT_REFERENCE_PARAMETERS = 10,
+    VT_EXPRESSION = 12,
+    VT_DURATION_TICKS = 14,
+    VT_KEY_FRAMES = 16,
+    VT_INTERPOLATION_COLOR_SPACE = 18
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::AnimationKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::AnimationKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  uint32_t target() const {
+    return GetField<uint32_t>(VT_TARGET, 4294967295);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ReferenceParameter>> *reference_parameters() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ReferenceParameter>> *>(VT_REFERENCE_PARAMETERS);
+  }
+  uint32_t expression() const {
+    return GetField<uint32_t>(VT_EXPRESSION, 4294967295);
+  }
+  int64_t duration_ticks() const {
+    return GetField<int64_t>(VT_DURATION_TICKS, 0);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrame>> *key_frames() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrame>> *>(VT_KEY_FRAMES);
+  }
+  ::flatbuffers::Optional<uint8_t> interpolation_color_space() const {
+    return GetOptional<uint8_t, uint8_t>(VT_INTERPOLATION_COLOR_SPACE);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<uint32_t>(verifier, VT_TARGET, 4) &&
+           VerifyOffset(verifier, VT_REFERENCE_PARAMETERS) &&
+           verifier.VerifyVector(reference_parameters()) &&
+           verifier.VerifyVectorOfTables(reference_parameters()) &&
+           VerifyField<uint32_t>(verifier, VT_EXPRESSION, 4) &&
+           VerifyField<int64_t>(verifier, VT_DURATION_TICKS, 8) &&
+           VerifyOffset(verifier, VT_KEY_FRAMES) &&
+           verifier.VerifyVector(key_frames()) &&
+           verifier.VerifyVectorOfTables(key_frames()) &&
+           VerifyField<uint8_t>(verifier, VT_INTERPOLATION_COLOR_SPACE, 1) &&
+           verifier.EndTable();
+  }
+};
+
+struct AnimationBuilder {
+  typedef Animation Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Animation::VT_BASE, base);
+  }
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::AnimationKind kind) {
+    fbb_.AddElement<uint8_t>(Animation::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_target(uint32_t target) {
+    fbb_.AddElement<uint32_t>(Animation::VT_TARGET, target, 4294967295);
+  }
+  void add_reference_parameters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ReferenceParameter>>> reference_parameters) {
+    fbb_.AddOffset(Animation::VT_REFERENCE_PARAMETERS, reference_parameters);
+  }
+  void add_expression(uint32_t expression) {
+    fbb_.AddElement<uint32_t>(Animation::VT_EXPRESSION, expression, 4294967295);
+  }
+  void add_duration_ticks(int64_t duration_ticks) {
+    fbb_.AddElement<int64_t>(Animation::VT_DURATION_TICKS, duration_ticks, 0);
+  }
+  void add_key_frames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrame>>> key_frames) {
+    fbb_.AddOffset(Animation::VT_KEY_FRAMES, key_frames);
+  }
+  void add_interpolation_color_space(uint8_t interpolation_color_space) {
+    fbb_.AddElement<uint8_t>(Animation::VT_INTERPOLATION_COLOR_SPACE, interpolation_color_space);
+  }
+  explicit AnimationBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Animation> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Animation>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Animation> CreateAnimation(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::AnimationKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::AnimationKind::Scalar,
+    uint32_t target = 4294967295,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ReferenceParameter>>> reference_parameters = 0,
+    uint32_t expression = 4294967295,
+    int64_t duration_ticks = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrame>>> key_frames = 0,
+    ::flatbuffers::Optional<uint8_t> interpolation_color_space = ::flatbuffers::nullopt) {
+  AnimationBuilder builder_(_fbb);
+  builder_.add_duration_ticks(duration_ticks);
+  builder_.add_key_frames(key_frames);
+  builder_.add_expression(expression);
+  builder_.add_reference_parameters(reference_parameters);
+  builder_.add_target(target);
+  builder_.add_base(base);
+  if(interpolation_color_space) { builder_.add_interpolation_color_space(*interpolation_color_space); }
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Animation> CreateAnimationDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::AnimationKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::AnimationKind::Scalar,
+    uint32_t target = 4294967295,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ReferenceParameter>> *reference_parameters = nullptr,
+    uint32_t expression = 4294967295,
+    int64_t duration_ticks = 0,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrame>> *key_frames = nullptr,
+    ::flatbuffers::Optional<uint8_t> interpolation_color_space = ::flatbuffers::nullopt) {
+  auto reference_parameters__ = reference_parameters ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ReferenceParameter>>(*reference_parameters) : 0;
+  auto key_frames__ = key_frames ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::KeyFrame>>(*key_frames) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreateAnimation(
+      _fbb,
+      base,
+      kind,
+      target,
+      reference_parameters__,
+      expression,
+      duration_ticks,
+      key_frames__,
+      interpolation_color_space);
+}
+
+struct PropertySet FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef PropertySetBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_OWNER = 6,
+    VT_VALUES = 8
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  uint32_t owner() const {
+    return GetField<uint32_t>(VT_OWNER, 4294967295);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValue>> *values() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValue>> *>(VT_VALUES);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint32_t>(verifier, VT_OWNER, 4) &&
+           VerifyOffset(verifier, VT_VALUES) &&
+           verifier.VerifyVector(values()) &&
+           verifier.VerifyVectorOfTables(values()) &&
+           verifier.EndTable();
+  }
+};
+
+struct PropertySetBuilder {
+  typedef PropertySet Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(PropertySet::VT_BASE, base);
+  }
+  void add_owner(uint32_t owner) {
+    fbb_.AddElement<uint32_t>(PropertySet::VT_OWNER, owner, 4294967295);
+  }
+  void add_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValue>>> values) {
+    fbb_.AddOffset(PropertySet::VT_VALUES, values);
+  }
+  explicit PropertySetBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<PropertySet> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<PropertySet>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<PropertySet> CreatePropertySet(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    uint32_t owner = 4294967295,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValue>>> values = 0) {
+  PropertySetBuilder builder_(_fbb);
+  builder_.add_values(values);
+  builder_.add_owner(owner);
+  builder_.add_base(base);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<PropertySet> CreatePropertySetDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    uint32_t owner = 4294967295,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValue>> *values = nullptr) {
+  auto values__ = values ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValue>>(*values) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreatePropertySet(
+      _fbb,
+      base,
+      owner,
+      values__);
+}
+
+struct Controller FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ControllerBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4,
+    VT_TARGET_OBJECT = 6,
+    VT_TARGET_PROPERTY = 8,
+    VT_IS_PAUSED = 10,
+    VT_IS_CUSTOM = 12
+  };
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *base() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj *>(VT_BASE);
+  }
+  uint32_t target_object() const {
+    return GetField<uint32_t>(VT_TARGET_OBJECT, 4294967295);
+  }
+  uint32_t target_property() const {
+    return GetField<uint32_t>(VT_TARGET_PROPERTY, 4294967295);
+  }
+  bool is_paused() const {
+    return GetField<uint8_t>(VT_IS_PAUSED, 0) != 0;
+  }
+  bool is_custom() const {
+    return GetField<uint8_t>(VT_IS_CUSTOM, 0) != 0;
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           VerifyField<uint32_t>(verifier, VT_TARGET_OBJECT, 4) &&
+           VerifyField<uint32_t>(verifier, VT_TARGET_PROPERTY, 4) &&
+           VerifyField<uint8_t>(verifier, VT_IS_PAUSED, 1) &&
+           VerifyField<uint8_t>(verifier, VT_IS_CUSTOM, 1) &&
+           verifier.EndTable();
+  }
+};
+
+struct ControllerBuilder {
+  typedef Controller Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base) {
+    fbb_.AddOffset(Controller::VT_BASE, base);
+  }
+  void add_target_object(uint32_t target_object) {
+    fbb_.AddElement<uint32_t>(Controller::VT_TARGET_OBJECT, target_object, 4294967295);
+  }
+  void add_target_property(uint32_t target_property) {
+    fbb_.AddElement<uint32_t>(Controller::VT_TARGET_PROPERTY, target_property, 4294967295);
+  }
+  void add_is_paused(bool is_paused) {
+    fbb_.AddElement<uint8_t>(Controller::VT_IS_PAUSED, static_cast<uint8_t>(is_paused), 0);
+  }
+  void add_is_custom(bool is_custom) {
+    fbb_.AddElement<uint8_t>(Controller::VT_IS_CUSTOM, static_cast<uint8_t>(is_custom), 0);
+  }
+  explicit ControllerBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Controller> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Controller>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Controller> CreateController(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CompObj> base = 0,
+    uint32_t target_object = 4294967295,
+    uint32_t target_property = 4294967295,
+    bool is_paused = false,
+    bool is_custom = false) {
+  ControllerBuilder builder_(_fbb);
+  builder_.add_target_property(target_property);
+  builder_.add_target_object(target_object);
+  builder_.add_base(base);
+  builder_.add_is_custom(is_custom);
+  builder_.add_is_paused(is_paused);
+  return builder_.Finish();
+}
+
+struct PropertyBinding FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef PropertyBindingBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_DISPLAY_NAME = 6,
+    VT_ACTUAL_TYPE = 8,
+    VT_EXPOSED_TYPE = 10,
+    VT_DEFAULT_SCALAR = 12,
+    VT_DEFAULT_VECTOR = 14,
+    VT_DEFAULT_COLOR = 16
+  };
+  uint32_t name() const {
+    return GetField<uint32_t>(VT_NAME, 0);
+  }
+  uint32_t display_name() const {
+    return GetField<uint32_t>(VT_DISPLAY_NAME, 0);
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType actual_type() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType>(GetField<uint8_t>(VT_ACTUAL_TYPE, 0));
+  }
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType exposed_type() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType>(GetField<uint8_t>(VT_EXPOSED_TYPE, 0));
+  }
+  float default_scalar() const {
+    return GetField<float>(VT_DEFAULT_SCALAR, 0.0f);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *default_vector() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *>(VT_DEFAULT_VECTOR);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *default_color() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *>(VT_DEFAULT_COLOR);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
+           VerifyField<uint32_t>(verifier, VT_DISPLAY_NAME, 4) &&
+           VerifyField<uint8_t>(verifier, VT_ACTUAL_TYPE, 1) &&
+           VerifyField<uint8_t>(verifier, VT_EXPOSED_TYPE, 1) &&
+           VerifyField<float>(verifier, VT_DEFAULT_SCALAR, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4>(verifier, VT_DEFAULT_VECTOR, 4) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color>(verifier, VT_DEFAULT_COLOR, 1) &&
+           verifier.EndTable();
+  }
+};
+
+struct PropertyBindingBuilder {
+  typedef PropertyBinding Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(uint32_t name) {
+    fbb_.AddElement<uint32_t>(PropertyBinding::VT_NAME, name, 0);
+  }
+  void add_display_name(uint32_t display_name) {
+    fbb_.AddElement<uint32_t>(PropertyBinding::VT_DISPLAY_NAME, display_name, 0);
+  }
+  void add_actual_type(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType actual_type) {
+    fbb_.AddElement<uint8_t>(PropertyBinding::VT_ACTUAL_TYPE, static_cast<uint8_t>(actual_type), 0);
+  }
+  void add_exposed_type(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType exposed_type) {
+    fbb_.AddElement<uint8_t>(PropertyBinding::VT_EXPOSED_TYPE, static_cast<uint8_t>(exposed_type), 0);
+  }
+  void add_default_scalar(float default_scalar) {
+    fbb_.AddElement<float>(PropertyBinding::VT_DEFAULT_SCALAR, default_scalar, 0.0f);
+  }
+  void add_default_vector(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *default_vector) {
+    fbb_.AddStruct(PropertyBinding::VT_DEFAULT_VECTOR, default_vector);
+  }
+  void add_default_color(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *default_color) {
+    fbb_.AddStruct(PropertyBinding::VT_DEFAULT_COLOR, default_color);
+  }
+  explicit PropertyBindingBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<PropertyBinding> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<PropertyBinding>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<PropertyBinding> CreatePropertyBinding(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t name = 0,
+    uint32_t display_name = 0,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType actual_type = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType::None,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType exposed_type = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValueType::None,
+    float default_scalar = 0.0f,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec4 *default_vector = nullptr,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *default_color = nullptr) {
+  PropertyBindingBuilder builder_(_fbb);
+  builder_.add_default_color(default_color);
+  builder_.add_default_vector(default_vector);
+  builder_.add_default_scalar(default_scalar);
+  builder_.add_display_name(display_name);
+  builder_.add_name(name);
+  builder_.add_exposed_type(exposed_type);
+  builder_.add_actual_type(actual_type);
+  return builder_.Finish();
+}
+
+struct Marker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef MarkerBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_PROGRESS = 6,
+    VT_DURATION_PROGRESS = 8
+  };
+  uint32_t name() const {
+    return GetField<uint32_t>(VT_NAME, 0);
+  }
+  float progress() const {
+    return GetField<float>(VT_PROGRESS, 0.0f);
+  }
+  float duration_progress() const {
+    return GetField<float>(VT_DURATION_PROGRESS, 0.0f);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
+           VerifyField<float>(verifier, VT_PROGRESS, 4) &&
+           VerifyField<float>(verifier, VT_DURATION_PROGRESS, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct MarkerBuilder {
+  typedef Marker Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(uint32_t name) {
+    fbb_.AddElement<uint32_t>(Marker::VT_NAME, name, 0);
+  }
+  void add_progress(float progress) {
+    fbb_.AddElement<float>(Marker::VT_PROGRESS, progress, 0.0f);
+  }
+  void add_duration_progress(float duration_progress) {
+    fbb_.AddElement<float>(Marker::VT_DURATION_PROGRESS, duration_progress, 0.0f);
+  }
+  explicit MarkerBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Marker> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Marker>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Marker> CreateMarker(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t name = 0,
+    float progress = 0.0f,
+    float duration_progress = 0.0f) {
+  MarkerBuilder builder_(_fbb);
+  builder_.add_duration_progress(duration_progress);
+  builder_.add_progress(progress);
+  builder_.add_name(name);
+  return builder_.Finish();
+}
+
+struct Metadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef MetadataBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_WIDTH = 6,
+    VT_HEIGHT = 8,
+    VT_DURATION_TICKS = 10,
+    VT_FRAMES_PER_SECOND = 12,
+    VT_PROPERTY_BINDINGS = 14,
+    VT_MARKERS = 16,
+    VT_THEMING_PROPERTY_SET = 18
+  };
+  uint32_t name() const {
+    return GetField<uint32_t>(VT_NAME, 4294967295);
+  }
+  float width() const {
+    return GetField<float>(VT_WIDTH, 0.0f);
+  }
+  float height() const {
+    return GetField<float>(VT_HEIGHT, 0.0f);
+  }
+  int64_t duration_ticks() const {
+    return GetField<int64_t>(VT_DURATION_TICKS, 0);
+  }
+  float frames_per_second() const {
+    return GetField<float>(VT_FRAMES_PER_SECOND, 0.0f);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyBinding>> *property_bindings() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyBinding>> *>(VT_PROPERTY_BINDINGS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Marker>> *markers() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Marker>> *>(VT_MARKERS);
+  }
+  uint32_t theming_property_set() const {
+    return GetField<uint32_t>(VT_THEMING_PROPERTY_SET, 4294967295);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
+           VerifyField<float>(verifier, VT_WIDTH, 4) &&
+           VerifyField<float>(verifier, VT_HEIGHT, 4) &&
+           VerifyField<int64_t>(verifier, VT_DURATION_TICKS, 8) &&
+           VerifyField<float>(verifier, VT_FRAMES_PER_SECOND, 4) &&
+           VerifyOffset(verifier, VT_PROPERTY_BINDINGS) &&
+           verifier.VerifyVector(property_bindings()) &&
+           verifier.VerifyVectorOfTables(property_bindings()) &&
+           VerifyOffset(verifier, VT_MARKERS) &&
+           verifier.VerifyVector(markers()) &&
+           verifier.VerifyVectorOfTables(markers()) &&
+           VerifyField<uint32_t>(verifier, VT_THEMING_PROPERTY_SET, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct MetadataBuilder {
+  typedef Metadata Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(uint32_t name) {
+    fbb_.AddElement<uint32_t>(Metadata::VT_NAME, name, 4294967295);
+  }
+  void add_width(float width) {
+    fbb_.AddElement<float>(Metadata::VT_WIDTH, width, 0.0f);
+  }
+  void add_height(float height) {
+    fbb_.AddElement<float>(Metadata::VT_HEIGHT, height, 0.0f);
+  }
+  void add_duration_ticks(int64_t duration_ticks) {
+    fbb_.AddElement<int64_t>(Metadata::VT_DURATION_TICKS, duration_ticks, 0);
+  }
+  void add_frames_per_second(float frames_per_second) {
+    fbb_.AddElement<float>(Metadata::VT_FRAMES_PER_SECOND, frames_per_second, 0.0f);
+  }
+  void add_property_bindings(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyBinding>>> property_bindings) {
+    fbb_.AddOffset(Metadata::VT_PROPERTY_BINDINGS, property_bindings);
+  }
+  void add_markers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Marker>>> markers) {
+    fbb_.AddOffset(Metadata::VT_MARKERS, markers);
+  }
+  void add_theming_property_set(uint32_t theming_property_set) {
+    fbb_.AddElement<uint32_t>(Metadata::VT_THEMING_PROPERTY_SET, theming_property_set, 4294967295);
+  }
+  explicit MetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Metadata> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Metadata>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Metadata> CreateMetadata(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t name = 4294967295,
+    float width = 0.0f,
+    float height = 0.0f,
+    int64_t duration_ticks = 0,
+    float frames_per_second = 0.0f,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyBinding>>> property_bindings = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Marker>>> markers = 0,
+    uint32_t theming_property_set = 4294967295) {
+  MetadataBuilder builder_(_fbb);
+  builder_.add_duration_ticks(duration_ticks);
+  builder_.add_theming_property_set(theming_property_set);
+  builder_.add_markers(markers);
+  builder_.add_property_bindings(property_bindings);
+  builder_.add_frames_per_second(frames_per_second);
+  builder_.add_height(height);
+  builder_.add_width(width);
+  builder_.add_name(name);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Metadata> CreateMetadataDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t name = 4294967295,
+    float width = 0.0f,
+    float height = 0.0f,
+    int64_t duration_ticks = 0,
+    float frames_per_second = 0.0f,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyBinding>> *property_bindings = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Marker>> *markers = nullptr,
+    uint32_t theming_property_set = 4294967295) {
+  auto property_bindings__ = property_bindings ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyBinding>>(*property_bindings) : 0;
+  auto markers__ = markers ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Marker>>(*markers) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreateMetadata(
+      _fbb,
+      name,
+      width,
+      height,
+      duration_ticks,
+      frames_per_second,
+      property_bindings__,
+      markers__,
+      theming_property_set);
+}
+
+struct LottieComposition FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef LottieCompositionBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_SCHEMA_VERSION = 4,
+    VT_REQUIRED_UAP_VERSION = 6,
+    VT_METADATA = 8,
+    VT_ROOT_VISUAL = 10,
+    VT_STRINGS = 12,
+    VT_VISUALS = 14,
+    VT_SHAPES = 16,
+    VT_GEOMETRIES = 18,
+    VT_CANVAS_GEOMETRIES = 20,
+    VT_BRUSHES = 22,
+    VT_GRADIENT_STOPS = 24,
+    VT_VIEW_BOXES = 26,
+    VT_CLIPS = 28,
+    VT_SHADOWS = 30,
+    VT_SURFACES = 32,
+    VT_EFFECTS = 34,
+    VT_EASINGS = 36,
+    VT_ANIMATIONS = 38,
+    VT_PROPERTY_SETS = 40,
+    VT_CONTROLLERS = 42,
+    VT_CUSTOM_CONTROLLERS = 44
+  };
+  uint16_t schema_version() const {
+    return GetField<uint16_t>(VT_SCHEMA_VERSION, 0);
+  }
+  uint16_t required_uap_version() const {
+    return GetField<uint16_t>(VT_REQUIRED_UAP_VERSION, 0);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Metadata *metadata() const {
+    return GetPointer<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Metadata *>(VT_METADATA);
+  }
+  uint32_t root_visual() const {
+    return GetField<uint32_t>(VT_ROOT_VISUAL, 4294967295);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *strings() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_STRINGS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Visual>> *visuals() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Visual>> *>(VT_VISUALS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shape>> *shapes() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shape>> *>(VT_SHAPES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Geometry>> *geometries() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Geometry>> *>(VT_GEOMETRIES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometry>> *canvas_geometries() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometry>> *>(VT_CANVAS_GEOMETRIES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Brush>> *brushes() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Brush>> *>(VT_BRUSHES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GradientStop>> *gradient_stops() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GradientStop>> *>(VT_GRADIENT_STOPS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ViewBox>> *view_boxes() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ViewBox>> *>(VT_VIEW_BOXES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Clip>> *clips() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Clip>> *>(VT_CLIPS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shadow>> *shadows() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shadow>> *>(VT_SHADOWS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Surface>> *surfaces() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Surface>> *>(VT_SURFACES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Effect>> *effects() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Effect>> *>(VT_EFFECTS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Easing>> *easings() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Easing>> *>(VT_EASINGS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animation>> *animations() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animation>> *>(VT_ANIMATIONS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertySet>> *property_sets() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertySet>> *>(VT_PROPERTY_SETS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Controller>> *controllers() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Controller>> *>(VT_CONTROLLERS);
+  }
+  const ::flatbuffers::Vector<uint32_t> *custom_controllers() const {
+    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_CUSTOM_CONTROLLERS);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint16_t>(verifier, VT_SCHEMA_VERSION, 2) &&
+           VerifyField<uint16_t>(verifier, VT_REQUIRED_UAP_VERSION, 2) &&
+           VerifyOffset(verifier, VT_METADATA) &&
+           verifier.VerifyTable(metadata()) &&
+           VerifyField<uint32_t>(verifier, VT_ROOT_VISUAL, 4) &&
+           VerifyOffset(verifier, VT_STRINGS) &&
+           verifier.VerifyVector(strings()) &&
+           verifier.VerifyVectorOfStrings(strings()) &&
+           VerifyOffset(verifier, VT_VISUALS) &&
+           verifier.VerifyVector(visuals()) &&
+           verifier.VerifyVectorOfTables(visuals()) &&
+           VerifyOffset(verifier, VT_SHAPES) &&
+           verifier.VerifyVector(shapes()) &&
+           verifier.VerifyVectorOfTables(shapes()) &&
+           VerifyOffset(verifier, VT_GEOMETRIES) &&
+           verifier.VerifyVector(geometries()) &&
+           verifier.VerifyVectorOfTables(geometries()) &&
+           VerifyOffset(verifier, VT_CANVAS_GEOMETRIES) &&
+           verifier.VerifyVector(canvas_geometries()) &&
+           verifier.VerifyVectorOfTables(canvas_geometries()) &&
+           VerifyOffset(verifier, VT_BRUSHES) &&
+           verifier.VerifyVector(brushes()) &&
+           verifier.VerifyVectorOfTables(brushes()) &&
+           VerifyOffset(verifier, VT_GRADIENT_STOPS) &&
+           verifier.VerifyVector(gradient_stops()) &&
+           verifier.VerifyVectorOfTables(gradient_stops()) &&
+           VerifyOffset(verifier, VT_VIEW_BOXES) &&
+           verifier.VerifyVector(view_boxes()) &&
+           verifier.VerifyVectorOfTables(view_boxes()) &&
+           VerifyOffset(verifier, VT_CLIPS) &&
+           verifier.VerifyVector(clips()) &&
+           verifier.VerifyVectorOfTables(clips()) &&
+           VerifyOffset(verifier, VT_SHADOWS) &&
+           verifier.VerifyVector(shadows()) &&
+           verifier.VerifyVectorOfTables(shadows()) &&
+           VerifyOffset(verifier, VT_SURFACES) &&
+           verifier.VerifyVector(surfaces()) &&
+           verifier.VerifyVectorOfTables(surfaces()) &&
+           VerifyOffset(verifier, VT_EFFECTS) &&
+           verifier.VerifyVector(effects()) &&
+           verifier.VerifyVectorOfTables(effects()) &&
+           VerifyOffset(verifier, VT_EASINGS) &&
+           verifier.VerifyVector(easings()) &&
+           verifier.VerifyVectorOfTables(easings()) &&
+           VerifyOffset(verifier, VT_ANIMATIONS) &&
+           verifier.VerifyVector(animations()) &&
+           verifier.VerifyVectorOfTables(animations()) &&
+           VerifyOffset(verifier, VT_PROPERTY_SETS) &&
+           verifier.VerifyVector(property_sets()) &&
+           verifier.VerifyVectorOfTables(property_sets()) &&
+           VerifyOffset(verifier, VT_CONTROLLERS) &&
+           verifier.VerifyVector(controllers()) &&
+           verifier.VerifyVectorOfTables(controllers()) &&
+           VerifyOffset(verifier, VT_CUSTOM_CONTROLLERS) &&
+           verifier.VerifyVector(custom_controllers()) &&
+           verifier.EndTable();
+  }
+};
+
+struct LottieCompositionBuilder {
+  typedef LottieComposition Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_schema_version(uint16_t schema_version) {
+    fbb_.AddElement<uint16_t>(LottieComposition::VT_SCHEMA_VERSION, schema_version, 0);
+  }
+  void add_required_uap_version(uint16_t required_uap_version) {
+    fbb_.AddElement<uint16_t>(LottieComposition::VT_REQUIRED_UAP_VERSION, required_uap_version, 0);
+  }
+  void add_metadata(::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Metadata> metadata) {
+    fbb_.AddOffset(LottieComposition::VT_METADATA, metadata);
+  }
+  void add_root_visual(uint32_t root_visual) {
+    fbb_.AddElement<uint32_t>(LottieComposition::VT_ROOT_VISUAL, root_visual, 4294967295);
+  }
+  void add_strings(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> strings) {
+    fbb_.AddOffset(LottieComposition::VT_STRINGS, strings);
+  }
+  void add_visuals(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Visual>>> visuals) {
+    fbb_.AddOffset(LottieComposition::VT_VISUALS, visuals);
+  }
+  void add_shapes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shape>>> shapes) {
+    fbb_.AddOffset(LottieComposition::VT_SHAPES, shapes);
+  }
+  void add_geometries(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Geometry>>> geometries) {
+    fbb_.AddOffset(LottieComposition::VT_GEOMETRIES, geometries);
+  }
+  void add_canvas_geometries(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometry>>> canvas_geometries) {
+    fbb_.AddOffset(LottieComposition::VT_CANVAS_GEOMETRIES, canvas_geometries);
+  }
+  void add_brushes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Brush>>> brushes) {
+    fbb_.AddOffset(LottieComposition::VT_BRUSHES, brushes);
+  }
+  void add_gradient_stops(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GradientStop>>> gradient_stops) {
+    fbb_.AddOffset(LottieComposition::VT_GRADIENT_STOPS, gradient_stops);
+  }
+  void add_view_boxes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ViewBox>>> view_boxes) {
+    fbb_.AddOffset(LottieComposition::VT_VIEW_BOXES, view_boxes);
+  }
+  void add_clips(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Clip>>> clips) {
+    fbb_.AddOffset(LottieComposition::VT_CLIPS, clips);
+  }
+  void add_shadows(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shadow>>> shadows) {
+    fbb_.AddOffset(LottieComposition::VT_SHADOWS, shadows);
+  }
+  void add_surfaces(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Surface>>> surfaces) {
+    fbb_.AddOffset(LottieComposition::VT_SURFACES, surfaces);
+  }
+  void add_effects(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Effect>>> effects) {
+    fbb_.AddOffset(LottieComposition::VT_EFFECTS, effects);
+  }
+  void add_easings(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Easing>>> easings) {
+    fbb_.AddOffset(LottieComposition::VT_EASINGS, easings);
+  }
+  void add_animations(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animation>>> animations) {
+    fbb_.AddOffset(LottieComposition::VT_ANIMATIONS, animations);
+  }
+  void add_property_sets(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertySet>>> property_sets) {
+    fbb_.AddOffset(LottieComposition::VT_PROPERTY_SETS, property_sets);
+  }
+  void add_controllers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Controller>>> controllers) {
+    fbb_.AddOffset(LottieComposition::VT_CONTROLLERS, controllers);
+  }
+  void add_custom_controllers(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> custom_controllers) {
+    fbb_.AddOffset(LottieComposition::VT_CUSTOM_CONTROLLERS, custom_controllers);
+  }
+  explicit LottieCompositionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<LottieComposition> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<LottieComposition>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<LottieComposition> CreateLottieComposition(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint16_t schema_version = 0,
+    uint16_t required_uap_version = 0,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Metadata> metadata = 0,
+    uint32_t root_visual = 4294967295,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> strings = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Visual>>> visuals = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shape>>> shapes = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Geometry>>> geometries = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometry>>> canvas_geometries = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Brush>>> brushes = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GradientStop>>> gradient_stops = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ViewBox>>> view_boxes = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Clip>>> clips = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shadow>>> shadows = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Surface>>> surfaces = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Effect>>> effects = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Easing>>> easings = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animation>>> animations = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertySet>>> property_sets = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Controller>>> controllers = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> custom_controllers = 0) {
+  LottieCompositionBuilder builder_(_fbb);
+  builder_.add_custom_controllers(custom_controllers);
+  builder_.add_controllers(controllers);
+  builder_.add_property_sets(property_sets);
+  builder_.add_animations(animations);
+  builder_.add_easings(easings);
+  builder_.add_effects(effects);
+  builder_.add_surfaces(surfaces);
+  builder_.add_shadows(shadows);
+  builder_.add_clips(clips);
+  builder_.add_view_boxes(view_boxes);
+  builder_.add_gradient_stops(gradient_stops);
+  builder_.add_brushes(brushes);
+  builder_.add_canvas_geometries(canvas_geometries);
+  builder_.add_geometries(geometries);
+  builder_.add_shapes(shapes);
+  builder_.add_visuals(visuals);
+  builder_.add_strings(strings);
+  builder_.add_root_visual(root_visual);
+  builder_.add_metadata(metadata);
+  builder_.add_required_uap_version(required_uap_version);
+  builder_.add_schema_version(schema_version);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<LottieComposition> CreateLottieCompositionDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint16_t schema_version = 0,
+    uint16_t required_uap_version = 0,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Metadata> metadata = 0,
+    uint32_t root_visual = 4294967295,
+    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *strings = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Visual>> *visuals = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shape>> *shapes = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Geometry>> *geometries = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometry>> *canvas_geometries = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Brush>> *brushes = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GradientStop>> *gradient_stops = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ViewBox>> *view_boxes = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Clip>> *clips = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shadow>> *shadows = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Surface>> *surfaces = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Effect>> *effects = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Easing>> *easings = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animation>> *animations = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertySet>> *property_sets = nullptr,
+    const std::vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Controller>> *controllers = nullptr,
+    const std::vector<uint32_t> *custom_controllers = nullptr) {
+  auto strings__ = strings ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*strings) : 0;
+  auto visuals__ = visuals ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Visual>>(*visuals) : 0;
+  auto shapes__ = shapes ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shape>>(*shapes) : 0;
+  auto geometries__ = geometries ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Geometry>>(*geometries) : 0;
+  auto canvas_geometries__ = canvas_geometries ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometry>>(*canvas_geometries) : 0;
+  auto brushes__ = brushes ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Brush>>(*brushes) : 0;
+  auto gradient_stops__ = gradient_stops ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::GradientStop>>(*gradient_stops) : 0;
+  auto view_boxes__ = view_boxes ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::ViewBox>>(*view_boxes) : 0;
+  auto clips__ = clips ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Clip>>(*clips) : 0;
+  auto shadows__ = shadows ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Shadow>>(*shadows) : 0;
+  auto surfaces__ = surfaces ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Surface>>(*surfaces) : 0;
+  auto effects__ = effects ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Effect>>(*effects) : 0;
+  auto easings__ = easings ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Easing>>(*easings) : 0;
+  auto animations__ = animations ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Animation>>(*animations) : 0;
+  auto property_sets__ = property_sets ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertySet>>(*property_sets) : 0;
+  auto controllers__ = controllers ? _fbb.CreateVector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Controller>>(*controllers) : 0;
+  auto custom_controllers__ = custom_controllers ? _fbb.CreateVector<uint32_t>(*custom_controllers) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreateLottieComposition(
+      _fbb,
+      schema_version,
+      required_uap_version,
+      metadata,
+      root_visual,
+      strings__,
+      visuals__,
+      shapes__,
+      geometries__,
+      canvas_geometries__,
+      brushes__,
+      gradient_stops__,
+      view_boxes__,
+      clips__,
+      shadows__,
+      surfaces__,
+      effects__,
+      easings__,
+      animations__,
+      property_sets__,
+      controllers__,
+      custom_controllers__);
+}
+
+struct CanvasGeometry FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef CanvasGeometryBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_KIND = 4,
+    VT_A = 6,
+    VT_B = 8,
+    VT_COMBINE_MODE = 10,
+    VT_MATRIX = 12,
+    VT_SOURCE = 14,
+    VT_GEOMETRIES = 16,
+    VT_FILL_RULE = 18,
+    VT_OPS = 20,
+    VT_OPERANDS = 22,
+    VT_X = 24,
+    VT_Y = 26,
+    VT_W = 28,
+    VT_H = 30,
+    VT_RADIUS_X = 32,
+    VT_RADIUS_Y = 34
+  };
+  CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometryKind kind() const {
+    return static_cast<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometryKind>(GetField<uint8_t>(VT_KIND, 0));
+  }
+  uint32_t a() const {
+    return GetField<uint32_t>(VT_A, 4294967295);
+  }
+  uint32_t b() const {
+    return GetField<uint32_t>(VT_B, 4294967295);
+  }
+  uint8_t combine_mode() const {
+    return GetField<uint8_t>(VT_COMBINE_MODE, 0);
+  }
+  const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *matrix() const {
+    return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *>(VT_MATRIX);
+  }
+  uint32_t source() const {
+    return GetField<uint32_t>(VT_SOURCE, 4294967295);
+  }
+  const ::flatbuffers::Vector<uint32_t> *geometries() const {
+    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_GEOMETRIES);
+  }
+  uint8_t fill_rule() const {
+    return GetField<uint8_t>(VT_FILL_RULE, 0);
+  }
+  const ::flatbuffers::Vector<uint8_t> *ops() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_OPS);
+  }
+  const ::flatbuffers::Vector<float> *operands() const {
+    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_OPERANDS);
+  }
+  float x() const {
+    return GetField<float>(VT_X, 0.0f);
+  }
+  float y() const {
+    return GetField<float>(VT_Y, 0.0f);
+  }
+  float w() const {
+    return GetField<float>(VT_W, 0.0f);
+  }
+  float h() const {
+    return GetField<float>(VT_H, 0.0f);
+  }
+  float radius_x() const {
+    return GetField<float>(VT_RADIUS_X, 0.0f);
+  }
+  float radius_y() const {
+    return GetField<float>(VT_RADIUS_Y, 0.0f);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
+           VerifyField<uint32_t>(verifier, VT_A, 4) &&
+           VerifyField<uint32_t>(verifier, VT_B, 4) &&
+           VerifyField<uint8_t>(verifier, VT_COMBINE_MODE, 1) &&
+           VerifyField<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2>(verifier, VT_MATRIX, 4) &&
+           VerifyField<uint32_t>(verifier, VT_SOURCE, 4) &&
+           VerifyOffset(verifier, VT_GEOMETRIES) &&
+           verifier.VerifyVector(geometries()) &&
+           VerifyField<uint8_t>(verifier, VT_FILL_RULE, 1) &&
+           VerifyOffset(verifier, VT_OPS) &&
+           verifier.VerifyVector(ops()) &&
+           VerifyOffset(verifier, VT_OPERANDS) &&
+           verifier.VerifyVector(operands()) &&
+           VerifyField<float>(verifier, VT_X, 4) &&
+           VerifyField<float>(verifier, VT_Y, 4) &&
+           VerifyField<float>(verifier, VT_W, 4) &&
+           VerifyField<float>(verifier, VT_H, 4) &&
+           VerifyField<float>(verifier, VT_RADIUS_X, 4) &&
+           VerifyField<float>(verifier, VT_RADIUS_Y, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct CanvasGeometryBuilder {
+  typedef CanvasGeometry Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_kind(CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometryKind kind) {
+    fbb_.AddElement<uint8_t>(CanvasGeometry::VT_KIND, static_cast<uint8_t>(kind), 0);
+  }
+  void add_a(uint32_t a) {
+    fbb_.AddElement<uint32_t>(CanvasGeometry::VT_A, a, 4294967295);
+  }
+  void add_b(uint32_t b) {
+    fbb_.AddElement<uint32_t>(CanvasGeometry::VT_B, b, 4294967295);
+  }
+  void add_combine_mode(uint8_t combine_mode) {
+    fbb_.AddElement<uint8_t>(CanvasGeometry::VT_COMBINE_MODE, combine_mode, 0);
+  }
+  void add_matrix(const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *matrix) {
+    fbb_.AddStruct(CanvasGeometry::VT_MATRIX, matrix);
+  }
+  void add_source(uint32_t source) {
+    fbb_.AddElement<uint32_t>(CanvasGeometry::VT_SOURCE, source, 4294967295);
+  }
+  void add_geometries(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> geometries) {
+    fbb_.AddOffset(CanvasGeometry::VT_GEOMETRIES, geometries);
+  }
+  void add_fill_rule(uint8_t fill_rule) {
+    fbb_.AddElement<uint8_t>(CanvasGeometry::VT_FILL_RULE, fill_rule, 0);
+  }
+  void add_ops(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> ops) {
+    fbb_.AddOffset(CanvasGeometry::VT_OPS, ops);
+  }
+  void add_operands(::flatbuffers::Offset<::flatbuffers::Vector<float>> operands) {
+    fbb_.AddOffset(CanvasGeometry::VT_OPERANDS, operands);
+  }
+  void add_x(float x) {
+    fbb_.AddElement<float>(CanvasGeometry::VT_X, x, 0.0f);
+  }
+  void add_y(float y) {
+    fbb_.AddElement<float>(CanvasGeometry::VT_Y, y, 0.0f);
+  }
+  void add_w(float w) {
+    fbb_.AddElement<float>(CanvasGeometry::VT_W, w, 0.0f);
+  }
+  void add_h(float h) {
+    fbb_.AddElement<float>(CanvasGeometry::VT_H, h, 0.0f);
+  }
+  void add_radius_x(float radius_x) {
+    fbb_.AddElement<float>(CanvasGeometry::VT_RADIUS_X, radius_x, 0.0f);
+  }
+  void add_radius_y(float radius_y) {
+    fbb_.AddElement<float>(CanvasGeometry::VT_RADIUS_Y, radius_y, 0.0f);
+  }
+  explicit CanvasGeometryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<CanvasGeometry> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<CanvasGeometry>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<CanvasGeometry> CreateCanvasGeometry(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometryKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometryKind::Combination,
+    uint32_t a = 4294967295,
+    uint32_t b = 4294967295,
+    uint8_t combine_mode = 0,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *matrix = nullptr,
+    uint32_t source = 4294967295,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> geometries = 0,
+    uint8_t fill_rule = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> ops = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<float>> operands = 0,
+    float x = 0.0f,
+    float y = 0.0f,
+    float w = 0.0f,
+    float h = 0.0f,
+    float radius_x = 0.0f,
+    float radius_y = 0.0f) {
+  CanvasGeometryBuilder builder_(_fbb);
+  builder_.add_radius_y(radius_y);
+  builder_.add_radius_x(radius_x);
+  builder_.add_h(h);
+  builder_.add_w(w);
+  builder_.add_y(y);
+  builder_.add_x(x);
+  builder_.add_operands(operands);
+  builder_.add_ops(ops);
+  builder_.add_geometries(geometries);
+  builder_.add_source(source);
+  builder_.add_matrix(matrix);
+  builder_.add_b(b);
+  builder_.add_a(a);
+  builder_.add_fill_rule(fill_rule);
+  builder_.add_combine_mode(combine_mode);
+  builder_.add_kind(kind);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<CanvasGeometry> CreateCanvasGeometryDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometryKind kind = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CanvasGeometryKind::Combination,
+    uint32_t a = 4294967295,
+    uint32_t b = 4294967295,
+    uint8_t combine_mode = 0,
+    const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Mat3x2 *matrix = nullptr,
+    uint32_t source = 4294967295,
+    const std::vector<uint32_t> *geometries = nullptr,
+    uint8_t fill_rule = 0,
+    const std::vector<uint8_t> *ops = nullptr,
+    const std::vector<float> *operands = nullptr,
+    float x = 0.0f,
+    float y = 0.0f,
+    float w = 0.0f,
+    float h = 0.0f,
+    float radius_x = 0.0f,
+    float radius_y = 0.0f) {
+  auto geometries__ = geometries ? _fbb.CreateVector<uint32_t>(*geometries) : 0;
+  auto ops__ = ops ? _fbb.CreateVector<uint8_t>(*ops) : 0;
+  auto operands__ = operands ? _fbb.CreateVector<float>(*operands) : 0;
+  return CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::CreateCanvasGeometry(
+      _fbb,
+      kind,
+      a,
+      b,
+      combine_mode,
+      matrix,
+      source,
+      geometries__,
+      fill_rule,
+      ops__,
+      operands__,
+      x,
+      y,
+      w,
+      h,
+      radius_x,
+      radius_y);
+}
+
+inline const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition *GetLottieComposition(const void *buf) {
+  return ::flatbuffers::GetRoot<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(buf);
+}
+
+inline const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition *GetSizePrefixedLottieComposition(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(buf);
+}
+
+inline const char *LottieCompositionIdentifier() {
+  return "LCMP";
+}
+
+inline bool LottieCompositionBufferHasIdentifier(const void *buf) {
+  return ::flatbuffers::BufferHasIdentifier(
+      buf, LottieCompositionIdentifier());
+}
+
+inline bool SizePrefixedLottieCompositionBufferHasIdentifier(const void *buf) {
+  return ::flatbuffers::BufferHasIdentifier(
+      buf, LottieCompositionIdentifier(), true);
+}
+
+inline bool VerifyLottieCompositionBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(LottieCompositionIdentifier());
+}
+
+inline bool VerifySizePrefixedLottieCompositionBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(LottieCompositionIdentifier());
+}
+
+inline const char *LottieCompositionExtension() {
+  return "lcomp";
+}
+
+inline void FinishLottieCompositionBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition> root) {
+  fbb.Finish(root, LottieCompositionIdentifier());
+}
+
+inline void FinishSizePrefixedLottieCompositionBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition> root) {
+  fbb.FinishSizePrefixed(root, LottieCompositionIdentifier());
+}
+
+}  // namespace Schema
+}  // namespace CompDataFlatbuffer
+}  // namespace Lottie
+}  // namespace WinUI
+}  // namespace CommunityToolkit
+
+#endif  // FLATBUFFERS_GENERATED_LOTTIECOMP_COMMUNITYTOOLKIT_WINUI_LOTTIE_COMPDATAFLATBUFFER_SCHEMA_H_
diff --git a/dlls/LottieRuntime/LottieRuntime.cpp b/dlls/LottieRuntime/LottieRuntime.cpp
new file mode 100644
index 00000000..b8368738
--- /dev/null
+++ b/dlls/LottieRuntime/LottieRuntime.cpp
@@ -0,0 +1,2014 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// A runtime interpreter for serialized Lottie compositions.
+//
+// This is the native counterpart of Instantiator.cs. It walks the FlatBuffer produced
+// by CompositionSerializer and issues the same sequence of Compositor calls that the
+// managed instantiator and the generated code issue, so the three produce the same
+// visual tree.
+//
+// Three things shape the code:
+//
+//  * Size first. There is one function per node category rather than one per node
+//    type, and the shared state of every node is applied by a single function that
+//    takes the least derived type. Everything lives in one translation unit so that
+//    the linker can discard what an application does not reach.
+//
+//  * Runtime cost second. Every node is realized at most once and is then found by
+//    indexing an array, never by hashing. The buffer is read in place; nothing is
+//    copied out of it.
+//
+//  * Transient memory third. The only allocations are the realization caches, which
+//    are exactly as large as the node vectors in the buffer, and the D2D geometries,
+//    which are released as soon as they have been handed to a CompositionPath.
+//
+// Calls are made through the least derived interface that has the member being used.
+// A node is only ever known by its concrete type inside the function that creates it;
+// everywhere else it is held as Visual, CompositionShape, CompositionBrush and so on.
+// That is what keeps the interpreter free of casts: there is no point at which it has
+// to ask what a node actually is, because the buffer already said, and the answer was
+// consumed at the moment of creation.
+
+#include "LottieRuntime.h"
+
+#include <cstdint>
+#include <cstring>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <d2d1_1.h>
+#include <windows.graphics.effects.interop.h>
+#include <Windows.Graphics.Interop.h>
+
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Foundation.Collections.h>
+#include <winrt/Windows.Foundation.Numerics.h>
+#include <winrt/Windows.Graphics.Effects.h>
+#include <winrt/Windows.UI.h>
+#include <winrt/Windows.UI.Composition.h>
+
+#include "Generated/lottie_comp_generated.h"
+
+namespace Fb = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema;
+
+using namespace winrt::Windows::Foundation::Numerics;
+using namespace winrt::Windows::UI::Composition;
+
+namespace
+{
+    // The index that the format uses for "no node". It is the same value in every
+    // field that can hold an index.
+    constexpr uint32_t NullIndex = 0xFFFFFFFFu;
+
+    // The schema version this build understands. A buffer that declares a higher
+    // version is rejected, because it may use fields that are not read here.
+    constexpr uint16_t SupportedSchemaVersion = 1;
+
+    // Object references that can point at more than one category pack the category
+    // into the top four bits.
+    constexpr uint32_t CategoryShift = 28;
+    constexpr uint32_t IndexMask = (1u << CategoryShift) - 1u;
+
+    [[noreturn]] void ThrowMalformed()
+    {
+        throw winrt::hresult_invalid_argument(L"The buffer is not a well formed Lottie composition.");
+    }
+
+    [[noreturn]] void ThrowUnsupported()
+    {
+        throw winrt::hresult_not_implemented(L"The composition uses a feature this build does not support.");
+    }
+
+    void Check(bool condition)
+    {
+        if (!condition)
+        {
+            ThrowMalformed();
+        }
+    }
+
+    // Reads an entry from one of the buffer's node vectors. A vector that is absent
+    // is treated as empty, so an index into it is out of range rather than a crash.
+    template<typename T>
+    T const* At(::flatbuffers::Vector<::flatbuffers::Offset<T>> const* vector, uint32_t index)
+    {
+        Check(vector != nullptr && index < vector->size());
+        auto const* result = vector->Get(index);
+        Check(result != nullptr);
+        return result;
+    }
+
+    float3 ToFloat3(Fb::Vec3 const* value)
+    {
+        return { value->x(), value->y(), value->z() };
+    }
+
+    float2 ToFloat2(Fb::Vec2 const* value)
+    {
+        return { value->x(), value->y() };
+    }
+
+    float3x2 ToFloat3x2(Fb::Mat3x2 const* value)
+    {
+        return {
+            value->m11(), value->m12(),
+            value->m21(), value->m22(),
+            value->m31(), value->m32(),
+        };
+    }
+
+    float4x4 ToFloat4x4(Fb::Mat4x4 const* value)
+    {
+        return {
+            value->m11(), value->m12(), value->m13(), value->m14(),
+            value->m21(), value->m22(), value->m23(), value->m24(),
+            value->m31(), value->m32(), value->m33(), value->m34(),
+            value->m41(), value->m42(), value->m43(), value->m44(),
+        };
+    }
+
+    winrt::Windows::UI::Color ToColor(Fb::Color const* value)
+    {
+        if (value == nullptr)
+        {
+            return { 0, 0, 0, 0 };
+        }
+
+        return { value->a(), value->r(), value->g(), value->b() };
+    }
+
+    // CanvasGeometryCombine and D2D1_COMBINE_MODE do not agree on the order of their
+    // members, so the value from the buffer cannot simply be cast.
+    D2D1_COMBINE_MODE ToCombineMode(uint8_t value)
+    {
+        switch (value)
+        {
+        case 0: return D2D1_COMBINE_MODE_UNION;
+        case 1: return D2D1_COMBINE_MODE_EXCLUDE;
+        case 2: return D2D1_COMBINE_MODE_INTERSECT;
+        case 3: return D2D1_COMBINE_MODE_XOR;
+        default: ThrowMalformed();
+        }
+    }
+
+    // ---------------------------------------------------------------------------
+    // Geometry.
+    //
+    // A CompositionPath is built from anything that implements IGeometrySource2D,
+    // and the only way to give one real content is the interop interface that hands
+    // out a D2D geometry. This is the smallest object that does that.
+    // ---------------------------------------------------------------------------
+    struct GeometrySource : winrt::implements<
+        GeometrySource,
+        winrt::Windows::Graphics::IGeometrySource2D,
+        ABI::Windows::Graphics::IGeometrySource2DInterop>
+    {
+        explicit GeometrySource(winrt::com_ptr<ID2D1Geometry> geometry) :
+            m_geometry(std::move(geometry))
+        {
+        }
+
+        IFACEMETHODIMP GetGeometry(ID2D1Geometry** value) noexcept
+        {
+            m_geometry.copy_to(value);
+            return S_OK;
+        }
+
+        IFACEMETHODIMP TryGetGeometryUsingFactory(ID2D1Factory*, ID2D1Geometry** value) noexcept
+        {
+            // The geometry is device independent and was made by this component's own
+            // factory, so there is nothing useful to return for another factory.
+            *value = nullptr;
+            return E_NOTIMPL;
+        }
+
+    private:
+        winrt::com_ptr<ID2D1Geometry> m_geometry;
+    };
+
+    ID2D1Factory* D2DFactory()
+    {
+        // One factory for the lifetime of the process. The geometries it makes are
+        // device independent, so nothing here depends on a device and the factory
+        // never has to be recreated.
+        static ID2D1Factory* const factory = []
+        {
+            ID2D1Factory* result = nullptr;
+            winrt::check_hresult(D2D1CreateFactory(D2D1_FACTORY_TYPE_MULTI_THREADED, &result));
+            return result;
+        }();
+
+        return factory;
+    }
+
+    // ---------------------------------------------------------------------------
+    // Effects.
+    //
+    // Windows.UI.Composition accepts any IGraphicsEffect that also implements the
+    // D2D interop interface, which is how it learns which D2D effect to instantiate
+    // and what to set on it. Implementing that directly avoids taking a dependency
+    // on Win2D for the two effects the translator emits.
+    // ---------------------------------------------------------------------------
+    struct Effect : winrt::implements<
+        Effect,
+        winrt::Windows::Graphics::Effects::IGraphicsEffect,
+        winrt::Windows::Graphics::Effects::IGraphicsEffectSource,
+        ABI::Windows::Graphics::Effects::IGraphicsEffectD2D1Interop>
+    {
+        // Both effects the translator emits have exactly one property, and in both
+        // cases it is property zero, so one class covers both and there is no need
+        // for a property table.
+        Effect(GUID const& id, winrt::Windows::Foundation::IInspectable property) :
+            m_id(id),
+            m_property(std::move(property))
+        {
+        }
+
+        winrt::hstring Name() const noexcept
+        {
+            return m_name;
+        }
+
+        void Name(winrt::hstring const& value)
+        {
+            m_name = value;
+        }
+
+        void AddSource(winrt::Windows::Graphics::Effects::IGraphicsEffectSource const& source)
+        {
+            m_sources.push_back(source);
+        }
+
+        IFACEMETHODIMP GetEffectId(GUID* id) noexcept
+        {
+            *id = m_id;
+            return S_OK;
+        }
+
+        IFACEMETHODIMP GetPropertyCount(UINT* count) noexcept
+        {
+            *count = 1;
+            return S_OK;
+        }
+
+        IFACEMETHODIMP GetProperty(UINT index, ABI::Windows::Foundation::IPropertyValue** value) noexcept
+        {
+            *value = nullptr;
+
+            if (index != 0)
+            {
+                return E_BOUNDS;
+            }
+
+            return m_property.as<winrt::Windows::Foundation::IPropertyValue>()
+                ->QueryInterface(__uuidof(ABI::Windows::Foundation::IPropertyValue), reinterpret_cast<void**>(value));
+        }
+
+        IFACEMETHODIMP GetSourceCount(UINT* count) noexcept
+        {
+            *count = static_cast<UINT>(m_sources.size());
+            return S_OK;
+        }
+
+        IFACEMETHODIMP GetSource(UINT index, ABI::Windows::Graphics::Effects::IGraphicsEffectSource** source) noexcept
+        {
+            *source = nullptr;
+
+            if (index >= m_sources.size())
+            {
+                return E_BOUNDS;
+            }
+
+            auto value = m_sources[index];
+            *source = reinterpret_cast<ABI::Windows::Graphics::Effects::IGraphicsEffectSource*>(
+                winrt::detach_abi(value));
+            return S_OK;
+        }
+
+        IFACEMETHODIMP GetNamedPropertyMapping(
+            LPCWSTR,
+            UINT*,
+            ABI::Windows::Graphics::Effects::GRAPHICS_EFFECT_PROPERTY_MAPPING*) noexcept
+        {
+            // Nothing animates an effect property by name, so there is nothing to map.
+            return E_INVALIDARG;
+        }
+
+    private:
+        GUID m_id;
+        winrt::Windows::Foundation::IInspectable m_property;
+        winrt::hstring m_name;
+        std::vector<winrt::Windows::Graphics::Effects::IGraphicsEffectSource> m_sources;
+    };
+}
+
+namespace
+{
+    // ---------------------------------------------------------------------------
+    // The interpreter.
+    //
+    // One instance exists for the duration of one call to LoadComposition. It owns
+    // the realization caches, which is the only state the walk needs: every other
+    // question is answered by the buffer.
+    // ---------------------------------------------------------------------------
+    class Interpreter
+    {
+    public:
+        Interpreter(Compositor const& compositor, Fb::LottieComposition const& root) :
+            m_compositor(compositor),
+            m_root(root),
+            m_visuals(Count(root.visuals())),
+            m_shapes(Count(root.shapes())),
+            m_geometries(Count(root.geometries())),
+            m_paths(Count(root.canvas_geometries())),
+            m_brushes(Count(root.brushes())),
+            m_gradientStops(Count(root.gradient_stops())),
+            m_viewBoxes(Count(root.view_boxes())),
+            m_clips(Count(root.clips())),
+            m_shadows(Count(root.shadows())),
+            m_surfaces(Count(root.surfaces())),
+            m_effects(Count(root.effects())),
+            m_easings(Count(root.easings())),
+            m_animations(Count(root.animations())),
+            m_propertySets(Count(root.property_sets())),
+            m_controllers(Count(root.controllers()))
+        {
+        }
+
+        Visual Run()
+        {
+            auto result = GetVisual(m_root.root_visual());
+            Check(result != nullptr);
+            return result;
+        }
+
+    private:
+        template<typename T>
+        static size_t Count(T const* vector)
+        {
+            return vector == nullptr ? 0 : vector->size();
+        }
+
+        winrt::hstring GetString(uint32_t index) const
+        {
+            if (index == NullIndex)
+            {
+                return {};
+            }
+
+            auto const* strings = m_root.strings();
+            Check(strings != nullptr && index < strings->size());
+            auto const* value = strings->Get(index);
+            Check(value != nullptr);
+
+            // The buffer holds UTF-8 and WinRT wants UTF-16, so this is the one place
+            // where text is copied out of the buffer.
+            return winrt::to_hstring(std::string_view(value->c_str(), value->size()));
+        }
+
+        // -----------------------------------------------------------------------
+        // Shared state.
+        //
+        // This is the reason the caches hold base types: everything an interpreter
+        // does to every node is available on CompositionObject.
+        // -----------------------------------------------------------------------
+        void Initialize(CompositionObject const& target, Fb::CompObj const* source)
+        {
+            if (source == nullptr)
+            {
+                return;
+            }
+
+            if (auto comment = source->comment(); comment != NullIndex)
+            {
+                target.Comment(GetString(comment));
+            }
+
+            // The property set is realized through its owner rather than on its own,
+            // so that a property set and the object that owns it cannot both create
+            // it. Doing it here also breaks the cycle between the two.
+            if (auto properties = source->properties(); properties != NullIndex)
+            {
+                RealizePropertySet(properties, target.Properties());
+            }
+
+            StartAnimations(target, source);
+        }
+
+        void StartAnimations(CompositionObject const& target, Fb::CompObj const* source)
+        {
+            auto const* animators = source->animators();
+            if (animators == nullptr)
+            {
+                return;
+            }
+
+            for (uint32_t i = 0; i != animators->size(); ++i)
+            {
+                auto const* animator = animators->Get(i);
+                Check(animator != nullptr);
+
+                auto property = GetString(animator->property());
+                auto animation = GetAnimation(animator->animation());
+                Check(animation != nullptr);
+
+                // A custom controller is one that drives a property that is not its
+                // own, which the composition engine has no way to express. The
+                // managed instantiator rejects these too.
+                auto controllerIndex = animator->controller();
+                if (controllerIndex != NullIndex && IsCustomController(controllerIndex))
+                {
+                    ThrowUnsupported();
+                }
+
+                target.StartAnimation(property, animation);
+
+                if (controllerIndex != NullIndex)
+                {
+                    RealizeController(controllerIndex, target, property);
+                }
+            }
+        }
+
+        bool IsCustomController(uint32_t index) const
+        {
+            auto const* controller = At(m_root.controllers(), index);
+            return controller->is_custom();
+        }
+
+        // -----------------------------------------------------------------------
+        // Property sets.
+        // -----------------------------------------------------------------------
+        void RealizePropertySet(uint32_t index, CompositionPropertySet const& target)
+        {
+            Check(index < m_propertySets.size());
+
+            if (m_propertySets[index] != nullptr)
+            {
+                return;
+            }
+
+            // Cached before the values are applied, because a value may be an
+            // expression that refers back to this property set.
+            m_propertySets[index] = target;
+
+            auto const* source = At(m_root.property_sets(), index);
+
+            if (auto const* values = source->values(); values != nullptr)
+            {
+                for (uint32_t i = 0; i != values->size(); ++i)
+                {
+                    auto const* value = values->Get(i);
+                    Check(value != nullptr);
+
+                    auto name = GetString(value->name());
+
+                    switch (value->type())
+                    {
+                    case Fb::PropertyValueType::Color:
+                        target.InsertColor(name, ToColor(value->color()));
+                        break;
+                    case Fb::PropertyValueType::Scalar:
+                        target.InsertScalar(name, value->scalar());
+                        break;
+                    case Fb::PropertyValueType::Vector2:
+                        target.InsertVector2(name, { Vector(value)->x(), Vector(value)->y() });
+                        break;
+                    case Fb::PropertyValueType::Vector3:
+                        target.InsertVector3(name, { Vector(value)->x(), Vector(value)->y(), Vector(value)->z() });
+                        break;
+                    case Fb::PropertyValueType::Vector4:
+                        target.InsertVector4(name, { Vector(value)->x(), Vector(value)->y(), Vector(value)->z(), Vector(value)->w() });
+                        break;
+                    case Fb::PropertyValueType::None:
+                        break;
+                    default:
+                        ThrowMalformed();
+                    }
+                }
+            }
+
+            StartAnimations(target, source->base());
+        }
+
+        static Fb::Vec4 const* Vector(Fb::PropertyValue const* value)
+        {
+            auto const* result = value->vector();
+            Check(result != nullptr);
+            return result;
+        }
+
+        CompositionPropertySet GetPropertySet(uint32_t index)
+        {
+            Check(index < m_propertySets.size());
+
+            if (m_propertySets[index] == nullptr)
+            {
+                auto const* source = At(m_root.property_sets(), index);
+
+                if (auto owner = source->owner(); owner != NullIndex)
+                {
+                    // Realizing the owner populates the cache as a side effect,
+                    // because Initialize realizes the owner's property set.
+                    GetObjectReference(owner);
+                }
+                else
+                {
+                    // A property set with no owner is a standalone one, which is how
+                    // the translator exposes theming properties.
+                    RealizePropertySet(index, m_compositor.CreatePropertySet());
+                }
+            }
+
+            Check(m_propertySets[index] != nullptr);
+            return m_propertySets[index];
+        }
+
+        // -----------------------------------------------------------------------
+        // Controllers.
+        // -----------------------------------------------------------------------
+        void RealizeController(uint32_t index, CompositionObject const& target, winrt::hstring const& property)
+        {
+            Check(index < m_controllers.size());
+
+            if (m_controllers[index] != nullptr)
+            {
+                return;
+            }
+
+            auto controller = target.TryGetAnimationController(property);
+            if (controller == nullptr)
+            {
+                return;
+            }
+
+            m_controllers[index] = controller;
+
+            auto const* source = At(m_root.controllers(), index);
+
+            if (source->is_paused())
+            {
+                controller.Pause();
+            }
+
+            Initialize(controller, source->base());
+        }
+
+        // -----------------------------------------------------------------------
+        // Object references.
+        //
+        // Only the three fields that can point at more than one kind of node are
+        // packed this way, so this is the only place a category has to be decoded.
+        // -----------------------------------------------------------------------
+        CompositionObject GetObjectReference(uint32_t reference)
+        {
+            if (reference == NullIndex)
+            {
+                return nullptr;
+            }
+
+            auto const index = reference & IndexMask;
+
+            switch (static_cast<Fb::ObjectCategory>(reference >> CategoryShift))
+            {
+            case Fb::ObjectCategory::Visual: return GetVisual(index);
+            case Fb::ObjectCategory::Shape: return GetShape(index);
+            case Fb::ObjectCategory::Geometry: return GetGeometry(index);
+            case Fb::ObjectCategory::Brush: return GetBrush(index);
+            case Fb::ObjectCategory::Animation: return GetAnimation(index);
+            case Fb::ObjectCategory::Easing: return GetEasing(index);
+            case Fb::ObjectCategory::PropertySet: return GetPropertySet(index);
+            case Fb::ObjectCategory::Clip: return GetClip(index);
+            case Fb::ObjectCategory::Shadow: return GetShadow(index);
+            case Fb::ObjectCategory::GradientStop: return GetGradientStop(index);
+            case Fb::ObjectCategory::ViewBox: return GetViewBox(index);
+            case Fb::ObjectCategory::Surface:
+            {
+                // Only a visual surface is a CompositionObject; an image surface is
+                // not, and nothing can legitimately reference one this way.
+                auto surface = GetSurface(index);
+                auto result = surface.try_as<CompositionObject>();
+                Check(result != nullptr);
+                return result;
+            }
+            case Fb::ObjectCategory::Controller:
+                // A controller is realized by the animator that produces it, so it
+                // can never be the target of a reference.
+                ThrowMalformed();
+            default:
+                ThrowMalformed();
+            }
+        }
+
+        // -----------------------------------------------------------------------
+        // Visuals.
+        // -----------------------------------------------------------------------
+        Visual GetVisual(uint32_t index)
+        {
+            if (index == NullIndex)
+            {
+                return nullptr;
+            }
+
+            Check(index < m_visuals.size());
+
+            if (m_visuals[index] != nullptr)
+            {
+                return m_visuals[index];
+            }
+
+            auto const* source = At(m_root.visuals(), index);
+
+            // The concrete type is known only here. Everything below this point,
+            // including the recursive walk into the children, uses the base type.
+            ContainerVisual container{ nullptr };
+
+            switch (source->kind())
+            {
+            case Fb::VisualKind::Container:
+                container = m_compositor.CreateContainerVisual();
+                break;
+            case Fb::VisualKind::Sprite:
+            {
+                auto sprite = m_compositor.CreateSpriteVisual();
+                m_visuals[index] = sprite;
+                if (auto brush = source->brush(); brush != NullIndex)
+                {
+                    sprite.Brush(GetBrush(brush));
+                }
+
+                container = sprite;
+                break;
+            }
+            case Fb::VisualKind::Shape:
+            {
+                auto shapeVisual = m_compositor.CreateShapeVisual();
+                m_visuals[index] = shapeVisual;
+
+                if (auto viewBox = source->view_box(); viewBox != NullIndex)
+                {
+                    shapeVisual.ViewBox(GetViewBox(viewBox));
+                }
+
+                if (auto const* shapes = source->shapes(); shapes != nullptr)
+                {
+                    auto collection = shapeVisual.Shapes();
+                    for (uint32_t i = 0; i != shapes->size(); ++i)
+                    {
+                        auto shape = GetShape(shapes->Get(i));
+                        Check(shape != nullptr);
+                        collection.Append(shape);
+                    }
+                }
+
+                container = shapeVisual;
+                break;
+            }
+            case Fb::VisualKind::Layer:
+            {
+                auto layer = m_compositor.CreateLayerVisual();
+                m_visuals[index] = layer;
+
+                if (auto shadow = source->shadow(); shadow != NullIndex)
+                {
+                    layer.Shadow(GetShadow(shadow));
+                }
+
+                container = layer;
+                break;
+            }
+            default:
+                ThrowMalformed();
+            }
+
+            // Cached before the children are walked, so that a cycle terminates.
+            m_visuals[index] = container;
+
+            ApplyVisualProperties(container, source);
+
+            if (auto const* children = source->children(); children != nullptr)
+            {
+                auto collection = container.Children();
+                for (uint32_t i = 0; i != children->size(); ++i)
+                {
+                    auto child = GetVisual(children->Get(i));
+                    Check(child != nullptr);
+                    collection.InsertAtTop(child);
+                }
+            }
+
+            Initialize(container, source->base());
+
+            return container;
+        }
+
+        // Takes a Visual rather than any of the four concrete kinds, because every
+        // property here is declared on Visual.
+        void ApplyVisualProperties(Visual const& target, Fb::Visual const* source)
+        {
+            if (auto value = source->border_mode())
+            {
+                target.BorderMode(static_cast<CompositionBorderMode>(*value));
+            }
+
+            if (auto const* value = source->center_point())
+            {
+                target.CenterPoint(ToFloat3(value));
+            }
+
+            if (auto value = source->clip(); value != NullIndex)
+            {
+                target.Clip(GetClip(value));
+            }
+
+            if (auto value = source->is_visible())
+            {
+                target.IsVisible(*value);
+            }
+
+            if (auto const* value = source->offset())
+            {
+                target.Offset(ToFloat3(value));
+            }
+
+            if (auto value = source->opacity())
+            {
+                target.Opacity(*value);
+            }
+
+            if (auto value = source->rotation_angle_in_degrees())
+            {
+                target.RotationAngleInDegrees(*value);
+            }
+
+            if (auto const* value = source->rotation_axis())
+            {
+                target.RotationAxis(ToFloat3(value));
+            }
+
+            if (auto const* value = source->scale())
+            {
+                target.Scale(ToFloat3(value));
+            }
+
+            if (auto const* value = source->size())
+            {
+                target.Size(ToFloat2(value));
+            }
+
+            if (auto const* value = source->transform_matrix())
+            {
+                target.TransformMatrix(ToFloat4x4(value));
+            }
+        }
+
+        // -----------------------------------------------------------------------
+        // Shapes.
+        // -----------------------------------------------------------------------
+        CompositionShape GetShape(uint32_t index)
+        {
+            if (index == NullIndex)
+            {
+                return nullptr;
+            }
+
+            Check(index < m_shapes.size());
+
+            if (m_shapes[index] != nullptr)
+            {
+                return m_shapes[index];
+            }
+
+            auto const* source = At(m_root.shapes(), index);
+
+            CompositionShape result{ nullptr };
+
+            switch (source->kind())
+            {
+            case Fb::ShapeKind::Container:
+            {
+                auto container = m_compositor.CreateContainerShape();
+                m_shapes[index] = container;
+
+                if (auto const* shapes = source->shapes(); shapes != nullptr)
+                {
+                    auto collection = container.Shapes();
+                    for (uint32_t i = 0; i != shapes->size(); ++i)
+                    {
+                        auto shape = GetShape(shapes->Get(i));
+                        Check(shape != nullptr);
+                        collection.Append(shape);
+                    }
+                }
+
+                result = container;
+                break;
+            }
+            case Fb::ShapeKind::Sprite:
+            {
+                auto sprite = m_compositor.CreateSpriteShape();
+                m_shapes[index] = sprite;
+                ApplySpriteShapeProperties(sprite, source);
+                result = sprite;
+                break;
+            }
+            default:
+                ThrowMalformed();
+            }
+
+            m_shapes[index] = result;
+
+            ApplyShapeProperties(result, source);
+            Initialize(result, source->base());
+
+            return result;
+        }
+
+        void ApplyShapeProperties(CompositionShape const& target, Fb::Shape const* source)
+        {
+            if (auto const* value = source->center_point())
+            {
+                target.CenterPoint(ToFloat2(value));
+            }
+
+            if (auto const* value = source->offset())
+            {
+                target.Offset(ToFloat2(value));
+            }
+
+            if (auto value = source->rotation_angle_in_degrees())
+            {
+                target.RotationAngleInDegrees(*value);
+            }
+
+            if (auto const* value = source->scale())
+            {
+                target.Scale(ToFloat2(value));
+            }
+
+            if (auto const* value = source->transform_matrix())
+            {
+                target.TransformMatrix(ToFloat3x2(value));
+            }
+        }
+
+        void ApplySpriteShapeProperties(CompositionSpriteShape const& target, Fb::Shape const* source)
+        {
+            if (auto value = source->geometry(); value != NullIndex)
+            {
+                target.Geometry(GetGeometry(value));
+            }
+
+            if (auto value = source->fill_brush(); value != NullIndex)
+            {
+                target.FillBrush(GetBrush(value));
+            }
+
+            if (auto value = source->stroke_brush(); value != NullIndex)
+            {
+                target.StrokeBrush(GetBrush(value));
+            }
+
+            if (auto value = source->is_stroke_non_scaling())
+            {
+                target.IsStrokeNonScaling(*value);
+            }
+
+            if (auto value = source->stroke_dash_offset())
+            {
+                target.StrokeDashOffset(*value);
+            }
+
+            if (auto const* values = source->stroke_dash_array(); values != nullptr)
+            {
+                auto dashes = target.StrokeDashArray();
+                for (uint32_t i = 0; i != values->size(); ++i)
+                {
+                    dashes.Append(values->Get(i));
+                }
+            }
+
+            if (auto value = source->stroke_dash_cap())
+            {
+                target.StrokeDashCap(static_cast<CompositionStrokeCap>(*value));
+            }
+
+            if (auto value = source->stroke_start_cap())
+            {
+                target.StrokeStartCap(static_cast<CompositionStrokeCap>(*value));
+            }
+
+            if (auto value = source->stroke_end_cap())
+            {
+                target.StrokeEndCap(static_cast<CompositionStrokeCap>(*value));
+            }
+
+            if (auto value = source->stroke_line_join())
+            {
+                target.StrokeLineJoin(static_cast<CompositionStrokeLineJoin>(*value));
+            }
+
+            if (auto value = source->stroke_miter_limit())
+            {
+                target.StrokeMiterLimit(static_cast<uint32_t>(*value));
+            }
+
+            if (auto value = source->stroke_thickness())
+            {
+                target.StrokeThickness(*value);
+            }
+        }
+
+        // -----------------------------------------------------------------------
+        // Geometries.
+        // -----------------------------------------------------------------------
+        CompositionGeometry GetGeometry(uint32_t index)
+        {
+            if (index == NullIndex)
+            {
+                return nullptr;
+            }
+
+            Check(index < m_geometries.size());
+
+            if (m_geometries[index] != nullptr)
+            {
+                return m_geometries[index];
+            }
+
+            auto const* source = At(m_root.geometries(), index);
+
+            CompositionGeometry result{ nullptr };
+
+            switch (source->kind())
+            {
+            case Fb::GeometryKind::Path:
+            {
+                auto path = source->path();
+                result = m_compositor.CreatePathGeometry(
+                    path == NullIndex ? nullptr : GetPath(path));
+                break;
+            }
+            case Fb::GeometryKind::Rectangle:
+            {
+                auto rectangle = m_compositor.CreateRectangleGeometry();
+                if (auto const* value = source->offset())
+                {
+                    rectangle.Offset(ToFloat2(value));
+                }
+
+                if (auto const* value = source->size())
+                {
+                    rectangle.Size(ToFloat2(value));
+                }
+
+                result = rectangle;
+                break;
+            }
+            case Fb::GeometryKind::RoundedRectangle:
+            {
+                auto rounded = m_compositor.CreateRoundedRectangleGeometry();
+                if (auto const* value = source->offset())
+                {
+                    rounded.Offset(ToFloat2(value));
+                }
+
+                if (auto const* value = source->size())
+                {
+                    rounded.Size(ToFloat2(value));
+                }
+
+                if (auto const* value = source->corner_radius())
+                {
+                    rounded.CornerRadius(ToFloat2(value));
+                }
+
+                result = rounded;
+                break;
+            }
+            case Fb::GeometryKind::Ellipse:
+            {
+                auto ellipse = m_compositor.CreateEllipseGeometry();
+                if (auto const* value = source->center())
+                {
+                    ellipse.Center(ToFloat2(value));
+                }
+
+                if (auto const* value = source->radius())
+                {
+                    ellipse.Radius(ToFloat2(value));
+                }
+
+                result = ellipse;
+                break;
+            }
+            default:
+                ThrowMalformed();
+            }
+
+            m_geometries[index] = result;
+
+            if (auto value = source->trim_start())
+            {
+                result.TrimStart(*value);
+            }
+
+            if (auto value = source->trim_end())
+            {
+                result.TrimEnd(*value);
+            }
+
+            if (auto value = source->trim_offset())
+            {
+                result.TrimOffset(*value);
+            }
+
+            Initialize(result, source->base());
+
+            return result;
+        }
+
+        // -----------------------------------------------------------------------
+        // Paths.
+        //
+        // A path is not a CompositionObject, so it has no shared state and no
+        // animators; it is only ever a value.
+        // -----------------------------------------------------------------------
+        CompositionPath GetPath(uint32_t index)
+        {
+            Check(index < m_paths.size());
+
+            if (m_paths[index] == nullptr)
+            {
+                auto geometry = BuildGeometry(index);
+                m_paths[index] = CompositionPath(winrt::make<GeometrySource>(std::move(geometry)));
+            }
+
+            return m_paths[index];
+        }
+
+        winrt::com_ptr<ID2D1Geometry> BuildGeometry(uint32_t index)
+        {
+            auto const* source = At(m_root.canvas_geometries(), index);
+
+            switch (source->kind())
+            {
+            case Fb::CanvasGeometryKind::Combination:
+            {
+                auto a = BuildGeometry(Required(source->a()));
+                auto b = BuildGeometry(Required(source->b()));
+
+                winrt::com_ptr<ID2D1PathGeometry> result;
+                winrt::check_hresult(D2DFactory()->CreatePathGeometry(result.put()));
+
+                winrt::com_ptr<ID2D1GeometrySink> sink;
+                winrt::check_hresult(result->Open(sink.put()));
+
+                auto const matrix = source->matrix();
+                auto const transform = matrix == nullptr
+                    ? D2D1::Matrix3x2F::Identity()
+                    : D2D1::Matrix3x2F(
+                        matrix->m11(), matrix->m12(),
+                        matrix->m21(), matrix->m22(),
+                        matrix->m31(), matrix->m32());
+
+                winrt::check_hresult(a->CombineWithGeometry(
+                    b.get(),
+                    ToCombineMode(source->combine_mode()),
+                    transform,
+                    sink.get()));
+
+                winrt::check_hresult(sink->Close());
+                return result;
+            }
+            case Fb::CanvasGeometryKind::Ellipse:
+            {
+                winrt::com_ptr<ID2D1EllipseGeometry> result;
+                winrt::check_hresult(D2DFactory()->CreateEllipseGeometry(
+                    D2D1::Ellipse(
+                        D2D1::Point2F(source->x(), source->y()),
+                        source->radius_x(),
+                        source->radius_y()),
+                    result.put()));
+                return result;
+            }
+            case Fb::CanvasGeometryKind::RoundedRectangle:
+            {
+                winrt::com_ptr<ID2D1RoundedRectangleGeometry> result;
+                winrt::check_hresult(D2DFactory()->CreateRoundedRectangleGeometry(
+                    D2D1::RoundedRect(
+                        D2D1::RectF(
+                            source->x(),
+                            source->y(),
+                            source->x() + source->w(),
+                            source->y() + source->h()),
+                        source->radius_x(),
+                        source->radius_y()),
+                    result.put()));
+                return result;
+            }
+            case Fb::CanvasGeometryKind::TransformedGeometry:
+            {
+                auto inner = BuildGeometry(Required(source->source()));
+
+                auto const* matrix = source->matrix();
+                Check(matrix != nullptr);
+
+                winrt::com_ptr<ID2D1TransformedGeometry> result;
+                winrt::check_hresult(D2DFactory()->CreateTransformedGeometry(
+                    inner.get(),
+                    D2D1::Matrix3x2F(
+                        matrix->m11(), matrix->m12(),
+                        matrix->m21(), matrix->m22(),
+                        matrix->m31(), matrix->m32()),
+                    result.put()));
+                return result;
+            }
+            case Fb::CanvasGeometryKind::Group:
+            {
+                auto const* geometries = source->geometries();
+                Check(geometries != nullptr);
+
+                std::vector<winrt::com_ptr<ID2D1Geometry>> owned;
+                std::vector<ID2D1Geometry*> raw;
+                owned.reserve(geometries->size());
+                raw.reserve(geometries->size());
+
+                for (uint32_t i = 0; i != geometries->size(); ++i)
+                {
+                    owned.push_back(BuildGeometry(geometries->Get(i)));
+                    raw.push_back(owned.back().get());
+                }
+
+                winrt::com_ptr<ID2D1GeometryGroup> result;
+                winrt::check_hresult(D2DFactory()->CreateGeometryGroup(
+                    static_cast<D2D1_FILL_MODE>(source->fill_rule()),
+                    raw.data(),
+                    static_cast<UINT32>(raw.size()),
+                    result.put()));
+                return result;
+            }
+            case Fb::CanvasGeometryKind::Path:
+                return BuildPath(source);
+            default:
+                ThrowMalformed();
+            }
+        }
+
+        // Replays the flattened command stream. The operands of every command are
+        // consecutive in one array, which is why there is no table per command.
+        winrt::com_ptr<ID2D1Geometry> BuildPath(Fb::CanvasGeometry const* source)
+        {
+            winrt::com_ptr<ID2D1PathGeometry> result;
+            winrt::check_hresult(D2DFactory()->CreatePathGeometry(result.put()));
+
+            winrt::com_ptr<ID2D1GeometrySink> sink;
+            winrt::check_hresult(result->Open(sink.put()));
+
+            sink->SetFillMode(static_cast<D2D1_FILL_MODE>(source->fill_rule()));
+
+            auto const* ops = source->ops();
+            auto const* operands = source->operands();
+
+            uint32_t next = 0;
+            bool inFigure = false;
+
+            auto take = [&](uint32_t count) -> float const*
+            {
+                Check(operands != nullptr && next + count <= operands->size());
+                auto const* values = operands->data() + next;
+                next += count;
+                return values;
+            };
+
+            for (uint32_t i = 0; ops != nullptr && i != ops->size(); ++i)
+            {
+                switch (static_cast<Fb::PathOp>(ops->Get(i)))
+                {
+                case Fb::PathOp::BeginFigure:
+                {
+                    Check(!inFigure);
+                    auto const* v = take(2);
+
+                    // Every figure the translator emits is filled; a hollow figure
+                    // would need a begin flag in the format, which it does not have
+                    // because the object model has no way to express one.
+                    sink->BeginFigure(D2D1::Point2F(v[0], v[1]), D2D1_FIGURE_BEGIN_FILLED);
+                    inFigure = true;
+                    break;
+                }
+                case Fb::PathOp::EndFigure:
+                {
+                    Check(inFigure);
+                    auto const* v = take(1);
+                    sink->EndFigure(v[0] != 0 ? D2D1_FIGURE_END_CLOSED : D2D1_FIGURE_END_OPEN);
+                    inFigure = false;
+                    break;
+                }
+                case Fb::PathOp::AddLine:
+                {
+                    Check(inFigure);
+                    auto const* v = take(2);
+                    sink->AddLine(D2D1::Point2F(v[0], v[1]));
+                    break;
+                }
+                case Fb::PathOp::AddCubicBezier:
+                {
+                    Check(inFigure);
+                    auto const* v = take(6);
+                    sink->AddBezier(D2D1::BezierSegment(
+                        D2D1::Point2F(v[0], v[1]),
+                        D2D1::Point2F(v[2], v[3]),
+                        D2D1::Point2F(v[4], v[5])));
+                    break;
+                }
+                default:
+                    ThrowMalformed();
+                }
+            }
+
+            Check(!inFigure);
+            winrt::check_hresult(sink->Close());
+
+            return result;
+        }
+
+        static uint32_t Required(uint32_t index)
+        {
+            Check(index != NullIndex);
+            return index;
+        }
+
+        // -----------------------------------------------------------------------
+        // Brushes.
+        // -----------------------------------------------------------------------
+        CompositionBrush GetBrush(uint32_t index)
+        {
+            if (index == NullIndex)
+            {
+                return nullptr;
+            }
+
+            Check(index < m_brushes.size());
+
+            if (m_brushes[index] != nullptr)
+            {
+                return m_brushes[index];
+            }
+
+            auto const* source = At(m_root.brushes(), index);
+
+            CompositionBrush result{ nullptr };
+
+            switch (source->kind())
+            {
+            case Fb::BrushKind::Color:
+                result = m_compositor.CreateColorBrush(ToColor(source->color()));
+                break;
+            case Fb::BrushKind::LinearGradient:
+            {
+                auto brush = m_compositor.CreateLinearGradientBrush();
+                m_brushes[index] = brush;
+
+                if (auto const* value = source->start_point())
+                {
+                    brush.StartPoint(ToFloat2(value));
+                }
+
+                if (auto const* value = source->end_point())
+                {
+                    brush.EndPoint(ToFloat2(value));
+                }
+
+                ApplyGradientBrushProperties(brush, source);
+                result = brush;
+                break;
+            }
+            case Fb::BrushKind::RadialGradient:
+            {
+                auto brush = m_compositor.CreateRadialGradientBrush();
+                m_brushes[index] = brush;
+
+                if (auto const* value = source->ellipse_center())
+                {
+                    brush.EllipseCenter(ToFloat2(value));
+                }
+
+                if (auto const* value = source->ellipse_radius())
+                {
+                    brush.EllipseRadius(ToFloat2(value));
+                }
+
+                if (auto const* value = source->gradient_origin_offset())
+                {
+                    brush.GradientOriginOffset(ToFloat2(value));
+                }
+
+                ApplyGradientBrushProperties(brush, source);
+                result = brush;
+                break;
+            }
+            case Fb::BrushKind::Surface:
+                result = m_compositor.CreateSurfaceBrush(GetSurface(Required(source->surface())));
+                break;
+            case Fb::BrushKind::Mask:
+            {
+                auto brush = m_compositor.CreateMaskBrush();
+                m_brushes[index] = brush;
+                brush.Source(GetBrush(source->source()));
+                brush.Mask(GetBrush(source->mask()));
+                result = brush;
+                break;
+            }
+            case Fb::BrushKind::Effect:
+            {
+                auto effect = GetEffect(Required(source->effect()));
+                auto brush = m_compositor.CreateEffectFactory(effect).CreateBrush();
+                m_brushes[index] = brush;
+
+                if (auto const* parameters = source->source_parameters(); parameters != nullptr)
+                {
+                    for (uint32_t i = 0; i != parameters->size(); ++i)
+                    {
+                        auto const* parameter = parameters->Get(i);
+                        Check(parameter != nullptr);
+                        brush.SetSourceParameter(
+                            GetString(parameter->name()),
+                            GetBrush(parameter->brush()));
+                    }
+                }
+
+                result = brush;
+                break;
+            }
+            default:
+                ThrowMalformed();
+            }
+
+            m_brushes[index] = result;
+
+            Initialize(result, source->base());
+
+            return result;
+        }
+
+        void ApplyGradientBrushProperties(CompositionGradientBrush const& target, Fb::Brush const* source)
+        {
+            if (auto const* value = source->anchor_point())
+            {
+                target.AnchorPoint(ToFloat2(value));
+            }
+
+            if (auto const* value = source->center_point())
+            {
+                target.CenterPoint(ToFloat2(value));
+            }
+
+            if (auto value = source->extend_mode())
+            {
+                target.ExtendMode(static_cast<CompositionGradientExtendMode>(*value));
+            }
+
+            if (auto value = source->interpolation_space())
+            {
+                target.InterpolationSpace(static_cast<CompositionColorSpace>(*value));
+            }
+
+            if (auto value = source->mapping_mode())
+            {
+                target.MappingMode(static_cast<CompositionMappingMode>(*value));
+            }
+
+            if (auto const* value = source->offset())
+            {
+                target.Offset(ToFloat2(value));
+            }
+
+            if (auto value = source->rotation_angle_in_degrees())
+            {
+                target.RotationAngleInDegrees(*value);
+            }
+
+            if (auto const* value = source->scale())
+            {
+                target.Scale(ToFloat2(value));
+            }
+
+            if (auto const* value = source->transform_matrix())
+            {
+                target.TransformMatrix(ToFloat3x2(value));
+            }
+
+            if (auto const* stops = source->color_stops(); stops != nullptr)
+            {
+                auto collection = target.ColorStops();
+                for (uint32_t i = 0; i != stops->size(); ++i)
+                {
+                    collection.Append(GetGradientStop(stops->Get(i)));
+                }
+            }
+        }
+
+        CompositionColorGradientStop GetGradientStop(uint32_t index)
+        {
+            Check(index < m_gradientStops.size());
+
+            if (m_gradientStops[index] == nullptr)
+            {
+                auto const* source = At(m_root.gradient_stops(), index);
+
+                auto stop = m_compositor.CreateColorGradientStop(
+                    source->offset(),
+                    ToColor(source->color()));
+
+                m_gradientStops[index] = stop;
+                Initialize(stop, source->base());
+            }
+
+            return m_gradientStops[index];
+        }
+
+        // -----------------------------------------------------------------------
+        // Clips, view boxes, shadows and surfaces.
+        // -----------------------------------------------------------------------
+        CompositionClip GetClip(uint32_t index)
+        {
+            Check(index < m_clips.size());
+
+            if (m_clips[index] != nullptr)
+            {
+                return m_clips[index];
+            }
+
+            auto const* source = At(m_root.clips(), index);
+
+            CompositionClip result{ nullptr };
+
+            switch (source->kind())
+            {
+            case Fb::ClipKind::Inset:
+            {
+                auto clip = m_compositor.CreateInsetClip();
+
+                if (auto value = source->left_inset())
+                {
+                    clip.LeftInset(*value);
+                }
+
+                if (auto value = source->right_inset())
+                {
+                    clip.RightInset(*value);
+                }
+
+                if (auto value = source->top_inset())
+                {
+                    clip.TopInset(*value);
+                }
+
+                if (auto value = source->bottom_inset())
+                {
+                    clip.BottomInset(*value);
+                }
+
+                result = clip;
+                break;
+            }
+            case Fb::ClipKind::Geometric:
+            {
+                auto clip = m_compositor.CreateGeometricClip();
+                m_clips[index] = clip;
+                clip.Geometry(GetGeometry(source->geometry()));
+                result = clip;
+                break;
+            }
+            default:
+                ThrowMalformed();
+            }
+
+            m_clips[index] = result;
+
+            if (auto const* value = source->center_point())
+            {
+                result.CenterPoint(ToFloat2(value));
+            }
+
+            if (auto const* value = source->scale())
+            {
+                result.Scale(ToFloat2(value));
+            }
+
+            Initialize(result, source->base());
+
+            return result;
+        }
+
+        CompositionViewBox GetViewBox(uint32_t index)
+        {
+            Check(index < m_viewBoxes.size());
+
+            if (m_viewBoxes[index] == nullptr)
+            {
+                auto const* source = At(m_root.view_boxes(), index);
+
+                auto viewBox = m_compositor.CreateViewBox();
+                m_viewBoxes[index] = viewBox;
+
+                if (auto const* value = source->size())
+                {
+                    viewBox.Size(ToFloat2(value));
+                }
+
+                Initialize(viewBox, source->base());
+            }
+
+            return m_viewBoxes[index];
+        }
+
+        CompositionShadow GetShadow(uint32_t index)
+        {
+            Check(index < m_shadows.size());
+
+            if (m_shadows[index] != nullptr)
+            {
+                return m_shadows[index];
+            }
+
+            auto const* source = At(m_root.shadows(), index);
+            Check(source->kind() == Fb::ShadowKind::Drop);
+
+            auto shadow = m_compositor.CreateDropShadow();
+            m_shadows[index] = shadow;
+
+            if (auto value = source->blur_radius())
+            {
+                shadow.BlurRadius(*value);
+            }
+
+            if (auto const* value = source->color())
+            {
+                shadow.Color(ToColor(value));
+            }
+
+            if (auto mask = source->mask(); mask != NullIndex)
+            {
+                shadow.Mask(GetBrush(mask));
+            }
+
+            if (auto const* value = source->offset())
+            {
+                shadow.Offset(ToFloat3(value));
+            }
+
+            if (auto value = source->opacity())
+            {
+                shadow.Opacity(*value);
+            }
+
+            if (auto value = source->source_policy())
+            {
+                shadow.SourcePolicy(static_cast<CompositionDropShadowSourcePolicy>(*value));
+            }
+
+            Initialize(shadow, source->base());
+
+            return shadow;
+        }
+
+        ICompositionSurface GetSurface(uint32_t index)
+        {
+            Check(index < m_surfaces.size());
+
+            if (m_surfaces[index] != nullptr)
+            {
+                return m_surfaces[index];
+            }
+
+            auto const* source = At(m_root.surfaces(), index);
+
+            switch (source->kind())
+            {
+            case Fb::SurfaceKind::VisualSurface:
+            {
+                auto surface = m_compositor.CreateVisualSurface();
+                m_surfaces[index] = surface;
+
+                if (auto value = source->source_visual(); value != NullIndex)
+                {
+                    surface.SourceVisual(GetVisual(value));
+                }
+
+                if (auto const* value = source->source_size())
+                {
+                    surface.SourceSize(ToFloat2(value));
+                }
+
+                if (auto const* value = source->source_offset())
+                {
+                    surface.SourceOffset(ToFloat2(value));
+                }
+
+                Initialize(surface, source->base());
+                break;
+            }
+            case Fb::SurfaceKind::LoadedImageFromUri:
+            case Fb::SurfaceKind::LoadedImageFromStream:
+                // LoadedImageSurface lives in Windows.UI.Xaml.Media, so an
+                // interpreter that is usable outside XAML cannot create one. The
+                // translator only emits these for animations that embed an image,
+                // which the Lottie feature set this interpreter targets excludes.
+                ThrowUnsupported();
+            default:
+                ThrowMalformed();
+            }
+
+            return m_surfaces[index];
+        }
+
+        winrt::Windows::Graphics::Effects::IGraphicsEffect GetEffect(uint32_t index)
+        {
+            Check(index < m_effects.size());
+
+            if (m_effects[index] != nullptr)
+            {
+                return m_effects[index];
+            }
+
+            auto const* source = At(m_root.effects(), index);
+
+            winrt::com_ptr<Effect> effect;
+
+            switch (source->kind())
+            {
+            case Fb::EffectKind::Composite:
+                // CanvasComposite and D2D1_COMPOSITE_MODE agree on every member, so
+                // the mode from the buffer is the D2D value.
+                effect = winrt::make_self<Effect>(
+                    CLSID_D2D1Composite,
+                    winrt::box_value(static_cast<uint32_t>(source->mode())));
+                break;
+            case Fb::EffectKind::GaussianBlur:
+                effect = winrt::make_self<Effect>(
+                    CLSID_D2D1GaussianBlur,
+                    winrt::box_value(source->blur_amount()));
+                break;
+            default:
+                ThrowMalformed();
+            }
+
+            // The sources are the names the brush later binds real brushes to. The
+            // composition engine matches them up by name.
+            if (auto const* sources = source->sources(); sources != nullptr)
+            {
+                for (uint32_t i = 0; i != sources->size(); ++i)
+                {
+                    effect->AddSource(CompositionEffectSourceParameter(GetString(sources->Get(i))));
+                }
+            }
+
+            auto result = effect.as<winrt::Windows::Graphics::Effects::IGraphicsEffect>();
+            m_effects[index] = result;
+            return result;
+        }
+
+        // -----------------------------------------------------------------------
+        // Easings.
+        // -----------------------------------------------------------------------
+        CompositionEasingFunction GetEasing(uint32_t index)
+        {
+            if (index == NullIndex)
+            {
+                return nullptr;
+            }
+
+            Check(index < m_easings.size());
+
+            if (m_easings[index] != nullptr)
+            {
+                return m_easings[index];
+            }
+
+            auto const* source = At(m_root.easings(), index);
+
+            CompositionEasingFunction result{ nullptr };
+
+            switch (source->kind())
+            {
+            case Fb::EasingKind::Linear:
+                result = m_compositor.CreateLinearEasingFunction();
+                break;
+            case Fb::EasingKind::CubicBezier:
+            {
+                auto const* first = source->control_point_1();
+                auto const* second = source->control_point_2();
+                result = m_compositor.CreateCubicBezierEasingFunction(
+                    first == nullptr ? float2{ 0, 0 } : ToFloat2(first),
+                    second == nullptr ? float2{ 0, 0 } : ToFloat2(second));
+                break;
+            }
+            case Fb::EasingKind::Step:
+            {
+                auto stepCount = source->step_count();
+                auto step = m_compositor.CreateStepEasingFunction(
+                    stepCount ? *stepCount : 1);
+
+                if (auto value = source->initial_step())
+                {
+                    step.InitialStep(*value);
+                }
+
+                if (auto value = source->final_step())
+                {
+                    step.FinalStep(*value);
+                }
+
+                if (auto value = source->is_initial_step_single_frame())
+                {
+                    step.IsInitialStepSingleFrame(*value);
+                }
+
+                if (auto value = source->is_final_step_single_frame())
+                {
+                    step.IsFinalStepSingleFrame(*value);
+                }
+
+                result = step;
+                break;
+            }
+            default:
+                ThrowMalformed();
+            }
+
+            m_easings[index] = result;
+            Initialize(result, source->base());
+
+            return result;
+        }
+
+        // -----------------------------------------------------------------------
+        // Animations.
+        // -----------------------------------------------------------------------
+        CompositionAnimation GetAnimation(uint32_t index)
+        {
+            if (index == NullIndex)
+            {
+                return nullptr;
+            }
+
+            Check(index < m_animations.size());
+
+            if (m_animations[index] != nullptr)
+            {
+                return m_animations[index];
+            }
+
+            auto const* source = At(m_root.animations(), index);
+
+            CompositionAnimation result = source->kind() == Fb::AnimationKind::Expression
+                ? CreateExpressionAnimation(source)
+                : CreateKeyFrameAnimation(source);
+
+            m_animations[index] = result;
+
+            if (auto target = source->target(); target != NullIndex)
+            {
+                result.Target(GetString(target));
+            }
+
+            if (auto const* parameters = source->reference_parameters(); parameters != nullptr)
+            {
+                for (uint32_t i = 0; i != parameters->size(); ++i)
+                {
+                    auto const* parameter = parameters->Get(i);
+                    Check(parameter != nullptr);
+
+                    auto value = GetObjectReference(parameter->target());
+                    Check(value != nullptr);
+                    result.SetReferenceParameter(GetString(parameter->name()), value);
+                }
+            }
+
+            Initialize(result, source->base());
+
+            return result;
+        }
+
+        CompositionAnimation CreateExpressionAnimation(Fb::Animation const* source)
+        {
+            return m_compositor.CreateExpressionAnimation(GetString(Required(source->expression())));
+        }
+
+        // Creates the animation and inserts its key frames in one place, because the
+        // concrete type is only needed in order to insert a value key frame and it
+        // would otherwise have to be recovered with a cast.
+        CompositionAnimation CreateKeyFrameAnimation(Fb::Animation const* source)
+        {
+            auto const* frames = source->key_frames();
+
+            KeyFrameAnimation result{ nullptr };
+
+            switch (source->kind())
+            {
+            case Fb::AnimationKind::Scalar:
+            {
+                auto animation = m_compositor.CreateScalarKeyFrameAnimation();
+                ForEachValueKeyFrame(frames, [&](Fb::KeyFrame const* frame)
+                {
+                    animation.InsertKeyFrame(frame->progress(), frame->scalar(), GetEasing(frame->easing()));
+                });
+                result = animation;
+                break;
+            }
+            case Fb::AnimationKind::Vector2:
+            {
+                auto animation = m_compositor.CreateVector2KeyFrameAnimation();
+                ForEachValueKeyFrame(frames, [&](Fb::KeyFrame const* frame)
+                {
+                    auto const* v = RequireVector(frame);
+                    animation.InsertKeyFrame(frame->progress(), { v->x(), v->y() }, GetEasing(frame->easing()));
+                });
+                result = animation;
+                break;
+            }
+            case Fb::AnimationKind::Vector3:
+            {
+                auto animation = m_compositor.CreateVector3KeyFrameAnimation();
+                ForEachValueKeyFrame(frames, [&](Fb::KeyFrame const* frame)
+                {
+                    auto const* v = RequireVector(frame);
+                    animation.InsertKeyFrame(frame->progress(), { v->x(), v->y(), v->z() }, GetEasing(frame->easing()));
+                });
+                result = animation;
+                break;
+            }
+            case Fb::AnimationKind::Vector4:
+            {
+                auto animation = m_compositor.CreateVector4KeyFrameAnimation();
+                ForEachValueKeyFrame(frames, [&](Fb::KeyFrame const* frame)
+                {
+                    auto const* v = RequireVector(frame);
+                    animation.InsertKeyFrame(frame->progress(), { v->x(), v->y(), v->z(), v->w() }, GetEasing(frame->easing()));
+                });
+                result = animation;
+                break;
+            }
+            case Fb::AnimationKind::Color:
+            {
+                auto animation = m_compositor.CreateColorKeyFrameAnimation();
+
+                if (auto value = source->interpolation_color_space())
+                {
+                    animation.InterpolationColorSpace(static_cast<CompositionColorSpace>(*value));
+                }
+
+                ForEachValueKeyFrame(frames, [&](Fb::KeyFrame const* frame)
+                {
+                    animation.InsertKeyFrame(frame->progress(), ToColor(frame->color()), GetEasing(frame->easing()));
+                });
+                result = animation;
+                break;
+            }
+            case Fb::AnimationKind::Boolean:
+            {
+                auto animation = m_compositor.CreateBooleanKeyFrameAnimation();
+
+                // A boolean cannot be interpolated, so it has no easing.
+                ForEachValueKeyFrame(frames, [&](Fb::KeyFrame const* frame)
+                {
+                    animation.InsertKeyFrame(frame->progress(), frame->scalar() != 0);
+                });
+                result = animation;
+                break;
+            }
+            case Fb::AnimationKind::Path:
+            {
+                auto animation = m_compositor.CreatePathKeyFrameAnimation();
+                ForEachValueKeyFrame(frames, [&](Fb::KeyFrame const* frame)
+                {
+                    animation.InsertKeyFrame(frame->progress(), GetPath(Required(frame->path())), GetEasing(frame->easing()));
+                });
+                result = animation;
+                break;
+            }
+            default:
+                ThrowMalformed();
+            }
+
+            // Expression key frames are inserted through the base type, so they do
+            // not have to be repeated in every branch above. They are inserted after
+            // the value key frames, which is safe because a key frame animation is a
+            // map keyed on progress rather than a list.
+            if (frames != nullptr)
+            {
+                for (uint32_t i = 0; i != frames->size(); ++i)
+                {
+                    auto const* frame = frames->Get(i);
+                    Check(frame != nullptr);
+
+                    if (frame->kind() == Fb::KeyFrameKind::Expression)
+                    {
+                        result.InsertExpressionKeyFrame(
+                            frame->progress(),
+                            GetString(Required(frame->expression())),
+                            GetEasing(frame->easing()));
+                    }
+                }
+            }
+
+            if (auto ticks = source->duration_ticks(); ticks != 0)
+            {
+                result.Duration(winrt::Windows::Foundation::TimeSpan{ ticks });
+            }
+
+            return result;
+        }
+
+        template<typename F>
+        void ForEachValueKeyFrame(::flatbuffers::Vector<::flatbuffers::Offset<Fb::KeyFrame>> const* frames, F&& apply)
+        {
+            if (frames == nullptr)
+            {
+                return;
+            }
+
+            for (uint32_t i = 0; i != frames->size(); ++i)
+            {
+                auto const* frame = frames->Get(i);
+                Check(frame != nullptr);
+
+                if (frame->kind() == Fb::KeyFrameKind::Value)
+                {
+                    apply(frame);
+                }
+            }
+        }
+
+        static Fb::Vec4 const* RequireVector(Fb::KeyFrame const* frame)
+        {
+            auto const* result = frame->vector();
+            Check(result != nullptr);
+            return result;
+        }
+
+        Compositor const& m_compositor;
+        Fb::LottieComposition const& m_root;
+
+        // The caches. Each is exactly as long as the matching vector in the buffer,
+        // so a lookup is a bounds check and an index. Each holds the least derived
+        // type that any reference to that category needs, which is what stops a
+        // realized node from ever having to be cast back to what it was.
+        std::vector<Visual> m_visuals;
+        std::vector<CompositionShape> m_shapes;
+        std::vector<CompositionGeometry> m_geometries;
+        std::vector<CompositionPath> m_paths;
+        std::vector<CompositionBrush> m_brushes;
+        std::vector<CompositionColorGradientStop> m_gradientStops;
+        std::vector<CompositionViewBox> m_viewBoxes;
+        std::vector<CompositionClip> m_clips;
+        std::vector<CompositionShadow> m_shadows;
+        std::vector<ICompositionSurface> m_surfaces;
+        std::vector<winrt::Windows::Graphics::Effects::IGraphicsEffect> m_effects;
+        std::vector<CompositionEasingFunction> m_easings;
+        std::vector<CompositionAnimation> m_animations;
+        std::vector<CompositionPropertySet> m_propertySets;
+        std::vector<AnimationController> m_controllers;
+    };
+}
+
+namespace CommunityToolkit::WinUI::Lottie
+{
+    Visual LoadComposition(Compositor const& compositor, std::span<std::byte const> buffer)
+    {
+        // The buffer is untrusted, so nothing is read out of it until the verifier
+        // has agreed that every offset in it is inside it.
+        ::flatbuffers::Verifier verifier(
+            reinterpret_cast<uint8_t const*>(buffer.data()),
+            buffer.size());
+
+        if (buffer.size() < sizeof(uint32_t) + 4 ||
+            !Fb::LottieCompositionBufferHasIdentifier(buffer.data()) ||
+            !Fb::VerifyLottieCompositionBuffer(verifier))
+        {
+            ThrowMalformed();
+        }
+
+        auto const* root = Fb::GetLottieComposition(buffer.data());
+        Check(root != nullptr);
+
+        // A newer schema may store things in fields this build does not read, so a
+        // buffer that declares one is refused rather than silently misinterpreted.
+        if (root->schema_version() > SupportedSchemaVersion)
+        {
+            ThrowUnsupported();
+        }
+
+        return Interpreter(compositor, *root).Run();
+    }
+
+    CompositionPropertySet ProgressPropertySet(Visual const& root)
+    {
+        return root.Properties();
+    }
+}
diff --git a/dlls/LottieRuntime/LottieRuntime.h b/dlls/LottieRuntime/LottieRuntime.h
new file mode 100644
index 00000000..28a65f6f
--- /dev/null
+++ b/dlls/LottieRuntime/LottieRuntime.h
@@ -0,0 +1,54 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#pragma once
+
+#include <cstddef>
+#include <span>
+
+#include <winrt/Windows.UI.Composition.h>
+
+// The component is usable either as a DLL or compiled straight into an application.
+// Define LOTTIERUNTIME_STATIC to build it in, and LOTTIERUNTIME_EXPORTS when building
+// the DLL itself.
+#if defined(LOTTIERUNTIME_STATIC)
+#define LOTTIERUNTIME_API
+#elif defined(LOTTIERUNTIME_EXPORTS)
+#define LOTTIERUNTIME_API __declspec(dllexport)
+#else
+#define LOTTIERUNTIME_API __declspec(dllimport)
+#endif
+
+namespace CommunityToolkit::WinUI::Lottie
+{
+    // Builds the composition described by a serialized Lottie composition.
+    //
+    // The buffer is the output of LottieGen -Language flatbuffer, or equivalently of
+    // CompositionSerializer. It is treated as untrusted: it is verified before it is
+    // read, and every index in it is range checked, so a malformed buffer produces an
+    // exception rather than undefined behaviour.
+    //
+    // The returned visual is the root of a tree that is already animated and ready to
+    // be attached to a target with SetElementChildVisual or as a child of another
+    // visual. The animations are bound to the "Progress" property of the property set
+    // returned by ProgressPropertySet, so playback is driven by animating that single
+    // property.
+    //
+    // The result is the least derived type that describes the root, because a caller
+    // that only parents the tree and drives its progress never needs anything more.
+    //
+    // Throws winrt::hresult_error with E_INVALIDARG if the buffer is not a well formed
+    // composition, and E_NOTIMPL if it requires a feature this build does not have.
+    LOTTIERUNTIME_API winrt::Windows::UI::Composition::Visual LoadComposition(
+        winrt::Windows::UI::Composition::Compositor const& compositor,
+        std::span<std::byte const> buffer);
+
+    // The property set that drives the animation. Animating its "Progress" scalar from
+    // 0 to 1 plays the animation once.
+    //
+    // This is the property set of the visual returned by LoadComposition, so it is only
+    // a convenience; it exists so that callers do not have to know that detail.
+    LOTTIERUNTIME_API winrt::Windows::UI::Composition::CompositionPropertySet ProgressPropertySet(
+        winrt::Windows::UI::Composition::Visual const& root);
+}
diff --git a/dlls/LottieRuntime/LottieRuntime.vcxproj b/dlls/LottieRuntime/LottieRuntime.vcxproj
new file mode 100644
index 00000000..846e7c15
--- /dev/null
+++ b/dlls/LottieRuntime/LottieRuntime.vcxproj
@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{6E0A5B4C-2F1D-4B7A-9C3E-1D5A8F0B2E47}</ProjectGuid>
+    <RootNamespace>LottieRuntime</RootNamespace>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
+
+    <!-- The interpreter targets the same minimum as the rest of Lottie-Windows.
+         Anything newer is reached through the buffer's required UAP version, which
+         a caller checks before it loads. -->
+    <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
+  </PropertyGroup>
+
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+
+  <PropertyGroup>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Release'">false</UseDebugLibraries>
+    <WholeProgramOptimization Condition="'$(Configuration)'=='Release'">true</WholeProgramOptimization>
+  </PropertyGroup>
+
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+      <PreprocessorDefinitions>LOTTIERUNTIME_EXPORTS;WIN32_LEAN_AND_MEAN;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory);$(MSBuildThisFileDirectory)packages\flatbuffers\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <WarningLevel>Level4</WarningLevel>
+      <TreatWarningAsError>true</TreatWarningAsError>
+
+      <!-- Exceptions are the error channel, and every interop entry point is
+           noexcept, so there is nothing to unwind across an ABI boundary. -->
+      <ExceptionHandling>Sync</ExceptionHandling>
+
+      <!-- Size is the first thing this component optimizes for. -->
+      <Optimization Condition="'$(Configuration)'=='Release'">MinSpace</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>d2d1.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
+
+      <!-- Discards the code for any node type the application never reaches. -->
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+    </Link>
+  </ItemDefinitionGroup>
+
+  <ItemGroup>
+    <ClInclude Include="LottieRuntime.h" />
+    <ClInclude Include="Generated\lottie_comp_generated.h" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ClCompile Include="LottieRuntime.cpp" />
+  </ItemGroup>
+
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>
diff --git a/dlls/LottieRuntime/README.md b/dlls/LottieRuntime/README.md
new file mode 100644
index 00000000..6c2f0541
--- /dev/null
+++ b/dlls/LottieRuntime/README.md
@@ -0,0 +1,135 @@
+# LottieRuntime
+
+A native runtime interpreter for Lottie animations.
+
+`LottieRuntime` builds a Windows.UI.Composition visual tree from a serialized
+composition, at runtime, without a JSON parser and without generated code. It is a
+header and a source file, so it can be built as a DLL that several applications
+share, or compiled straight into one.
+
+## How it fits in
+
+Lottie-Windows already turns a Lottie file into a `WinCompData` graph, which is a
+description of a composition tree. There were two things that could consume that
+graph:
+
+| Consumer | When it runs | Cost |
+| --- | --- | --- |
+| `Instantiator` | Runtime, in the app | Ships the whole JSON reader and translator |
+| `LottieGen` code generators | Build time | No runtime cost, but one class per animation |
+
+This adds a third. `CompositionSerializer` writes the `WinCompData` graph into a
+FlatBuffer at build time, and `LottieRuntime` reads that buffer at runtime. The
+animation stays data, so it can be swapped, downloaded or themed without a rebuild,
+and the code that reads it is the same size no matter how many animations an
+application has.
+
+```
+Lottie JSON --> LottieCompositionReader --> LottieData
+                                              |
+                                              v
+                                       LottieToWinComp
+                                              |
+                                              v
+                                        WinCompData graph
+                                        /      |        \
+                                       /       |         \
+                              Instantiator  UIDataCodeGen  CompositionSerializer
+                              (runtime C#)   (C#/C++/CX)          |
+                                                                  v
+                                                            .lcomp buffer
+                                                                  |
+                                                                  v
+                                                            LottieRuntime
+                                                            (runtime C++)
+```
+
+Because the FlatBuffer is written from the same graph the other two consume, all
+three produce the same visual tree. The round trip tests in
+`tests/CompDataFlatbuffer.Tests` assert exactly that.
+
+## Producing a buffer
+
+```
+LottieGen -InputFile animation.json -Language flatbuffer -OutputFolder .
+```
+
+This writes `Animation.lcomp`. The format is described by
+[`source/LottieFlatbuffer/lottie_comp.fbs`](../../source/LottieFlatbuffer/lottie_comp.fbs).
+
+## Using it
+
+```cpp
+#include <LottieRuntime.h>
+
+auto bytes = ReadFileBytes(L"Animation.lcomp");
+auto root = CommunityToolkit::WinUI::Lottie::LoadComposition(compositor, bytes);
+
+// Drive the animation by animating one scalar from 0 to 1.
+auto progress = CommunityToolkit::WinUI::Lottie::ProgressPropertySet(root);
+progress.StartAnimation(L"Progress", playAnimation);
+
+ElementCompositionPreview::SetElementChildVisual(element, root);
+```
+
+`LoadComposition` returns a `Visual`, which is the least derived type that describes
+the root. A caller that parents the tree and drives its progress never needs more
+than that.
+
+## Design
+
+**Least derived interfaces.** A node's concrete type is known only inside the
+function that creates it. The realization caches hold `Visual`,
+`CompositionShape`, `CompositionBrush`, `CompositionGeometry` and so on, and every
+call the interpreter makes afterwards is declared on those types. There is no point
+at which the interpreter asks what a node actually is, because the buffer already
+said, and the answer was consumed at the moment of creation. The one exception is
+`ObjectCategory::Surface` in an object reference, where the buffer permits an image
+surface that is not a `CompositionObject`; that is a validation check, not a
+downcast in the normal path.
+
+**Size first.** There is one function per node *category*, not per node type, and
+the state shared by every node is applied by a single function that takes
+`CompositionObject`. Everything is in one translation unit, so `/OPT:REF` discards
+the code for whatever an application never reaches.
+
+**Runtime cost second.** Each node is realized at most once. Lookups are a bounds
+check and an array index; there is no hash table anywhere. The buffer is read in
+place, so no intermediate object model is built.
+
+**Transient memory third.** The only allocations are the caches, which are exactly
+as long as the buffer's node vectors, and the D2D geometries, which are released as
+soon as they have been given to a `CompositionPath`.
+
+**Untrusted input.** A buffer may have come from a file or a download. It is checked
+for the `LCMP` identifier, run through the FlatBuffers verifier, and every index
+read out of it is range checked. A malformed buffer throws
+`winrt::hresult_invalid_argument`; it never reads outside the buffer.
+
+## Dependencies
+
+Direct2D, for path geometry, and the composition effect interop interface, for the
+two effects the translator emits. There is no dependency on Win2D: the interpreter
+implements `IGeometrySource2DInterop` and `IGraphicsEffectD2D1Interop` itself, which
+is a few dozen lines and avoids pulling a large component into every application.
+
+Requires the FlatBuffers C++ runtime headers (headers only, no library) from
+[flatbuffers 25.2.10](https://github.com/google/flatbuffers/releases/tag/v25.2.10),
+which must match the `flatc` used to generate `Generated/lottie_comp_generated.h`.
+
+## Limitations
+
+`LoadedImageSurface` is a Windows.UI.Xaml.Media type, so an interpreter that is
+usable outside XAML cannot create one. An animation that embeds a raster image
+throws `winrt::hresult_not_implemented`. Custom animation controllers are rejected
+for the same reason the managed `Instantiator` rejects them: the composition engine
+has no way to express one.
+
+## Status
+
+**This code has not been compiled.** It was written on a Linux host, where neither
+MSVC nor the Windows SDK is available, so it has never been through a compiler and
+must be treated as unverified. Its behaviour is specified by `Instantiator.cs` and
+by `CompositionDeserializer.cs`, both of which are exercised by the tests in
+`tests/CompDataFlatbuffer.Tests`, so the shape of what it does is well tested even
+though this particular expression of it is not.

From 8cf90b6803bd8a4a64820c8a246ec6a031b64065 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 18:48:19 +0000
Subject: [PATCH 11/39] Document the format, the native interpreter and how
 they relate

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 README.md                         |  6 +++
 dlls/README.md                    |  8 ++++
 source/LottieFlatbuffer/README.md | 75 +++++++++++++++++++++++++++++++
 3 files changed, 89 insertions(+)
 create mode 100644 source/LottieFlatbuffer/README.md

diff --git a/README.md b/README.md
index 968bb183..15b643b5 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,12 @@ Lottie-Windows consists of 3 related products:
 
 This repo also contains source code for **[samples](/LottieViewer)**.
 
+It also contains **[LottieRuntime](/dlls/LottieRuntime)**, a native C++/WinRT interpreter that
+builds the composition tree at runtime from a serialized animation produced by
+`LottieGen -Language flatbuffer`. It keeps the animation as data, like the JSON path does, but
+without shipping a JSON parser or the translator. See
+[the format](/source/LottieFlatbuffer/README.md) for how the two relate.
+
 ## <a name="quickstart"></a> Quick start
 
 There are **two** options to integrate Lottie animations into your **WinUI 3** or **UWP** project.
diff --git a/dlls/README.md b/dlls/README.md
index e795c3ae..6e09e866 100644
--- a/dlls/README.md
+++ b/dlls/README.md
@@ -25,3 +25,11 @@ But we don't actually use the DLLs in any of the other projects; instead, we mus
 ### Summary
 * Shared projects give us the equivalent of C++ static libs.
 * The dlls directory enforces modularity.
+
+## LottieRuntime
+
+`LottieRuntime` is the exception to everything above. It is a real C++ DLL that an
+application is meant to consume, rather than a modularity check, and it is not part
+of `Lottie-Windows.sln` because it needs the C++ toolset and the FlatBuffers headers.
+It reads the serialized form of a `WinCompData` graph and builds the composition
+tree at runtime. See [LottieRuntime/README.md](LottieRuntime/README.md).
diff --git a/source/LottieFlatbuffer/README.md b/source/LottieFlatbuffer/README.md
new file mode 100644
index 00000000..d5547614
--- /dev/null
+++ b/source/LottieFlatbuffer/README.md
@@ -0,0 +1,75 @@
+# LottieFlatbuffer
+
+`lottie_comp.fbs` is the schema for the serialized form of a `WinCompData` graph.
+
+## What is serialized, and why that
+
+A Lottie file goes through several stages before anything is drawn:
+
+```
+Lottie JSON --> LottieData --> WinCompData graph --> composition tree
+```
+
+The interesting choice is which of those to serialize. The Lottie authoring format
+would be the obvious answer, but it is the wrong one: reading it back still requires
+the whole translator, which is by far the largest part of Lottie-Windows and the
+part that changes most often. The `WinCompData` graph is much closer to what the
+composition engine needs, so a reader for it is small, and it is a closed object
+model, so a reader for it is *complete* rather than approximate.
+
+This is the same seam that the code generators use. `Instantiator.cs`, the C#, C++/CX
+and C++/WinRT generators, and this format are all consumers of the same graph, which
+is why they all produce the same visual tree.
+
+## Layout
+
+The graph is a DAG with sharing, so it is stored as a set of parallel node vectors,
+one per category, and every reference is a `uint32` index into one of them.
+`0xFFFFFFFF` means no node. Sharing therefore costs nothing: two references to the
+same node are two copies of the same index.
+
+Three fields can point at more than one category — a reference parameter's target, a
+property set's owner and a controller's target. Those pack the category into the top
+four bits, so they are the only places a reader has to decode a category. Everywhere
+else the field's type already says which vector to index.
+
+Strings are interned into a single vector and referenced by index, which is what
+makes the format small: the graph is full of repeated property names such as
+`Offset`, `Progress` and `TrimEnd`.
+
+Path geometry is flattened into a `[ubyte]` of opcodes and a `[float]` of operands
+rather than a table per command, because a path can have thousands of commands and a
+FlatBuffers table has a fixed overhead that would dominate.
+
+Serialization is deterministic: the same graph always produces the same bytes, so
+output can be diffed and cached.
+
+## Versioning
+
+The rules are at the top of `lottie_comp.fbs`. In short: fields may only be added,
+never removed or reordered, and `SCHEMA_VERSION` is bumped when they are. A reader
+refuses a buffer whose version is higher than the one it was built for, because such
+a buffer may carry meaning in fields the reader does not look at.
+
+## Regenerating
+
+`flatc` output for both C# and C++ is checked in, so contributors do not need `flatc`
+installed. After changing the schema:
+
+```powershell
+./build/RegenerateFlatbuffers.ps1 -Flatc <path to flatc>
+```
+
+The `flatc` version **must** match the `Google.FlatBuffers` NuGet package version;
+the generated C# calls a version-stamped method that only exists in the matching
+package. Both are currently 25.2.10.
+
+## Consumers
+
+| | |
+| --- | --- |
+| `source/CompDataFlatbuffer/CompositionSerializer.cs` | Writes a graph |
+| `source/CompDataFlatbuffer/CompositionDeserializer.cs` | Reads one back, in C# |
+| `dlls/LottieRuntime` | Reads one back, in C++/WinRT |
+| `LottieGen -Language flatbuffer` | Produces a `.lcomp` file |
+| `tests/CompDataFlatbuffer.Tests` | Asserts a graph survives the round trip unchanged |

From 5e3e9aa7860ca2dc084697498dbfe87a6512832d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 31 Aug 2026 18:54:46 +0000
Subject: [PATCH 12/39] Address code review feedback in glob parsing, indexer
 and coverage test

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 source/CompDataFlatbuffer/GraphIndexer.cs       | 4 ++--
 source/LottieGen/Glob.cs                        | 6 ++++--
 tests/CompDataFlatbuffer.Tests/CoverageTests.cs | 5 +++--
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/source/CompDataFlatbuffer/GraphIndexer.cs b/source/CompDataFlatbuffer/GraphIndexer.cs
index 20b56d93..7d5b6bcc 100644
--- a/source/CompDataFlatbuffer/GraphIndexer.cs
+++ b/source/CompDataFlatbuffer/GraphIndexer.cs
@@ -223,12 +223,12 @@ uint Index<T>(Dictionary<object, int> map, T? value)
 
             var index = map.Count;
             map.Add(value, index);
-            Add(value, index);
+            Add(value);
             return (uint)index;
         }
 
         // Appends a newly discovered node to its category list and walks its children.
-        void Add(object value, int index)
+        void Add(object value)
         {
             switch (value)
             {
diff --git a/source/LottieGen/Glob.cs b/source/LottieGen/Glob.cs
index e8ccd0c8..e28a958c 100644
--- a/source/LottieGen/Glob.cs
+++ b/source/LottieGen/Glob.cs
@@ -164,11 +164,13 @@ static Regex WildcardToRegex(string wildcard)
                 directoryPath = $".{Path.DirectorySeparatorChar}";
             }
 
-            if (directoryPath.EndsWith(":"))
+            if (directoryPath.Length == 2 && directoryPath[1] == ':' && char.IsLetter(directoryPath[0]))
             {
                 // The directory path is just a drive letter with no directory.
                 // Ensure it is treated as the current directory on the drive.
-                directoryPath += @".\";
+                // A name that merely ends in ':' is not a drive letter, and on a
+                // platform where that is a legal directory name it must be left alone.
+                directoryPath += $".{Path.DirectorySeparatorChar}";
             }
 
             // Ensure that we always have a trailing directory separator. Callers expect this.
diff --git a/tests/CompDataFlatbuffer.Tests/CoverageTests.cs b/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
index 7dfd7f21..b06281cf 100644
--- a/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
+++ b/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
@@ -451,8 +451,9 @@ void Add(CompositionObject? o)
                         Add(surfaceBrush.Surface as CompositionObject);
                         break;
                     case CompositionEffectBrush effectBrush:
-                        Add(effectBrush.GetEffectFactory());
-                        foreach (var source in effectBrush.GetEffectFactory().Effect.Sources)
+                        var effectFactory = effectBrush.GetEffectFactory();
+                        Add(effectFactory);
+                        foreach (var source in effectFactory.Effect.Sources)
                         {
                             Add(effectBrush.GetSourceParameter(source.Name));
                         }

From 53c3e34863e5f8fe82afcb52ddb8ed2db8a86b70 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 09:37:39 -0700
Subject: [PATCH 13/39] Fix LottieRuntime C++/WinRT COM interop and build
 errors

- Move #include <unknwn.h> before LottieRuntime.h (which pulls in
  C++/WinRT headers), satisfying the classic-COM interop requirement.
- Use winrt::implements<> with the projected interface listed first
  for GeometrySource and Effect, so winrt::make<> returns a com_ptr
  convertible to CompositionPath / IGraphicsEffect directly.
- Fix StrokeMiterLimit cast (was uint32_t, should be float).
- Default-construct WinRT projection type caches with nullptr fill
  value; these types have no default constructor.
- Link dxguid.lib for D2D1 effect CLSIDs (Composite, GaussianBlur).
---
 dlls/LottieRuntime/LottieRuntime.cpp     | 80 +++++++++++-------------
 dlls/LottieRuntime/LottieRuntime.vcxproj |  2 +-
 2 files changed, 39 insertions(+), 43 deletions(-)

diff --git a/dlls/LottieRuntime/LottieRuntime.cpp b/dlls/LottieRuntime/LottieRuntime.cpp
index b8368738..25cafeb3 100644
--- a/dlls/LottieRuntime/LottieRuntime.cpp
+++ b/dlls/LottieRuntime/LottieRuntime.cpp
@@ -31,6 +31,10 @@
 // to ask what a node actually is, because the buffer already said, and the answer was
 // consumed at the moment of creation.
 
+// <unknwn.h> must be included before any C++/WinRT header, and LottieRuntime.h
+// pulls one in (winrt/Windows.UI.Composition.h), so it has to come first here.
+#include <unknwn.h>
+
 #include "LottieRuntime.h"
 
 #include <cstdint>
@@ -161,26 +165,21 @@ namespace
     // and the only way to give one real content is the interop interface that hands
     // out a D2D geometry. This is the smallest object that does that.
     // ---------------------------------------------------------------------------
-    struct GeometrySource : winrt::implements<
-        GeometrySource,
-        winrt::Windows::Graphics::IGeometrySource2D,
-        ABI::Windows::Graphics::IGeometrySource2DInterop>
+    struct GeometrySource : winrt::implements<GeometrySource, winrt::Windows::Graphics::IGeometrySource2D, ABI::Windows::Graphics::IGeometrySource2DInterop>
     {
-        explicit GeometrySource(winrt::com_ptr<ID2D1Geometry> geometry) :
+        GeometrySource(winrt::com_ptr<ID2D1Geometry> geometry) :
             m_geometry(std::move(geometry))
         {
         }
 
-        IFACEMETHODIMP GetGeometry(ID2D1Geometry** value) noexcept
+        IFACEMETHODIMP GetGeometry(ID2D1Geometry** value) noexcept override
         {
             m_geometry.copy_to(value);
             return S_OK;
         }
 
-        IFACEMETHODIMP TryGetGeometryUsingFactory(ID2D1Factory*, ID2D1Geometry** value) noexcept
+        IFACEMETHODIMP TryGetGeometryUsingFactory(ID2D1Factory*, ID2D1Geometry** value) noexcept override
         {
-            // The geometry is device independent and was made by this component's own
-            // factory, so there is nothing useful to return for another factory.
             *value = nullptr;
             return E_NOTIMPL;
         }
@@ -212,15 +211,8 @@ namespace
     // and what to set on it. Implementing that directly avoids taking a dependency
     // on Win2D for the two effects the translator emits.
     // ---------------------------------------------------------------------------
-    struct Effect : winrt::implements<
-        Effect,
-        winrt::Windows::Graphics::Effects::IGraphicsEffect,
-        winrt::Windows::Graphics::Effects::IGraphicsEffectSource,
-        ABI::Windows::Graphics::Effects::IGraphicsEffectD2D1Interop>
+    struct Effect : winrt::implements<Effect, winrt::Windows::Graphics::Effects::IGraphicsEffect, ABI::Windows::Graphics::Effects::IGraphicsEffectD2D1Interop>
     {
-        // Both effects the translator emits have exactly one property, and in both
-        // cases it is property zero, so one class covers both and there is no need
-        // for a property table.
         Effect(GUID const& id, winrt::Windows::Foundation::IInspectable property) :
             m_id(id),
             m_property(std::move(property))
@@ -242,19 +234,19 @@ namespace
             m_sources.push_back(source);
         }
 
-        IFACEMETHODIMP GetEffectId(GUID* id) noexcept
+        IFACEMETHODIMP GetEffectId(GUID* id) noexcept override
         {
             *id = m_id;
             return S_OK;
         }
 
-        IFACEMETHODIMP GetPropertyCount(UINT* count) noexcept
+        IFACEMETHODIMP GetPropertyCount(UINT* count) noexcept override
         {
             *count = 1;
             return S_OK;
         }
 
-        IFACEMETHODIMP GetProperty(UINT index, ABI::Windows::Foundation::IPropertyValue** value) noexcept
+        IFACEMETHODIMP GetProperty(UINT index, ABI::Windows::Foundation::IPropertyValue** value) noexcept override
         {
             *value = nullptr;
 
@@ -263,17 +255,22 @@ namespace
                 return E_BOUNDS;
             }
 
-            return m_property.as<winrt::Windows::Foundation::IPropertyValue>()
-                ->QueryInterface(__uuidof(ABI::Windows::Foundation::IPropertyValue), reinterpret_cast<void**>(value));
+            auto pv = m_property.try_as<ABI::Windows::Foundation::IPropertyValue>();
+            if (pv)
+            {
+                *value = pv.detach();
+                return S_OK;
+            }
+            return E_NOINTERFACE;
         }
 
-        IFACEMETHODIMP GetSourceCount(UINT* count) noexcept
+        IFACEMETHODIMP GetSourceCount(UINT* count) noexcept override
         {
             *count = static_cast<UINT>(m_sources.size());
             return S_OK;
         }
 
-        IFACEMETHODIMP GetSource(UINT index, ABI::Windows::Graphics::Effects::IGraphicsEffectSource** source) noexcept
+        IFACEMETHODIMP GetSource(UINT index, ABI::Windows::Graphics::Effects::IGraphicsEffectSource** source) noexcept override
         {
             *source = nullptr;
 
@@ -291,9 +288,8 @@ namespace
         IFACEMETHODIMP GetNamedPropertyMapping(
             LPCWSTR,
             UINT*,
-            ABI::Windows::Graphics::Effects::GRAPHICS_EFFECT_PROPERTY_MAPPING*) noexcept
+            ABI::Windows::Graphics::Effects::GRAPHICS_EFFECT_PROPERTY_MAPPING*) noexcept override
         {
-            // Nothing animates an effect property by name, so there is nothing to map.
             return E_INVALIDARG;
         }
 
@@ -320,21 +316,21 @@ namespace
         Interpreter(Compositor const& compositor, Fb::LottieComposition const& root) :
             m_compositor(compositor),
             m_root(root),
-            m_visuals(Count(root.visuals())),
-            m_shapes(Count(root.shapes())),
-            m_geometries(Count(root.geometries())),
-            m_paths(Count(root.canvas_geometries())),
-            m_brushes(Count(root.brushes())),
-            m_gradientStops(Count(root.gradient_stops())),
-            m_viewBoxes(Count(root.view_boxes())),
-            m_clips(Count(root.clips())),
-            m_shadows(Count(root.shadows())),
-            m_surfaces(Count(root.surfaces())),
-            m_effects(Count(root.effects())),
-            m_easings(Count(root.easings())),
-            m_animations(Count(root.animations())),
-            m_propertySets(Count(root.property_sets())),
-            m_controllers(Count(root.controllers()))
+            m_visuals(Count(root.visuals()), nullptr),
+            m_shapes(Count(root.shapes()), nullptr),
+            m_geometries(Count(root.geometries()), nullptr),
+            m_paths(Count(root.canvas_geometries()), nullptr),
+            m_brushes(Count(root.brushes()), nullptr),
+            m_gradientStops(Count(root.gradient_stops()), nullptr),
+            m_viewBoxes(Count(root.view_boxes()), nullptr),
+            m_clips(Count(root.clips()), nullptr),
+            m_shadows(Count(root.shadows()), nullptr),
+            m_surfaces(Count(root.surfaces()), nullptr),
+            m_effects(Count(root.effects()), nullptr),
+            m_easings(Count(root.easings()), nullptr),
+            m_animations(Count(root.animations()), nullptr),
+            m_propertySets(Count(root.property_sets()), nullptr),
+            m_controllers(Count(root.controllers()), nullptr)
         {
         }
 
@@ -913,7 +909,7 @@ namespace
 
             if (auto value = source->stroke_miter_limit())
             {
-                target.StrokeMiterLimit(static_cast<uint32_t>(*value));
+                target.StrokeMiterLimit(static_cast<float>(*value));
             }
 
             if (auto value = source->stroke_thickness())
diff --git a/dlls/LottieRuntime/LottieRuntime.vcxproj b/dlls/LottieRuntime/LottieRuntime.vcxproj
index 846e7c15..10d16e61 100644
--- a/dlls/LottieRuntime/LottieRuntime.vcxproj
+++ b/dlls/LottieRuntime/LottieRuntime.vcxproj
@@ -60,7 +60,7 @@
       <StringPooling>true</StringPooling>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>d2d1.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>d2d1.lib;dxguid.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
 
       <!-- Discards the code for any node type the application never reaches. -->
       <OptimizeReferences>true</OptimizeReferences>

From ebce829ccdc85bd969a53bfd7edd048b0fa499ed Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 09:48:20 -0700
Subject: [PATCH 14/39] Add LottieRuntimeDump sample tool

A console tool that links LottieRuntime.vcxproj, loads a serialized
Lottie composition (.lcomp) given as its command-line argument, and
prints the composition object hierarchy of the resulting visual tree:
visuals, their shapes (recursively through container shapes), fill and
stroke brushes, and gradient stops. Each line shows the runtime class
name and, where set, the Comment property, so the printed tree can be
matched back to the source Lottie layers.

Builds via project reference to LottieRuntime.vcxproj and copies
LottieRuntime.dll next to the exe as a post-build step, since C++
project references do not do this automatically.
---
 dlls/LottieRuntimeDump/LottieRuntimeDump.cpp  | 200 ++++++++++++++++++
 .../LottieRuntimeDump.vcxproj                 |  74 +++++++
 2 files changed, 274 insertions(+)
 create mode 100644 dlls/LottieRuntimeDump/LottieRuntimeDump.cpp
 create mode 100644 dlls/LottieRuntimeDump/LottieRuntimeDump.vcxproj

diff --git a/dlls/LottieRuntimeDump/LottieRuntimeDump.cpp b/dlls/LottieRuntimeDump/LottieRuntimeDump.cpp
new file mode 100644
index 00000000..081c961a
--- /dev/null
+++ b/dlls/LottieRuntimeDump/LottieRuntimeDump.cpp
@@ -0,0 +1,200 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// Sample tool: loads a serialized Lottie composition (a .lcomp FlatBuffer produced
+// by LottieGen -Language flatbuffer or CompositionSerializer) through LottieRuntime,
+// then prints the composition object hierarchy of the resulting visual tree.
+//
+// Usage: LottieRuntimeDump.exe <path-to.lcomp>
+
+#include <unknwn.h>
+
+#include <LottieRuntime.h>
+
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Foundation.Collections.h>
+#include <winrt/Windows.UI.Composition.h>
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+using namespace winrt;
+using namespace winrt::Windows::UI::Composition;
+using namespace winrt::Windows::Foundation;
+using namespace winrt::Windows::Foundation::Collections;
+
+namespace
+{
+    std::vector<std::byte> ReadFileBytes(wchar_t const* path)
+    {
+        std::ifstream file(path, std::ios::binary | std::ios::ate);
+        if (!file)
+        {
+            throw std::runtime_error("Could not open input file.");
+        }
+
+        auto const size = static_cast<size_t>(file.tellg());
+        std::vector<std::byte> result(size);
+        file.seekg(0);
+        file.read(reinterpret_cast<char*>(result.data()), static_cast<std::streamsize>(size));
+        return result;
+    }
+
+    void PrintLine(int depth, std::wstring_view text)
+    {
+        std::wstring indent(static_cast<size_t>(depth) * 2, L' ');
+        std::wcout << indent << text << L"\n";
+    }
+
+    hstring RuntimeClassName(IInspectable const& node)
+    {
+        if (node == nullptr)
+        {
+            return L"(null)";
+        }
+
+        return winrt::get_class_name(node);
+    }
+
+    hstring CommentOf(CompositionObject const& node)
+    {
+        auto comment = node.Comment();
+        return comment.empty() ? L"" : (L" \"" + comment + L"\"");
+    }
+
+    void DumpBrush(CompositionBrush const& brush, int depth);
+    void DumpVisual(Visual const& visual, int depth);
+    void DumpShape(CompositionShape const& shape, int depth);
+
+    void DumpShape(CompositionShape const& shape, int depth)
+    {
+        if (shape == nullptr)
+        {
+            return;
+        }
+
+        PrintLine(depth, RuntimeClassName(shape) + CommentOf(shape));
+
+        if (auto containerShape = shape.try_as<CompositionContainerShape>())
+        {
+            for (auto const& child : containerShape.Shapes())
+            {
+                DumpShape(child, depth + 1);
+            }
+        }
+
+        if (auto spriteShape = shape.try_as<CompositionSpriteShape>())
+        {
+            if (auto fill = spriteShape.FillBrush())
+            {
+                PrintLine(depth + 1, L"FillBrush:");
+                DumpBrush(fill, depth + 2);
+            }
+
+            if (auto stroke = spriteShape.StrokeBrush())
+            {
+                PrintLine(depth + 1, L"StrokeBrush:");
+                DumpBrush(stroke, depth + 2);
+            }
+        }
+    }
+
+    void DumpBrush(CompositionBrush const& brush, int depth)
+    {
+        if (brush == nullptr)
+        {
+            return;
+        }
+
+        PrintLine(depth, RuntimeClassName(brush) + CommentOf(brush));
+
+        if (auto linearGradient = brush.try_as<CompositionLinearGradientBrush>())
+        {
+            for (auto const& stop : linearGradient.ColorStops())
+            {
+                PrintLine(depth + 1, L"ColorStop " + RuntimeClassName(stop));
+            }
+        }
+    }
+
+    void DumpVisual(Visual const& visual, int depth)
+    {
+        if (visual == nullptr)
+        {
+            return;
+        }
+
+        PrintLine(depth, RuntimeClassName(visual) + CommentOf(visual));
+
+        if (auto spriteVisual = visual.try_as<SpriteVisual>())
+        {
+            if (auto brush = spriteVisual.Brush())
+            {
+                PrintLine(depth + 1, L"Brush:");
+                DumpBrush(brush, depth + 2);
+            }
+
+            if (auto shapeVisual = visual.try_as<ShapeVisual>())
+            {
+                for (auto const& shape : shapeVisual.Shapes())
+                {
+                    DumpShape(shape, depth + 1);
+                }
+            }
+        }
+        else if (auto shapeVisual = visual.try_as<ShapeVisual>())
+        {
+            for (auto const& shape : shapeVisual.Shapes())
+            {
+                DumpShape(shape, depth + 1);
+            }
+        }
+
+        if (auto containerVisual = visual.try_as<ContainerVisual>())
+        {
+            for (auto const& child : containerVisual.Children())
+            {
+                DumpVisual(child, depth + 1);
+            }
+        }
+    }
+}
+
+int wmain(int argc, wchar_t* argv[])
+{
+    winrt::init_apartment();
+
+    if (argc != 2)
+    {
+        std::wcerr << L"Usage: LottieRuntimeDump.exe <path-to.lcomp>\n";
+        return 1;
+    }
+
+    try
+    {
+        auto bytes = ReadFileBytes(argv[1]);
+
+        Compositor compositor;
+        auto root = CommunityToolkit::WinUI::Lottie::LoadComposition(
+            compositor,
+            std::span<std::byte const>(bytes.data(), bytes.size()));
+
+        std::wcout << L"Composition object hierarchy:\n";
+        DumpVisual(root, 0);
+    }
+    catch (winrt::hresult_error const& e)
+    {
+        std::wcerr << L"Failed to load composition: " << e.message().c_str() << L"\n";
+        return 1;
+    }
+    catch (std::exception const& e)
+    {
+        std::cerr << "Failed: " << e.what() << "\n";
+        return 1;
+    }
+
+    return 0;
+}
diff --git a/dlls/LottieRuntimeDump/LottieRuntimeDump.vcxproj b/dlls/LottieRuntimeDump/LottieRuntimeDump.vcxproj
new file mode 100644
index 00000000..33e8a74c
--- /dev/null
+++ b/dlls/LottieRuntimeDump/LottieRuntimeDump.vcxproj
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}</ProjectGuid>
+    <RootNamespace>LottieRuntimeDump</RootNamespace>
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
+  </PropertyGroup>
+
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+
+  <PropertyGroup>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Release'">false</UseDebugLibraries>
+    <WholeProgramOptimization Condition="'$(Configuration)'=='Release'">true</WholeProgramOptimization>
+  </PropertyGroup>
+
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+      <PreprocessorDefinitions>WIN32_LEAN_AND_MEAN;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory)..\LottieRuntime;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <WarningLevel>Level4</WarningLevel>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <ExceptionHandling>Sync</ExceptionHandling>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+
+  <ItemGroup>
+    <ClCompile Include="LottieRuntimeDump.cpp" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LottieRuntime\LottieRuntime.vcxproj">
+      <Project>{6E0A5B4C-2F1D-4B7A-9C3E-1D5A8F0B2E47}</Project>
+    </ProjectReference>
+  </ItemGroup>
+
+  <Target Name="CopyLottieRuntimeDll" AfterTargets="Build">
+    <ItemGroup>
+      <LottieRuntimeDll Include="$(MSBuildThisFileDirectory)..\LottieRuntime\$(Platform)\$(Configuration)\LottieRuntime.dll" />
+    </ItemGroup>
+    <Copy SourceFiles="@(LottieRuntimeDll)" DestinationFolder="$(OutDir)" SkipUnchangedFiles="true" />
+  </Target>
+
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

From 4e2ac80f634312b41d53ab374144f659b6d58704 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 10:53:50 -0700
Subject: [PATCH 15/39] Add classic COM loader interface for LottieRuntime

Defines ILottieCompositionLoader (IID 3874B71B-05E6-42A9-B838-1AE7F0BA4E1C),
a classic COM interface accepting (UINT32 length, BYTE const* buffer, REFIID,
void**) that wraps LoadComposition for callers without a C++/WinRT toolchain.
Implements it as LottieCompositionLoader (CLSID 9F7B7089-F512-4BBC-81FE-4FF12B4DA159)
via winrt::implements<>, plus DllGetClassObject/DllCanUnloadNow exports and a
LottieRuntime.def to keep those names undecorated.

The class is never registered with the system: LottieRuntime.manifest is a
private-assembly manifest declaring the comClass, copied next to a consuming
exe and named directly by an ACTCTX, so CoCreateInstance resolves the CLSID
without any HKEY_CLASSES_ROOT entry.

Adds LottieRuntimeComTest, a console harness that builds an activation
context from that manifest, activates it, CoCreateInstances the loader, and
calls LoadComposition on a file argument.

Known issue: CoCreateInstance currently returns E_ACCESSDENIED (0x80070005)
even though CreateActCtx/ActivateActCtx succeed and the DLL exports
DllGetClassObject/DllCanUnloadNow correctly - the private-assembly activation
path needs further debugging before this is fully working end-to-end.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 dlls/LottieRuntime/LottieRuntime.def          |   6 +
 dlls/LottieRuntime/LottieRuntime.manifest     |  20 +++
 dlls/LottieRuntime/LottieRuntime.vcxproj      |  20 +++
 dlls/LottieRuntime/LottieRuntimeCom.cpp       | 123 +++++++++++++++
 dlls/LottieRuntime/LottieRuntimeCom.h         |  38 +++++
 .../LottieRuntimeComTest.cpp                  | 140 ++++++++++++++++++
 .../LottieRuntimeComTest.vcxproj              |  88 +++++++++++
 7 files changed, 435 insertions(+)
 create mode 100644 dlls/LottieRuntime/LottieRuntime.def
 create mode 100644 dlls/LottieRuntime/LottieRuntime.manifest
 create mode 100644 dlls/LottieRuntime/LottieRuntimeCom.cpp
 create mode 100644 dlls/LottieRuntime/LottieRuntimeCom.h
 create mode 100644 dlls/LottieRuntimeComTest/LottieRuntimeComTest.cpp
 create mode 100644 dlls/LottieRuntimeComTest/LottieRuntimeComTest.vcxproj

diff --git a/dlls/LottieRuntime/LottieRuntime.def b/dlls/LottieRuntime/LottieRuntime.def
new file mode 100644
index 00000000..7c435ed5
--- /dev/null
+++ b/dlls/LottieRuntime/LottieRuntime.def
@@ -0,0 +1,6 @@
+; Classic COM entry points must have undecorated names for CoCreateInstance's
+; loader (and for the test's GetProcAddress-based activation) to find them.
+LIBRARY LottieRuntime
+EXPORTS
+    DllGetClassObject   PRIVATE
+    DllCanUnloadNow     PRIVATE
diff --git a/dlls/LottieRuntime/LottieRuntime.manifest b/dlls/LottieRuntime/LottieRuntime.manifest
new file mode 100644
index 00000000..95945106
--- /dev/null
+++ b/dlls/LottieRuntime/LottieRuntime.manifest
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+  <!--
+    Declares the LottieCompositionLoader COM class as part of LottieRuntime.dll's
+    own identity, so any process whose activation context includes this manifest
+    (directly, or by referencing it as a dependent assembly) can CoCreateInstance
+    CLSID_LottieCompositionLoader without it ever being written to HKEY_CLASSES_ROOT.
+    This is the "registration-free COM" / isolated-application binding model.
+  -->
+  <assemblyIdentity
+      type="win32"
+      name="LottieRuntime"
+      version="1.0.0.0"
+      processorArchitecture="amd64" />
+  <file name="LottieRuntime.dll">
+    <comClass
+        clsid="{9F7B7089-F512-4BBC-81FE-4FF12B4DA159}"
+        threadingModel="Both" />
+  </file>
+</assembly>
diff --git a/dlls/LottieRuntime/LottieRuntime.vcxproj b/dlls/LottieRuntime/LottieRuntime.vcxproj
index 10d16e61..b9ef90ff 100644
--- a/dlls/LottieRuntime/LottieRuntime.vcxproj
+++ b/dlls/LottieRuntime/LottieRuntime.vcxproj
@@ -61,6 +61,7 @@
     </ClCompile>
     <Link>
       <AdditionalDependencies>d2d1.lib;dxguid.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ModuleDefinitionFile>LottieRuntime.def</ModuleDefinitionFile>
 
       <!-- Discards the code for any node type the application never reaches. -->
       <OptimizeReferences>true</OptimizeReferences>
@@ -70,12 +71,31 @@
 
   <ItemGroup>
     <ClInclude Include="LottieRuntime.h" />
+    <ClInclude Include="LottieRuntimeCom.h" />
     <ClInclude Include="Generated\lottie_comp_generated.h" />
   </ItemGroup>
 
   <ItemGroup>
     <ClCompile Include="LottieRuntime.cpp" />
+    <ClCompile Include="LottieRuntimeCom.cpp" />
   </ItemGroup>
 
+  <ItemGroup>
+    <!-- LottieRuntime.manifest is a private-assembly manifest, not embedded in
+         this DLL: it is copied next to a consumer's exe (see
+         LottieRuntimeComTest.vcxproj) and named directly by an ACTCTX, which is
+         how CoCreateInstance resolves CLSID_LottieCompositionLoader without
+         HKEY_CLASSES_ROOT registration or a linker-generated /MANIFEST, which
+         would otherwise merge in a trustInfo/UAC block that only an application
+         manifest is allowed to carry. -->
+    <None Include="LottieRuntime.manifest" />
+  </ItemGroup>
+
+  <ItemDefinitionGroup>
+    <Link>
+      <GenerateManifest>false</GenerateManifest>
+    </Link>
+  </ItemDefinitionGroup>
+
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
 </Project>
diff --git a/dlls/LottieRuntime/LottieRuntimeCom.cpp b/dlls/LottieRuntime/LottieRuntimeCom.cpp
new file mode 100644
index 00000000..9bb953b7
--- /dev/null
+++ b/dlls/LottieRuntime/LottieRuntimeCom.cpp
@@ -0,0 +1,123 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// The classic COM entry point declared in LottieRuntimeCom.h. This is the only
+// translation unit that needs to know both LoadComposition and classic COM, so it
+// stays out of LottieRuntime.cpp.
+
+#include <unknwn.h>
+
+#include "LottieRuntimeCom.h"
+#include "LottieRuntime.h"
+
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.UI.Composition.h>
+
+using namespace winrt::Windows::UI::Composition;
+
+
+namespace
+{
+    // The loader owns the Compositor it hands nodes out of. A caller that wants to
+    // parent the resulting Visual into its own tree does so through the WinRT
+    // interfaces it queried result for; it never needs to supply a Compositor of
+    // its own, because there is nothing it could usefully do with one that this
+    // object does not already do internally.
+    struct LottieCompositionLoader : winrt::implements<LottieCompositionLoader, ILottieCompositionLoader>
+    {
+        STDMETHODIMP LoadComposition(UINT32 length, BYTE const* buffer, REFIID riid, void** result) noexcept override
+        {
+            if (result == nullptr)
+            {
+                return E_POINTER;
+            }
+
+            *result = nullptr;
+
+            if (buffer == nullptr && length != 0)
+            {
+                return E_INVALIDARG;
+            }
+
+            try
+            {
+                auto const span = std::span(reinterpret_cast<std::byte const*>(buffer), length);
+                auto const visual = CommunityToolkit::WinUI::Lottie::LoadComposition(m_compositor, span);
+                return visual.as<::IUnknown>()->QueryInterface(riid, result);
+            }
+            catch (...)
+            {
+                return winrt::to_hresult();
+            }
+        }
+
+    private:
+        Compositor m_compositor;
+    };
+
+    // A minimal class factory: this DLL only ever creates LottieCompositionLoader,
+    // so there is no per-CLSID dispatch to do.
+    struct ClassFactory : winrt::implements<ClassFactory, IClassFactory>
+    {
+        STDMETHODIMP CreateInstance(::IUnknown* outer, REFIID riid, void** result) noexcept override
+        {
+            if (result == nullptr)
+            {
+                return E_POINTER;
+            }
+
+            *result = nullptr;
+
+            if (outer != nullptr)
+            {
+                return CLASS_E_NOAGGREGATION;
+            }
+
+            try
+            {
+                return winrt::make<LottieCompositionLoader>()->QueryInterface(riid, result);
+            }
+            catch (...)
+            {
+                return winrt::to_hresult();
+            }
+        }
+
+        STDMETHODIMP LockServer(BOOL) noexcept override
+        {
+            return S_OK;
+        }
+    };
+}
+
+extern "C" HRESULT __stdcall DllGetClassObject(REFCLSID rclsid, REFIID riid, void** result)
+{
+    if (result == nullptr)
+    {
+        return E_POINTER;
+    }
+
+    *result = nullptr;
+
+    if (rclsid != CLSID_LottieCompositionLoader)
+    {
+        return CLASS_E_CLASSNOTAVAILABLE;
+    }
+
+    try
+    {
+        return winrt::make<ClassFactory>()->QueryInterface(riid, result);
+    }
+    catch (...)
+    {
+        return winrt::to_hresult();
+    }
+}
+
+extern "C" HRESULT __stdcall DllCanUnloadNow()
+{
+    // The loader has no process-wide state, so it is always safe to unload; the
+    // reference-counted objects it hands out keep the DLL alive on their own.
+    return S_OK;
+}
diff --git a/dlls/LottieRuntime/LottieRuntimeCom.h b/dlls/LottieRuntime/LottieRuntimeCom.h
new file mode 100644
index 00000000..a08a4840
--- /dev/null
+++ b/dlls/LottieRuntime/LottieRuntimeCom.h
@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#pragma once
+
+#include <unknwn.h>
+#include <Windows.h>
+
+// A classic (non-WinRT) COM entry point for LoadComposition, for callers that only
+// have a byte buffer and a COM activation story, rather than a Compositor and a
+// C++/WinRT toolchain. It is not registered with the system: it is meant to be
+// activated registration-free, through an application manifest that names
+// LottieRuntime.dll and this CLSID (see the "Isolated applications and side-by-side
+// assemblies" COM activation model).
+//
+// The object it produces is the root Visual of the composition, queried for
+// whatever interface the caller asked for through riid - typically IInspectable,
+// ABI::Windows::UI::Composition::IVisual, or IUnknown.
+MIDL_INTERFACE("3874B71B-05E6-42A9-B838-1AE7F0BA4E1C")
+ILottieCompositionLoader : public IUnknown
+{
+public:
+    // Parses buffer (the output of LottieGen -Language flatbuffer, or equivalently
+    // CompositionSerializer) and produces the root Visual of the resulting tree.
+    //
+    // The buffer is treated as untrusted: it is verified before it is read, so a
+    // malformed buffer produces a failure HRESULT rather than undefined behaviour.
+    STDMETHOD(LoadComposition)(UINT32 length, BYTE const* buffer, REFIID riid, void** result) = 0;
+};
+
+// A caller activating this class registration-free never links against
+// LottieRuntime.dll's import library (there is no exported symbol to link
+// against for an in-proc COM server resolved purely through an activation
+// context), so the CLSID is a compile-time constant here rather than an
+// extern declaration.
+constexpr CLSID CLSID_LottieCompositionLoader = {
+    0x9f7b7089, 0xf512, 0x4bbc, { 0x81, 0xfe, 0x4f, 0xf1, 0x2b, 0x4d, 0xa1, 0x59 } };
diff --git a/dlls/LottieRuntimeComTest/LottieRuntimeComTest.cpp b/dlls/LottieRuntimeComTest/LottieRuntimeComTest.cpp
new file mode 100644
index 00000000..50de323f
--- /dev/null
+++ b/dlls/LottieRuntimeComTest/LottieRuntimeComTest.cpp
@@ -0,0 +1,140 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// Exercises the classic COM entry point declared in LottieRuntimeCom.h.
+//
+// LottieRuntime.dll is never registered with the system: its CLSID is only ever
+// known through LottieRuntime.manifest, its own private-assembly manifest, copied
+// next to this exe at build time. This test builds an activation context directly
+// out of that manifest - the same shape a real isolated application uses when it
+// carries a private assembly instead of registering a DLL - and activates it for
+// the duration of the CoCreateInstance call, which is the reason CoCreateInstance
+// resolves the CLSID without anything ever touching HKEY_CLASSES_ROOT.
+
+#include <unknwn.h>
+
+#include <Windows.h>
+#include <combaseapi.h>
+#include <shlwapi.h>
+
+#include <cstdio>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <winrt/base.h>
+
+#include "LottieRuntimeCom.h"
+
+namespace
+{
+    std::vector<std::byte> ReadCompositionFile(wchar_t const* path)
+    {
+        HANDLE file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+        if (file == INVALID_HANDLE_VALUE)
+        {
+            throw std::runtime_error("Could not open the composition file.");
+        }
+
+        LARGE_INTEGER size{};
+        GetFileSizeEx(file, &size);
+
+        std::vector<std::byte> buffer(static_cast<size_t>(size.QuadPart));
+        DWORD read = 0;
+        BOOL const ok = ::ReadFile(file, buffer.data(), static_cast<DWORD>(buffer.size()), &read, nullptr);
+        CloseHandle(file);
+
+        if (!ok || read != buffer.size())
+        {
+            throw std::runtime_error("Could not read the composition file.");
+        }
+
+        return buffer;
+    }
+}
+
+int wmain(int argc, wchar_t* argv[])
+{
+    if (argc != 2)
+    {
+        fwprintf(stderr, L"Usage: LottieRuntimeComTest <path-to-flatbuffer-composition>\n");
+        return 1;
+    }
+
+    try
+    {
+        winrt::check_hresult(CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED));
+
+        // The manifest is a private assembly for this exe: it declares the CLSID
+        // directly rather than through a level of indirection, so it is loaded
+        // straight into the activation context as the primary manifest, with no
+        // separate application manifest and no HKEY_CLASSES_ROOT registration.
+        wchar_t moduleDir[MAX_PATH]{};
+        GetModuleFileNameW(nullptr, moduleDir, MAX_PATH);
+        PathRemoveFileSpecW(moduleDir);
+
+        std::wstring const manifestPath = std::wstring(moduleDir) + L"\\LottieRuntime.manifest";
+
+        ACTCTXW actCtx{ sizeof(ACTCTXW) };
+        actCtx.lpSource = manifestPath.c_str();
+        actCtx.lpAssemblyDirectory = moduleDir;
+        actCtx.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
+
+        HANDLE const hActCtx = CreateActCtxW(&actCtx);
+        if (hActCtx == INVALID_HANDLE_VALUE)
+        {
+            fwprintf(stderr, L"CreateActCtx failed: %lu (manifest: %s, dir: %s)\n", GetLastError(), manifestPath.c_str(), moduleDir);
+            return 1;
+        }
+
+        ULONG_PTR cookie = 0;
+        ActivateActCtx(hActCtx, &cookie);
+
+        winrt::com_ptr<ILottieCompositionLoader> loader;
+        HRESULT const hr = CoCreateInstance(
+            CLSID_LottieCompositionLoader,
+            nullptr,
+            CLSCTX_INPROC_SERVER,
+            __uuidof(ILottieCompositionLoader),
+            loader.put_void());
+
+        DeactivateActCtx(0, cookie);
+        ReleaseActCtx(hActCtx);
+
+        if (FAILED(hr))
+        {
+            fwprintf(stderr, L"CoCreateInstance failed (registration-free activation did not resolve the CLSID): 0x%08X (last error %lu)\n", hr, GetLastError());
+            return 1;
+        }
+
+        auto const buffer = ReadCompositionFile(argv[1]);
+
+        winrt::com_ptr<::IUnknown> root;
+        HRESULT const loadHr = loader->LoadComposition(
+            static_cast<UINT32>(buffer.size()),
+            reinterpret_cast<BYTE const*>(buffer.data()),
+            __uuidof(::IUnknown),
+            root.put_void());
+
+        if (FAILED(loadHr))
+        {
+            fwprintf(stderr, L"LoadComposition failed: 0x%08X\n", loadHr);
+            return 1;
+        }
+
+        wprintf(L"Registration-free activation succeeded; loaded a composition with a root object at %p.\n", root.get());
+        return 0;
+    }
+    catch (winrt::hresult_error const& e)
+    {
+        fwprintf(stderr, L"%s\n", e.message().c_str());
+        return 1;
+    }
+    catch (std::exception const& e)
+    {
+        fprintf(stderr, "%s\n", e.what());
+        return 1;
+    }
+}
diff --git a/dlls/LottieRuntimeComTest/LottieRuntimeComTest.vcxproj b/dlls/LottieRuntimeComTest/LottieRuntimeComTest.vcxproj
new file mode 100644
index 00000000..9ca4357c
--- /dev/null
+++ b/dlls/LottieRuntimeComTest/LottieRuntimeComTest.vcxproj
@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{2B6C4A1E-7F3D-4B7A-9C3E-3D5A8F0B2E49}</ProjectGuid>
+    <RootNamespace>LottieRuntimeComTest</RootNamespace>
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
+
+    <!-- This test builds its own activation context out of an in-memory manifest
+         at runtime (see LottieRuntimeComTest.cpp), so its own exe must not carry
+         a default /manifest that Windows auto-activates instead. -->
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+
+  <PropertyGroup>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Release'">false</UseDebugLibraries>
+    <WholeProgramOptimization Condition="'$(Configuration)'=='Release'">true</WholeProgramOptimization>
+  </PropertyGroup>
+
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+      <PreprocessorDefinitions>WIN32_LEAN_AND_MEAN;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory)..\LottieRuntime;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <WarningLevel>Level4</WarningLevel>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <ExceptionHandling>Sync</ExceptionHandling>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>windowsapp.lib;shlwapi.lib;ole32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateManifest>false</GenerateManifest>
+    </Link>
+  </ItemDefinitionGroup>
+
+  <ItemGroup>
+    <ClCompile Include="LottieRuntimeComTest.cpp" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LottieRuntime\LottieRuntime.vcxproj">
+      <Project>{6E0A5B4C-2F1D-4B7A-9C3E-1D5A8F0B2E47}</Project>
+    </ProjectReference>
+  </ItemGroup>
+
+  <!-- No HKEY_CLASSES_ROOT registration ever happens: the test only needs
+       LottieRuntime.dll to sit next to the exe, since its embedded manifest is
+       what an activation context resolves the CLSID against. -->
+  <Target Name="CopyLottieRuntimeDll" AfterTargets="Build">
+    <ItemGroup>
+      <LottieRuntimeDll Include="$(MSBuildThisFileDirectory)..\LottieRuntime\$(Platform)\$(Configuration)\LottieRuntime.dll" />
+      <!-- The private-assembly manifest that declares the CLSID; resolved by
+           name (LottieRuntime.manifest) from the assembly directory the test
+           points ACTCTX at, independent of anything embedded in the DLL. -->
+      <LottieRuntimeManifest Include="$(MSBuildThisFileDirectory)..\LottieRuntime\LottieRuntime.manifest" />
+    </ItemGroup>
+    <Copy SourceFiles="@(LottieRuntimeDll)" DestinationFolder="$(OutDir)" SkipUnchangedFiles="true" />
+    <Copy SourceFiles="@(LottieRuntimeManifest)" DestinationFolder="$(OutDir)" SkipUnchangedFiles="true" />
+  </Target>
+
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

From 75d048b10d5d28773de040cc8a3560610923a397 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 11:42:48 -0700
Subject: [PATCH 16/39] Initialize DispatcherQueue for COM loader

Create the desktop DispatcherQueue lazily before activating the loader's Compositor. This keeps CoCreateInstance side-effect-free and gives Windows.UI.Composition the thread infrastructure it requires.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 dlls/LottieRuntime/LottieRuntime.vcxproj |  2 +-
 dlls/LottieRuntime/LottieRuntimeCom.cpp  | 31 +++++++++++++++++++-----
 2 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/dlls/LottieRuntime/LottieRuntime.vcxproj b/dlls/LottieRuntime/LottieRuntime.vcxproj
index b9ef90ff..afa1301e 100644
--- a/dlls/LottieRuntime/LottieRuntime.vcxproj
+++ b/dlls/LottieRuntime/LottieRuntime.vcxproj
@@ -60,7 +60,7 @@
       <StringPooling>true</StringPooling>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>d2d1.lib;dxguid.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CoreMessaging.lib;d2d1.lib;dxguid.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>LottieRuntime.def</ModuleDefinitionFile>
 
       <!-- Discards the code for any node type the application never reaches. -->
diff --git a/dlls/LottieRuntime/LottieRuntimeCom.cpp b/dlls/LottieRuntime/LottieRuntimeCom.cpp
index 9bb953b7..2f531373 100644
--- a/dlls/LottieRuntime/LottieRuntimeCom.cpp
+++ b/dlls/LottieRuntime/LottieRuntimeCom.cpp
@@ -11,7 +11,10 @@
 #include "LottieRuntimeCom.h"
 #include "LottieRuntime.h"
 
+#include <DispatcherQueue.h>
+
 #include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.System.h>
 #include <winrt/Windows.UI.Composition.h>
 
 using namespace winrt::Windows::UI::Composition;
@@ -19,11 +22,8 @@ using namespace winrt::Windows::UI::Composition;
 
 namespace
 {
-    // The loader owns the Compositor it hands nodes out of. A caller that wants to
-    // parent the resulting Visual into its own tree does so through the WinRT
-    // interfaces it queried result for; it never needs to supply a Compositor of
-    // its own, because there is nothing it could usefully do with one that this
-    // object does not already do internally.
+    // The loader creates its Compositor on the first load. Desktop threads need a
+    // DispatcherQueue before Windows.UI.Composition can activate a Compositor.
     struct LottieCompositionLoader : winrt::implements<LottieCompositionLoader, ILottieCompositionLoader>
     {
         STDMETHODIMP LoadComposition(UINT32 length, BYTE const* buffer, REFIID riid, void** result) noexcept override
@@ -42,6 +42,24 @@ namespace
 
             try
             {
+                if (!m_compositor)
+                {
+                    if (!winrt::Windows::System::DispatcherQueue::GetForCurrentThread())
+                    {
+                        DispatcherQueueOptions const options{
+                            sizeof(DispatcherQueueOptions),
+                            DQTYPE_THREAD_CURRENT,
+                            DQTAT_COM_NONE,
+                        };
+
+                        winrt::check_hresult(CreateDispatcherQueueController(
+                            options,
+                            reinterpret_cast<PDISPATCHERQUEUECONTROLLER*>(winrt::put_abi(m_dispatcherQueueController))));
+                    }
+
+                    m_compositor = Compositor();
+                }
+
                 auto const span = std::span(reinterpret_cast<std::byte const*>(buffer), length);
                 auto const visual = CommunityToolkit::WinUI::Lottie::LoadComposition(m_compositor, span);
                 return visual.as<::IUnknown>()->QueryInterface(riid, result);
@@ -53,7 +71,8 @@ namespace
         }
 
     private:
-        Compositor m_compositor;
+        winrt::Windows::System::DispatcherQueueController m_dispatcherQueueController{ nullptr };
+        Compositor m_compositor{ nullptr };
     };
 
     // A minimal class factory: this DLL only ever creates LottieCompositionLoader,

From c2a9e3663f4d570c92ff3cd305586e99bbf8016c Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 11:44:07 -0700
Subject: [PATCH 17/39] Track LottieRuntime COM server lifetime

Use C++/WinRT's module lock for IClassFactory::LockServer and DllCanUnloadNow so COM cannot unload the DLL while its objects remain alive.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 dlls/LottieRuntime/LottieRuntimeCom.cpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/dlls/LottieRuntime/LottieRuntimeCom.cpp b/dlls/LottieRuntime/LottieRuntimeCom.cpp
index 2f531373..dc664301 100644
--- a/dlls/LottieRuntime/LottieRuntimeCom.cpp
+++ b/dlls/LottieRuntime/LottieRuntimeCom.cpp
@@ -103,8 +103,17 @@ namespace
             }
         }
 
-        STDMETHODIMP LockServer(BOOL) noexcept override
+        STDMETHODIMP LockServer(BOOL lock) noexcept override
         {
+            if (lock)
+            {
+                ++winrt::get_module_lock();
+            }
+            else
+            {
+                --winrt::get_module_lock();
+            }
+
             return S_OK;
         }
     };
@@ -136,7 +145,5 @@ extern "C" HRESULT __stdcall DllGetClassObject(REFCLSID rclsid, REFIID riid, voi
 
 extern "C" HRESULT __stdcall DllCanUnloadNow()
 {
-    // The loader has no process-wide state, so it is always safe to unload; the
-    // reference-counted objects it hands out keep the DLL alive on their own.
-    return S_OK;
+    return winrt::get_module_lock() == 0 ? S_OK : S_FALSE;
 }

From 6bc9cc7d31dc5347ebf7c84cd0204c13201ec7f3 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 11:44:20 -0700
Subject: [PATCH 18/39] Add LottieRuntime COM trace collector

Build the COM test, record it under Time Travel Debugging, and collect optional SideBySide and COM event logs into one directory.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 tools/collect-lottieruntime-cocreate-ttd.ps1 | 38 ++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 tools/collect-lottieruntime-cocreate-ttd.ps1

diff --git a/tools/collect-lottieruntime-cocreate-ttd.ps1 b/tools/collect-lottieruntime-cocreate-ttd.ps1
new file mode 100644
index 00000000..4c494585
--- /dev/null
+++ b/tools/collect-lottieruntime-cocreate-ttd.ps1
@@ -0,0 +1,38 @@
+param(
+    [string]$VsDevShell = "C:\Program Files\Microsoft Visual Studio\18\Professional\Common7\Tools\Launch-VsDevShell.ps1",
+    [string]$Config = "Debug",
+    [string]$Platform = "x64",
+    [string]$TraceDir = ".\trace",
+    [string]$RunName = "LottieRuntimeComTest_E_ACCESSDENIED.run",
+    [string]$InputPath = ".\nonexistent.bin",
+    [string]$TtTracer = "tttracer.exe"
+)
+
+$ErrorActionPreference = "Stop"
+
+$RepoRoot = Split-Path -Parent $PSScriptRoot
+Set-Location $RepoRoot
+
+& $VsDevShell -SkipAutomaticLocation
+
+msbuild "dlls\LottieRuntimeComTest\LottieRuntimeComTest.vcxproj" `
+    /p:Platform=$Platform `
+    /p:Configuration=$Config `
+    /t:Rebuild `
+    /nologo `
+    /v:minimal
+
+New-Item -ItemType Directory -Force -Path $TraceDir | Out-Null
+
+$ExePath = ".\dlls\LottieRuntimeComTest\$Platform\$Config\LottieRuntimeComTest.exe"
+$RunPath = Join-Path $TraceDir $RunName
+
+& $TtTracer -out $RunPath $ExePath $InputPath
+
+wevtutil qe Application /q:"*[System[Provider[@Name='Microsoft-Windows-SideBySide']]]" /c:30 /rd:true /f:text > (Join-Path $TraceDir "sxs-events.txt")
+wevtutil qe Application /q:"*[System[Provider[@Name='Microsoft-Windows-COMRuntime']]]" /c:30 /rd:true /f:text > (Join-Path $TraceDir "com-events.txt")
+
+Write-Host "Done."
+Write-Host "Trace: $RunPath"
+Write-Host "SxS:   $(Join-Path $TraceDir 'sxs-events.txt')"
+Write-Host "COM:   $(Join-Path $TraceDir 'com-events.txt')"

From 9449edd4317e92756b7affa5197c553c75e3e331 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 11:45:42 -0700
Subject: [PATCH 19/39] Remove temporary COM trace collector

Remove the one-off investigation helper now that the activation failure is diagnosed.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 tools/collect-lottieruntime-cocreate-ttd.ps1 | 38 --------------------
 1 file changed, 38 deletions(-)
 delete mode 100644 tools/collect-lottieruntime-cocreate-ttd.ps1

diff --git a/tools/collect-lottieruntime-cocreate-ttd.ps1 b/tools/collect-lottieruntime-cocreate-ttd.ps1
deleted file mode 100644
index 4c494585..00000000
--- a/tools/collect-lottieruntime-cocreate-ttd.ps1
+++ /dev/null
@@ -1,38 +0,0 @@
-param(
-    [string]$VsDevShell = "C:\Program Files\Microsoft Visual Studio\18\Professional\Common7\Tools\Launch-VsDevShell.ps1",
-    [string]$Config = "Debug",
-    [string]$Platform = "x64",
-    [string]$TraceDir = ".\trace",
-    [string]$RunName = "LottieRuntimeComTest_E_ACCESSDENIED.run",
-    [string]$InputPath = ".\nonexistent.bin",
-    [string]$TtTracer = "tttracer.exe"
-)
-
-$ErrorActionPreference = "Stop"
-
-$RepoRoot = Split-Path -Parent $PSScriptRoot
-Set-Location $RepoRoot
-
-& $VsDevShell -SkipAutomaticLocation
-
-msbuild "dlls\LottieRuntimeComTest\LottieRuntimeComTest.vcxproj" `
-    /p:Platform=$Platform `
-    /p:Configuration=$Config `
-    /t:Rebuild `
-    /nologo `
-    /v:minimal
-
-New-Item -ItemType Directory -Force -Path $TraceDir | Out-Null
-
-$ExePath = ".\dlls\LottieRuntimeComTest\$Platform\$Config\LottieRuntimeComTest.exe"
-$RunPath = Join-Path $TraceDir $RunName
-
-& $TtTracer -out $RunPath $ExePath $InputPath
-
-wevtutil qe Application /q:"*[System[Provider[@Name='Microsoft-Windows-SideBySide']]]" /c:30 /rd:true /f:text > (Join-Path $TraceDir "sxs-events.txt")
-wevtutil qe Application /q:"*[System[Provider[@Name='Microsoft-Windows-COMRuntime']]]" /c:30 /rd:true /f:text > (Join-Path $TraceDir "com-events.txt")
-
-Write-Host "Done."
-Write-Host "Trace: $RunPath"
-Write-Host "SxS:   $(Join-Path $TraceDir 'sxs-events.txt')"
-Write-Host "COM:   $(Join-Path $TraceDir 'com-events.txt')"

From 76617d8bf29c1db8955e0933b67b8f36bcd3c0c4 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 14:05:28 -0700
Subject: [PATCH 20/39] Fix interpreter realization gaps

Handle omitted property-set state, expose the required effect-source interface, cache and cycle-check canvas geometries and strings, preserve sprite shadows, and load URI and stream image surfaces.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 .gitmodules                          |   3 +
 dlls/LottieRuntime/LottieRuntime.cpp | 132 ++++++++++++++++++++++++---
 external/flatbuffers                 |   1 +
 3 files changed, 121 insertions(+), 15 deletions(-)
 create mode 100644 .gitmodules
 create mode 160000 external/flatbuffers

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 00000000..d67d60a6
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "external/flatbuffers"]
+	path = external/flatbuffers
+	url = https://github.com/google/flatbuffers.git
diff --git a/dlls/LottieRuntime/LottieRuntime.cpp b/dlls/LottieRuntime/LottieRuntime.cpp
index 25cafeb3..f2d55262 100644
--- a/dlls/LottieRuntime/LottieRuntime.cpp
+++ b/dlls/LottieRuntime/LottieRuntime.cpp
@@ -51,9 +51,13 @@
 #include <winrt/Windows.Foundation.Collections.h>
 #include <winrt/Windows.Foundation.Numerics.h>
 #include <winrt/Windows.Graphics.Effects.h>
+#include <winrt/Windows.Storage.Streams.h>
 #include <winrt/Windows.UI.h>
 #include <winrt/Windows.UI.Composition.h>
 
+#undef GetCurrentTime
+#include <winrt/Windows.UI.Xaml.Media.h>
+
 #include "Generated/lottie_comp_generated.h"
 
 namespace Fb = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema;
@@ -211,7 +215,11 @@ namespace
     // and what to set on it. Implementing that directly avoids taking a dependency
     // on Win2D for the two effects the translator emits.
     // ---------------------------------------------------------------------------
-    struct Effect : winrt::implements<Effect, winrt::Windows::Graphics::Effects::IGraphicsEffect, ABI::Windows::Graphics::Effects::IGraphicsEffectD2D1Interop>
+    struct Effect : winrt::implements<
+        Effect,
+        winrt::Windows::Graphics::Effects::IGraphicsEffect,
+        winrt::Windows::Graphics::Effects::IGraphicsEffectSource,
+        ABI::Windows::Graphics::Effects::IGraphicsEffectD2D1Interop>
     {
         Effect(GUID const& id, winrt::Windows::Foundation::IInspectable property) :
             m_id(id),
@@ -316,10 +324,14 @@ namespace
         Interpreter(Compositor const& compositor, Fb::LottieComposition const& root) :
             m_compositor(compositor),
             m_root(root),
+            m_strings(Count(root.strings())),
+            m_stringCached(Count(root.strings())),
             m_visuals(Count(root.visuals()), nullptr),
             m_shapes(Count(root.shapes()), nullptr),
             m_geometries(Count(root.geometries()), nullptr),
             m_paths(Count(root.canvas_geometries()), nullptr),
+            m_canvasGeometries(Count(root.canvas_geometries())),
+            m_canvasGeometryStates(Count(root.canvas_geometries())),
             m_brushes(Count(root.brushes()), nullptr),
             m_gradientStops(Count(root.gradient_stops()), nullptr),
             m_viewBoxes(Count(root.view_boxes()), nullptr),
@@ -348,7 +360,7 @@ namespace
             return vector == nullptr ? 0 : vector->size();
         }
 
-        winrt::hstring GetString(uint32_t index) const
+        winrt::hstring GetString(uint32_t index)
         {
             if (index == NullIndex)
             {
@@ -357,12 +369,17 @@ namespace
 
             auto const* strings = m_root.strings();
             Check(strings != nullptr && index < strings->size());
-            auto const* value = strings->Get(index);
-            Check(value != nullptr);
+            if (!m_stringCached[index])
+            {
+                auto const* value = strings->Get(index);
+                Check(value != nullptr);
 
-            // The buffer holds UTF-8 and WinRT wants UTF-16, so this is the one place
-            // where text is copied out of the buffer.
-            return winrt::to_hstring(std::string_view(value->c_str(), value->size()));
+                m_strings[index] =
+                    winrt::to_hstring(std::string_view(value->c_str(), value->size()));
+                m_stringCached[index] = true;
+            }
+
+            return m_strings[index];
         }
 
         // -----------------------------------------------------------------------
@@ -396,6 +413,11 @@ namespace
 
         void StartAnimations(CompositionObject const& target, Fb::CompObj const* source)
         {
+            if (source == nullptr)
+            {
+                return;
+            }
+
             auto const* animators = source->animators();
             if (animators == nullptr)
             {
@@ -471,14 +493,25 @@ namespace
                         target.InsertScalar(name, value->scalar());
                         break;
                     case Fb::PropertyValueType::Vector2:
-                        target.InsertVector2(name, { Vector(value)->x(), Vector(value)->y() });
+                    {
+                        auto const* vector = Vector(value);
+                        target.InsertVector2(name, { vector->x(), vector->y() });
                         break;
+                    }
                     case Fb::PropertyValueType::Vector3:
-                        target.InsertVector3(name, { Vector(value)->x(), Vector(value)->y(), Vector(value)->z() });
+                    {
+                        auto const* vector = Vector(value);
+                        target.InsertVector3(name, { vector->x(), vector->y(), vector->z() });
                         break;
+                    }
                     case Fb::PropertyValueType::Vector4:
-                        target.InsertVector4(name, { Vector(value)->x(), Vector(value)->y(), Vector(value)->z(), Vector(value)->w() });
+                    {
+                        auto const* vector = Vector(value);
+                        target.InsertVector4(
+                            name,
+                            { vector->x(), vector->y(), vector->z(), vector->w() });
                         break;
+                    }
                     case Fb::PropertyValueType::None:
                         break;
                     default:
@@ -636,6 +669,11 @@ namespace
                     sprite.Brush(GetBrush(brush));
                 }
 
+                if (auto shadow = source->shadow(); shadow != NullIndex)
+                {
+                    sprite.Shadow(GetShadow(shadow));
+                }
+
                 container = sprite;
                 break;
             }
@@ -680,6 +718,8 @@ namespace
                 ThrowMalformed();
             }
 
+            // Any case that resolves referenced objects must populate m_visuals
+            // first. The assignment below only precedes the child walk.
             // Cached before the children are walked, so that a cycle terminates.
             m_visuals[index] = container;
 
@@ -815,6 +855,8 @@ namespace
                 ThrowMalformed();
             }
 
+            // Any case that resolves referenced objects must populate m_shapes
+            // first. The assignment below cannot terminate recursive graphs.
             m_shapes[index] = result;
 
             ApplyShapeProperties(result, source);
@@ -1047,6 +1089,28 @@ namespace
         }
 
         winrt::com_ptr<ID2D1Geometry> BuildGeometry(uint32_t index)
+        {
+            Check(index < m_canvasGeometries.size());
+
+            switch (m_canvasGeometryStates[index])
+            {
+            case CanvasGeometryState::Realized:
+                return m_canvasGeometries[index];
+            case CanvasGeometryState::Realizing:
+                ThrowMalformed();
+            case CanvasGeometryState::Unrealized:
+                break;
+            }
+
+            m_canvasGeometryStates[index] = CanvasGeometryState::Realizing;
+            auto result = BuildGeometryCore(index);
+            Check(result != nullptr);
+            m_canvasGeometries[index] = result;
+            m_canvasGeometryStates[index] = CanvasGeometryState::Realized;
+            return result;
+        }
+
+        winrt::com_ptr<ID2D1Geometry> BuildGeometryCore(uint32_t index)
         {
             auto const* source = At(m_root.canvas_geometries(), index);
 
@@ -1344,6 +1408,8 @@ namespace
                 ThrowMalformed();
             }
 
+            // Any case that resolves referenced objects must populate m_brushes
+            // first. The assignment below cannot terminate recursive graphs.
             m_brushes[index] = result;
 
             Initialize(result, source->base());
@@ -1484,6 +1550,8 @@ namespace
                 ThrowMalformed();
             }
 
+            // Any case that resolves referenced objects must populate m_clips
+            // first. The assignment below cannot terminate recursive graphs.
             m_clips[index] = result;
 
             if (auto const* value = source->center_point())
@@ -1610,12 +1678,35 @@ namespace
                 break;
             }
             case Fb::SurfaceKind::LoadedImageFromUri:
+            {
+                auto const uri = source->uri();
+                Check(uri != NullIndex);
+                m_surfaces[index] =
+                    winrt::Windows::UI::Xaml::Media::LoadedImageSurface::StartLoadFromUri(
+                        winrt::Windows::Foundation::Uri(GetString(uri)));
+                break;
+            }
             case Fb::SurfaceKind::LoadedImageFromStream:
-                // LoadedImageSurface lives in Windows.UI.Xaml.Media, so an
-                // interpreter that is usable outside XAML cannot create one. The
-                // translator only emits these for animations that embed an image,
-                // which the Lottie feature set this interpreter targets excludes.
-                ThrowUnsupported();
+            {
+                auto const* bytes = source->bytes();
+                Check(bytes != nullptr);
+
+                winrt::Windows::Storage::Streams::InMemoryRandomAccessStream stream;
+                winrt::Windows::Storage::Streams::DataWriter writer(
+                    stream.GetOutputStreamAt(0));
+                writer.WriteBytes(
+                    winrt::array_view<uint8_t const>(
+                        bytes->data(),
+                        bytes->data() + bytes->size()));
+                writer.StoreAsync().get();
+                writer.FlushAsync().get();
+                stream.Seek(0);
+
+                m_surfaces[index] =
+                    winrt::Windows::UI::Xaml::Media::LoadedImageSurface::StartLoadFromStream(
+                        stream);
+                break;
+            }
             default:
                 ThrowMalformed();
             }
@@ -1951,14 +2042,25 @@ namespace
         Compositor const& m_compositor;
         Fb::LottieComposition const& m_root;
 
+        enum class CanvasGeometryState : uint8_t
+        {
+            Unrealized,
+            Realizing,
+            Realized,
+        };
+
         // The caches. Each is exactly as long as the matching vector in the buffer,
         // so a lookup is a bounds check and an index. Each holds the least derived
         // type that any reference to that category needs, which is what stops a
         // realized node from ever having to be cast back to what it was.
+        std::vector<winrt::hstring> m_strings;
+        std::vector<uint8_t> m_stringCached;
         std::vector<Visual> m_visuals;
         std::vector<CompositionShape> m_shapes;
         std::vector<CompositionGeometry> m_geometries;
         std::vector<CompositionPath> m_paths;
+        std::vector<winrt::com_ptr<ID2D1Geometry>> m_canvasGeometries;
+        std::vector<CanvasGeometryState> m_canvasGeometryStates;
         std::vector<CompositionBrush> m_brushes;
         std::vector<CompositionColorGradientStop> m_gradientStops;
         std::vector<CompositionViewBox> m_viewBoxes;
diff --git a/external/flatbuffers b/external/flatbuffers
new file mode 160000
index 00000000..5761d6e6
--- /dev/null
+++ b/external/flatbuffers
@@ -0,0 +1 @@
+Subproject commit 5761d6e67af841d15ee21bc1ce9a78ffa9cf939e

From 7e0245e5a2252db490ceb5028867342185eee601 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 14:51:15 -0700
Subject: [PATCH 21/39] Regenerate native bindings from pinned FlatBuffers

Use the FlatBuffers headers and flatc from pinned upstream default-branch commit 5761d6e for C++. Keep C# generation on the 25.2.10 runtime available through Microsoft's configured NuGet feed.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 build/RegenerateFlatbuffers.ps1               | 35 ++++----
 .../Generated/lottie_comp_generated.h         | 89 ++++++++++++-------
 2 files changed, 78 insertions(+), 46 deletions(-)

diff --git a/build/RegenerateFlatbuffers.ps1 b/build/RegenerateFlatbuffers.ps1
index 8cc52934..1a2e0efc 100644
--- a/build/RegenerateFlatbuffers.ps1
+++ b/build/RegenerateFlatbuffers.ps1
@@ -4,42 +4,47 @@
 # need flatc installed in order to build. Run this script after any change to
 # source/LottieFlatbuffer/lottie_comp.fbs, and check in the result.
 #
-# The version of flatc MUST match the version of the Google.FlatBuffers NuGet
-# package referenced by dlls/CompDataFlatbuffer/CompDataFlatbuffer.dll.csproj,
-# because the generated C# calls a version-stamped validation method
-# (FlatBufferConstants.FLATBUFFERS_<version>) that only exists in the matching
-# package.
-#
-# Download flatc from https://github.com/google/flatbuffers/releases/tag/v25.2.10
+# C# output must match the Google.FlatBuffers package available through the
+# configured Microsoft feed. C++ output must match external/flatbuffers.
 
 [CmdletBinding()]
 param(
-    # Path to the flatc executable. Defaults to whatever is on the PATH.
-    [string]$Flatc = "flatc"
+    # C# code must match the Google.FlatBuffers package version.
+    [string]$CSharpFlatc = "flatc",
+
+    # C++ code must match the headers in external/flatbuffers.
+    [Parameter(Mandatory)]
+    [string]$CppFlatc
 )
 
 $ErrorActionPreference = "Stop"
 
-$expectedVersion = "25.2.10"
+$expectedCSharpVersion = "25.2.10"
+$expectedCppVersion = "25.12.19"
 
 $repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..")
 $schema = Join-Path $repoRoot "source/LottieFlatbuffer/lottie_comp.fbs"
 $csharpOut = Join-Path $repoRoot "source/CompDataFlatbuffer/Generated"
 $cppOut = Join-Path $repoRoot "dlls/LottieRuntime/Generated"
 
-$actualVersion = (& $Flatc --version) -replace '^flatc version ', ''
-if ($actualVersion.Trim() -ne $expectedVersion) {
-    throw "flatc version $expectedVersion is required, but '$Flatc' is version $($actualVersion.Trim())."
+$actualCSharpVersion = (& $CSharpFlatc --version) -replace '^flatc version ', ''
+if ($actualCSharpVersion.Trim() -ne $expectedCSharpVersion) {
+    throw "C# flatc version $expectedCSharpVersion is required, but '$CSharpFlatc' is version $($actualCSharpVersion.Trim())."
+}
+
+$actualCppVersion = (& $CppFlatc --version) -replace '^flatc version ', ''
+if ($actualCppVersion.Trim() -ne $expectedCppVersion) {
+    throw "C++ flatc version $expectedCppVersion is required, but '$CppFlatc' is version $($actualCppVersion.Trim())."
 }
 
 New-Item -ItemType Directory -Force -Path $csharpOut, $cppOut | Out-Null
 
 # --gen-onefile keeps the checked in C# to a single file rather than one file
 # per type spread over a namespace directory tree.
-& $Flatc --csharp --gen-onefile -o $csharpOut $schema
+& $CSharpFlatc --csharp --gen-onefile -o $csharpOut $schema
 if ($LASTEXITCODE -ne 0) { throw "flatc failed to generate C#." }
 
-& $Flatc --cpp --scoped-enums -o $cppOut $schema
+& $CppFlatc --cpp --scoped-enums -o $cppOut $schema
 if ($LASTEXITCODE -ne 0) { throw "flatc failed to generate C++." }
 
 Write-Host "Generated FlatBuffers code from $schema"
diff --git a/dlls/LottieRuntime/Generated/lottie_comp_generated.h b/dlls/LottieRuntime/Generated/lottie_comp_generated.h
index b2eba1b4..eb3b0700 100644
--- a/dlls/LottieRuntime/Generated/lottie_comp_generated.h
+++ b/dlls/LottieRuntime/Generated/lottie_comp_generated.h
@@ -9,8 +9,8 @@
 // Ensure the included flatbuffers.h is the same version as when this file was
 // generated, otherwise it may not be compatible.
 static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
-              FLATBUFFERS_VERSION_MINOR == 2 &&
-              FLATBUFFERS_VERSION_REVISION == 10,
+              FLATBUFFERS_VERSION_MINOR == 12 &&
+              FLATBUFFERS_VERSION_REVISION == 19,
              "Non-compatible flatbuffers version included");
 
 namespace CommunityToolkit {
@@ -959,7 +959,8 @@ struct Animator FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t controller() const {
     return GetField<uint32_t>(VT_CONTROLLER, 4294967295);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_PROPERTY, 4) &&
            VerifyField<uint32_t>(verifier, VT_ANIMATION, 4) &&
@@ -1020,7 +1021,8 @@ struct CompObj FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t properties() const {
     return GetField<uint32_t>(VT_PROPERTIES, 4294967295);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_COMMENT, 4) &&
            VerifyOffset(verifier, VT_ANIMATORS) &&
@@ -1104,7 +1106,8 @@ struct PropertyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color() const {
     return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *>(VT_COLOR);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<uint8_t>(verifier, VT_TYPE, 1) &&
@@ -1173,7 +1176,8 @@ struct ReferenceParameter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   uint32_t target() const {
     return GetField<uint32_t>(VT_TARGET, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<uint32_t>(verifier, VT_TARGET, 4) &&
@@ -1224,7 +1228,8 @@ struct SourceParameter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t brush() const {
     return GetField<uint32_t>(VT_BRUSH, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<uint32_t>(verifier, VT_BRUSH, 4) &&
@@ -1299,7 +1304,8 @@ struct KeyFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t path() const {
     return GetField<uint32_t>(VT_PATH, 4294967295);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<float>(verifier, VT_PROGRESS, 4) &&
            VerifyField<uint32_t>(verifier, VT_EASING, 4) &&
@@ -1450,7 +1456,8 @@ struct Visual FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t shadow() const {
     return GetField<uint32_t>(VT_SHADOW, 4294967295);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -1716,7 +1723,8 @@ struct Shape FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Optional<float> stroke_thickness() const {
     return GetOptional<float, float>(VT_STROKE_THICKNESS);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -1962,7 +1970,8 @@ struct Geometry FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *radius() const {
     return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_RADIUS);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2152,7 +2161,8 @@ struct Brush FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SourceParameter>> *source_parameters() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SourceParameter>> *>(VT_SOURCE_PARAMETERS);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2391,7 +2401,8 @@ struct GradientStop FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   float offset() const {
     return GetField<float>(VT_OFFSET, 0.0f);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2449,7 +2460,8 @@ struct ViewBox FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size() const {
     return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_SIZE);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2529,7 +2541,8 @@ struct Clip FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t geometry() const {
     return GetField<uint32_t>(VT_GEOMETRY, 4294967295);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2647,7 +2660,8 @@ struct Shadow FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Optional<uint8_t> source_policy() const {
     return GetOptional<uint8_t, uint8_t>(VT_SOURCE_POLICY);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2755,7 +2769,8 @@ struct Surface FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<uint8_t> *bytes() const {
     return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_BYTES);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2871,7 +2886,8 @@ struct Effect FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   float blur_amount() const {
     return GetField<float>(VT_BLUR_AMOUNT, 0.0f);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2987,7 +3003,8 @@ struct Easing FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Optional<bool> is_final_step_single_frame() const {
     return GetOptional<uint8_t, bool>(VT_IS_FINAL_STEP_SINGLE_FRAME);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -3105,7 +3122,8 @@ struct Animation FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Optional<uint8_t> interpolation_color_space() const {
     return GetOptional<uint8_t, uint8_t>(VT_INTERPOLATION_COLOR_SPACE);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -3225,7 +3243,8 @@ struct PropertySet FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValue>> *values() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValue>> *>(VT_VALUES);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -3310,7 +3329,8 @@ struct Controller FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool is_custom() const {
     return GetField<uint8_t>(VT_IS_CUSTOM, 0) != 0;
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -3400,7 +3420,8 @@ struct PropertyBinding FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *default_color() const {
     return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *>(VT_DEFAULT_COLOR);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<uint32_t>(verifier, VT_DISPLAY_NAME, 4) &&
@@ -3485,7 +3506,8 @@ struct Marker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   float duration_progress() const {
     return GetField<float>(VT_DURATION_PROGRESS, 0.0f);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<float>(verifier, VT_PROGRESS, 4) &&
@@ -3566,7 +3588,8 @@ struct Metadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t theming_property_set() const {
     return GetField<uint32_t>(VT_THEMING_PROPERTY_SET, 4294967295);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<float>(verifier, VT_WIDTH, 4) &&
@@ -3757,7 +3780,8 @@ struct LottieComposition FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   const ::flatbuffers::Vector<uint32_t> *custom_controllers() const {
     return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_CUSTOM_CONTROLLERS);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint16_t>(verifier, VT_SCHEMA_VERSION, 2) &&
            VerifyField<uint16_t>(verifier, VT_REQUIRED_UAP_VERSION, 2) &&
@@ -4077,7 +4101,8 @@ struct CanvasGeometry FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   float radius_y() const {
     return GetField<float>(VT_RADIUS_Y, 0.0f);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
            VerifyField<uint32_t>(verifier, VT_A, 4) &&
@@ -4266,14 +4291,16 @@ inline bool SizePrefixedLottieCompositionBufferHasIdentifier(const void *buf) {
       buf, LottieCompositionIdentifier(), true);
 }
 
+template <bool B = false>
 inline bool VerifyLottieCompositionBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(LottieCompositionIdentifier());
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifyBuffer<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(LottieCompositionIdentifier());
 }
 
+template <bool B = false>
 inline bool VerifySizePrefixedLottieCompositionBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(LottieCompositionIdentifier());
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(LottieCompositionIdentifier());
 }
 
 inline const char *LottieCompositionExtension() {

From 70f33daba3c6b0a6c43d7447702b9dcf266b7578 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 14:51:27 -0700
Subject: [PATCH 22/39] Support custom animation controllers

Create custom controllers explicitly, pass them to StartAnimation, and initialize root property sets before descending into children so controller expressions can bind to root progress.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 dlls/LottieRuntime/LottieRuntime.cpp | 91 +++++++++++++++++++---------
 1 file changed, 63 insertions(+), 28 deletions(-)

diff --git a/dlls/LottieRuntime/LottieRuntime.cpp b/dlls/LottieRuntime/LottieRuntime.cpp
index f2d55262..0aad6531 100644
--- a/dlls/LottieRuntime/LottieRuntime.cpp
+++ b/dlls/LottieRuntime/LottieRuntime.cpp
@@ -16,13 +16,11 @@
 //    takes the least derived type. Everything lives in one translation unit so that
 //    the linker can discard what an application does not reach.
 //
-//  * Runtime cost second. Every node is realized at most once and is then found by
-//    indexing an array, never by hashing. The buffer is read in place; nothing is
-//    copied out of it.
+//  * Runtime cost second. Nodes and strings are realized once, then found by indexing
+//    dense arrays. The FlatBuffer remains the object model.
 //
-//  * Transient memory third. The only allocations are the realization caches, which
-//    are exactly as large as the node vectors in the buffer, and the D2D geometries,
-//    which are released as soon as they have been handed to a CompositionPath.
+//  * Transient memory third. Cache sizes come directly from the buffer. D2D geometry
+//    remains cached during interpretation so shared subgraphs stay shared.
 //
 // Calls are made through the least derived interface that has the member being used.
 // A node is only ever known by its concrete type inside the function that creates it;
@@ -31,8 +29,7 @@
 // to ask what a node actually is, because the buffer already said, and the answer was
 // consumed at the moment of creation.
 
-// <unknwn.h> must be included before any C++/WinRT header, and LottieRuntime.h
-// pulls one in (winrt/Windows.UI.Composition.h), so it has to come first here.
+// C++/WinRT requires <unknwn.h> before projected headers.
 #include <unknwn.h>
 
 #include "LottieRuntime.h"
@@ -389,6 +386,12 @@ namespace
         // does to every node is available on CompositionObject.
         // -----------------------------------------------------------------------
         void Initialize(CompositionObject const& target, Fb::CompObj const* source)
+        {
+            InitializeProperties(target, source);
+            StartAnimations(target, source);
+        }
+
+        void InitializeProperties(CompositionObject const& target, Fb::CompObj const* source)
         {
             if (source == nullptr)
             {
@@ -408,7 +411,6 @@ namespace
                 RealizePropertySet(properties, target.Properties());
             }
 
-            StartAnimations(target, source);
         }
 
         void StartAnimations(CompositionObject const& target, Fb::CompObj const* source)
@@ -433,18 +435,28 @@ namespace
                 auto animation = GetAnimation(animator->animation());
                 Check(animation != nullptr);
 
-                // A custom controller is one that drives a property that is not its
-                // own, which the composition engine has no way to express. The
-                // managed instantiator rejects these too.
                 auto controllerIndex = animator->controller();
-                if (controllerIndex != NullIndex && IsCustomController(controllerIndex))
+                auto customController =
+                    controllerIndex != NullIndex && IsCustomController(controllerIndex)
+                    ? GetController(controllerIndex)
+                    : nullptr;
+
+                if (customController != nullptr &&
+                    animation.try_as<ExpressionAnimation>() != nullptr)
                 {
-                    ThrowUnsupported();
+                    ThrowMalformed();
                 }
 
-                target.StartAnimation(property, animation);
+                if (customController != nullptr)
+                {
+                    target.StartAnimation(property, animation, customController);
+                }
+                else
+                {
+                    target.StartAnimation(property, animation);
+                }
 
-                if (controllerIndex != NullIndex)
+                if (controllerIndex != NullIndex && customController == nullptr)
                 {
                     RealizeController(controllerIndex, target, property);
                 }
@@ -559,7 +571,7 @@ namespace
         // -----------------------------------------------------------------------
         // Controllers.
         // -----------------------------------------------------------------------
-        void RealizeController(uint32_t index, CompositionObject const& target, winrt::hstring const& property)
+        void RealizeController(uint32_t index, AnimationController const& controller)
         {
             Check(index < m_controllers.size());
 
@@ -568,12 +580,6 @@ namespace
                 return;
             }
 
-            auto controller = target.TryGetAnimationController(property);
-            if (controller == nullptr)
-            {
-                return;
-            }
-
             m_controllers[index] = controller;
 
             auto const* source = At(m_root.controllers(), index);
@@ -586,6 +592,37 @@ namespace
             Initialize(controller, source->base());
         }
 
+        void RealizeController(
+            uint32_t index,
+            CompositionObject const& target,
+            winrt::hstring const& property)
+        {
+            auto controller = target.TryGetAnimationController(property);
+            Check(controller != nullptr);
+            RealizeController(index, controller);
+        }
+
+        AnimationController GetController(uint32_t index)
+        {
+            Check(index < m_controllers.size());
+            auto const* source = At(m_root.controllers(), index);
+
+            if (m_controllers[index] == nullptr)
+            {
+                if (source->is_custom())
+                {
+                    RealizeController(index, m_compositor.CreateAnimationController());
+                }
+                else
+                {
+                    GetObjectReference(source->target_object());
+                }
+            }
+
+            Check(m_controllers[index] != nullptr);
+            return m_controllers[index];
+        }
+
         // -----------------------------------------------------------------------
         // Object references.
         //
@@ -623,10 +660,7 @@ namespace
                 Check(result != nullptr);
                 return result;
             }
-            case Fb::ObjectCategory::Controller:
-                // A controller is realized by the animator that produces it, so it
-                // can never be the target of a reference.
-                ThrowMalformed();
+            case Fb::ObjectCategory::Controller: return GetController(index);
             default:
                 ThrowMalformed();
             }
@@ -724,6 +758,7 @@ namespace
             m_visuals[index] = container;
 
             ApplyVisualProperties(container, source);
+            InitializeProperties(container, source->base());
 
             if (auto const* children = source->children(); children != nullptr)
             {
@@ -736,7 +771,7 @@ namespace
                 }
             }
 
-            Initialize(container, source->base());
+            StartAnimations(container, source->base());
 
             return container;
         }

From b8867d711b3725fc40172fd580e4dbf5aa12754a Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 15:49:45 -0700
Subject: [PATCH 23/39] Make LottieRuntime DLL ABI-only

Remove exported C++ symbols, require callers to own the DispatcherQueue, support architecture-neutral registration-free activation, load embedded image streams synchronously, and make the native project portable from its packaged source layout.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 dlls/LottieRuntime/LottieRuntime.cpp      | 22 +++++++++++---------
 dlls/LottieRuntime/LottieRuntime.h        | 25 ++++++++---------------
 dlls/LottieRuntime/LottieRuntime.manifest | 10 ++-------
 dlls/LottieRuntime/LottieRuntime.vcxproj  | 19 ++++++++---------
 dlls/LottieRuntime/LottieRuntimeCom.cpp   | 17 +++------------
 dlls/LottieRuntime/LottieRuntimeCom.h     | 25 ++++++-----------------
 6 files changed, 40 insertions(+), 78 deletions(-)

diff --git a/dlls/LottieRuntime/LottieRuntime.cpp b/dlls/LottieRuntime/LottieRuntime.cpp
index 0aad6531..e059bbcc 100644
--- a/dlls/LottieRuntime/LottieRuntime.cpp
+++ b/dlls/LottieRuntime/LottieRuntime.cpp
@@ -41,6 +41,8 @@
 #include <vector>
 
 #include <d2d1_1.h>
+#include <shcore.h>
+#include <shlwapi.h>
 #include <windows.graphics.effects.interop.h>
 #include <Windows.Graphics.Interop.h>
 
@@ -1726,16 +1728,16 @@ namespace
                 auto const* bytes = source->bytes();
                 Check(bytes != nullptr);
 
-                winrt::Windows::Storage::Streams::InMemoryRandomAccessStream stream;
-                winrt::Windows::Storage::Streams::DataWriter writer(
-                    stream.GetOutputStreamAt(0));
-                writer.WriteBytes(
-                    winrt::array_view<uint8_t const>(
-                        bytes->data(),
-                        bytes->data() + bytes->size()));
-                writer.StoreAsync().get();
-                writer.FlushAsync().get();
-                stream.Seek(0);
+                winrt::com_ptr<IStream> byteStream;
+                byteStream.attach(SHCreateMemStream(bytes->data(), bytes->size()));
+                Check(byteStream != nullptr);
+
+                winrt::Windows::Storage::Streams::IRandomAccessStream stream{ nullptr };
+                winrt::check_hresult(CreateRandomAccessStreamOverStream(
+                    byteStream.get(),
+                    BSOS_DEFAULT,
+                    winrt::guid_of<decltype(stream)>(),
+                    winrt::put_abi(stream)));
 
                 m_surfaces[index] =
                     winrt::Windows::UI::Xaml::Media::LoadedImageSurface::StartLoadFromStream(
diff --git a/dlls/LottieRuntime/LottieRuntime.h b/dlls/LottieRuntime/LottieRuntime.h
index 28a65f6f..76b182cd 100644
--- a/dlls/LottieRuntime/LottieRuntime.h
+++ b/dlls/LottieRuntime/LottieRuntime.h
@@ -4,24 +4,17 @@
 
 #pragma once
 
+#include <unknwn.h>
+
 #include <cstddef>
 #include <span>
 
 #include <winrt/Windows.UI.Composition.h>
 
-// The component is usable either as a DLL or compiled straight into an application.
-// Define LOTTIERUNTIME_STATIC to build it in, and LOTTIERUNTIME_EXPORTS when building
-// the DLL itself.
-#if defined(LOTTIERUNTIME_STATIC)
-#define LOTTIERUNTIME_API
-#elif defined(LOTTIERUNTIME_EXPORTS)
-#define LOTTIERUNTIME_API __declspec(dllexport)
-#else
-#define LOTTIERUNTIME_API __declspec(dllimport)
-#endif
-
 namespace CommunityToolkit::WinUI::Lottie
 {
+    // LoadComposition is the direct-link C++ API.
+    // DLL callers use ILottieCompositionLoader from LottieRuntimeCom.h.
     // Builds the composition described by a serialized Lottie composition.
     //
     // The buffer is the output of LottieGen -Language flatbuffer, or equivalently of
@@ -35,20 +28,18 @@ namespace CommunityToolkit::WinUI::Lottie
     // returned by ProgressPropertySet, so playback is driven by animating that single
     // property.
     //
-    // The result is the least derived type that describes the root, because a caller
-    // that only parents the tree and drives its progress never needs anything more.
+    // Visual is sufficient for parenting the root and driving its progress.
     //
     // Throws winrt::hresult_error with E_INVALIDARG if the buffer is not a well formed
     // composition, and E_NOTIMPL if it requires a feature this build does not have.
-    LOTTIERUNTIME_API winrt::Windows::UI::Composition::Visual LoadComposition(
+    winrt::Windows::UI::Composition::Visual LoadComposition(
         winrt::Windows::UI::Composition::Compositor const& compositor,
         std::span<std::byte const> buffer);
 
     // The property set that drives the animation. Animating its "Progress" scalar from
     // 0 to 1 plays the animation once.
     //
-    // This is the property set of the visual returned by LoadComposition, so it is only
-    // a convenience; it exists so that callers do not have to know that detail.
-    LOTTIERUNTIME_API winrt::Windows::UI::Composition::CompositionPropertySet ProgressPropertySet(
+    // Returns the root Visual's property set.
+    winrt::Windows::UI::Composition::CompositionPropertySet ProgressPropertySet(
         winrt::Windows::UI::Composition::Visual const& root);
 }
diff --git a/dlls/LottieRuntime/LottieRuntime.manifest b/dlls/LottieRuntime/LottieRuntime.manifest
index 95945106..d93a09f5 100644
--- a/dlls/LottieRuntime/LottieRuntime.manifest
+++ b/dlls/LottieRuntime/LottieRuntime.manifest
@@ -1,17 +1,11 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
-  <!--
-    Declares the LottieCompositionLoader COM class as part of LottieRuntime.dll's
-    own identity, so any process whose activation context includes this manifest
-    (directly, or by referencing it as a dependent assembly) can CoCreateInstance
-    CLSID_LottieCompositionLoader without it ever being written to HKEY_CLASSES_ROOT.
-    This is the "registration-free COM" / isolated-application binding model.
-  -->
+  <!-- Private assembly identity for registration-free COM activation. -->
   <assemblyIdentity
       type="win32"
       name="LottieRuntime"
       version="1.0.0.0"
-      processorArchitecture="amd64" />
+      processorArchitecture="*" />
   <file name="LottieRuntime.dll">
     <comClass
         clsid="{9F7B7089-F512-4BBC-81FE-4FF12B4DA159}"
diff --git a/dlls/LottieRuntime/LottieRuntime.vcxproj b/dlls/LottieRuntime/LottieRuntime.vcxproj
index afa1301e..075df1be 100644
--- a/dlls/LottieRuntime/LottieRuntime.vcxproj
+++ b/dlls/LottieRuntime/LottieRuntime.vcxproj
@@ -31,6 +31,10 @@
          Anything newer is reached through the buffer's required UAP version, which
          a caller checks before it loads. -->
     <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
+    <FlatBuffersIncludeDirectory
+        Condition="'$(FlatBuffersIncludeDirectory)'=='' and Exists('$(MSBuildThisFileDirectory)..\..\external\flatbuffers\include')">$(MSBuildThisFileDirectory)..\..\external\flatbuffers\include</FlatBuffersIncludeDirectory>
+    <FlatBuffersIncludeDirectory
+        Condition="'$(FlatBuffersIncludeDirectory)'==''">$(MSBuildThisFileDirectory)flatbuffers\include</FlatBuffersIncludeDirectory>
   </PropertyGroup>
 
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
@@ -45,8 +49,8 @@
   <ItemDefinitionGroup>
     <ClCompile>
       <LanguageStandard>stdcpp20</LanguageStandard>
-      <PreprocessorDefinitions>LOTTIERUNTIME_EXPORTS;WIN32_LEAN_AND_MEAN;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory);$(MSBuildThisFileDirectory)packages\flatbuffers\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32_LEAN_AND_MEAN;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory);$(FlatBuffersIncludeDirectory);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <WarningLevel>Level4</WarningLevel>
       <TreatWarningAsError>true</TreatWarningAsError>
 
@@ -60,7 +64,7 @@
       <StringPooling>true</StringPooling>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>CoreMessaging.lib;d2d1.lib;dxguid.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>d2d1.lib;dxguid.lib;shcore.lib;shlwapi.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>LottieRuntime.def</ModuleDefinitionFile>
 
       <!-- Discards the code for any node type the application never reaches. -->
@@ -81,13 +85,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <!-- LottieRuntime.manifest is a private-assembly manifest, not embedded in
-         this DLL: it is copied next to a consumer's exe (see
-         LottieRuntimeComTest.vcxproj) and named directly by an ACTCTX, which is
-         how CoCreateInstance resolves CLSID_LottieCompositionLoader without
-         HKEY_CLASSES_ROOT registration or a linker-generated /MANIFEST, which
-         would otherwise merge in a trustInfo/UAC block that only an application
-         manifest is allowed to carry. -->
+    <!-- Consumers activate this private assembly manifest instead of registering
+         the class in HKEY_CLASSES_ROOT. -->
     <None Include="LottieRuntime.manifest" />
   </ItemGroup>
 
diff --git a/dlls/LottieRuntime/LottieRuntimeCom.cpp b/dlls/LottieRuntime/LottieRuntimeCom.cpp
index dc664301..b82fef6c 100644
--- a/dlls/LottieRuntime/LottieRuntimeCom.cpp
+++ b/dlls/LottieRuntime/LottieRuntimeCom.cpp
@@ -11,8 +11,6 @@
 #include "LottieRuntimeCom.h"
 #include "LottieRuntime.h"
 
-#include <DispatcherQueue.h>
-
 #include <winrt/Windows.Foundation.h>
 #include <winrt/Windows.System.h>
 #include <winrt/Windows.UI.Composition.h>
@@ -22,8 +20,8 @@ using namespace winrt::Windows::UI::Composition;
 
 namespace
 {
-    // The loader creates its Compositor on the first load. Desktop threads need a
-    // DispatcherQueue before Windows.UI.Composition can activate a Compositor.
+    // The caller owns the thread's DispatcherQueue. It must outlive every Visual
+    // returned by this loader.
     struct LottieCompositionLoader : winrt::implements<LottieCompositionLoader, ILottieCompositionLoader>
     {
         STDMETHODIMP LoadComposition(UINT32 length, BYTE const* buffer, REFIID riid, void** result) noexcept override
@@ -46,15 +44,7 @@ namespace
                 {
                     if (!winrt::Windows::System::DispatcherQueue::GetForCurrentThread())
                     {
-                        DispatcherQueueOptions const options{
-                            sizeof(DispatcherQueueOptions),
-                            DQTYPE_THREAD_CURRENT,
-                            DQTAT_COM_NONE,
-                        };
-
-                        winrt::check_hresult(CreateDispatcherQueueController(
-                            options,
-                            reinterpret_cast<PDISPATCHERQUEUECONTROLLER*>(winrt::put_abi(m_dispatcherQueueController))));
+                        return E_ILLEGAL_METHOD_CALL;
                     }
 
                     m_compositor = Compositor();
@@ -71,7 +61,6 @@ namespace
         }
 
     private:
-        winrt::Windows::System::DispatcherQueueController m_dispatcherQueueController{ nullptr };
         Compositor m_compositor{ nullptr };
     };
 
diff --git a/dlls/LottieRuntime/LottieRuntimeCom.h b/dlls/LottieRuntime/LottieRuntimeCom.h
index a08a4840..d4997a9d 100644
--- a/dlls/LottieRuntime/LottieRuntimeCom.h
+++ b/dlls/LottieRuntime/LottieRuntimeCom.h
@@ -7,32 +7,19 @@
 #include <unknwn.h>
 #include <Windows.h>
 
-// A classic (non-WinRT) COM entry point for LoadComposition, for callers that only
-// have a byte buffer and a COM activation story, rather than a Compositor and a
-// C++/WinRT toolchain. It is not registered with the system: it is meant to be
-// activated registration-free, through an application manifest that names
-// LottieRuntime.dll and this CLSID (see the "Isolated applications and side-by-side
-// assemblies" COM activation model).
+// COM interface for DLL activation. LottieRuntime.manifest declares the class for
+// registration-free COM activation.
 //
-// The object it produces is the root Visual of the composition, queried for
-// whatever interface the caller asked for through riid - typically IInspectable,
-// ABI::Windows::UI::Composition::IVisual, or IUnknown.
+// riid selects the interface returned for the root Visual.
 MIDL_INTERFACE("3874B71B-05E6-42A9-B838-1AE7F0BA4E1C")
 ILottieCompositionLoader : public IUnknown
 {
 public:
-    // Parses buffer (the output of LottieGen -Language flatbuffer, or equivalently
-    // CompositionSerializer) and produces the root Visual of the resulting tree.
-    //
-    // The buffer is treated as untrusted: it is verified before it is read, so a
-    // malformed buffer produces a failure HRESULT rather than undefined behaviour.
+    // buffer contains LottieGen -Language flatbuffer output. Validation precedes
+    // every read; malformed data returns E_INVALIDARG.
     STDMETHOD(LoadComposition)(UINT32 length, BYTE const* buffer, REFIID riid, void** result) = 0;
 };
 
-// A caller activating this class registration-free never links against
-// LottieRuntime.dll's import library (there is no exported symbol to link
-// against for an in-proc COM server resolved purely through an activation
-// context), so the CLSID is a compile-time constant here rather than an
-// extern declaration.
+// Registration-free clients do not link an import library.
 constexpr CLSID CLSID_LottieCompositionLoader = {
     0x9f7b7089, 0xf512, 0x4bbc, { 0x81, 0xfe, 0x4f, 0xf1, 0x2b, 0x4d, 0xa1, 0x59 } };

From d28d46ae76f952bb10d0232471a0f35e7386748d Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 15:49:59 -0700
Subject: [PATCH 24/39] Consolidate LottieRuntime sample tooling

Replace separate validation and dump executables with LottieRuntime.exe supporting validate, --dump, and --show modes. Document JSON conversion and package the complete native runtime source set, COM project, generated binding, and FlatBuffers headers in LottieGen.nupkg.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 LottieGen/DotnetTool/LottieGen.csproj         |  15 +
 dlls/LottieRuntime/README.md                  | 118 ++++--
 .../LottieRuntimeComTest.cpp                  | 140 -------
 .../LottieRuntimeComTest.vcxproj              |  88 -----
 dlls/LottieRuntimeDump/LottieRuntimeDump.cpp  | 200 ----------
 dlls/LottieRuntimeTool/LottieRuntime.cpp      | 363 ++++++++++++++++++
 .../LottieRuntime.vcxproj}                    |  20 +-
 dlls/LottieRuntimeTool/README.md              |  54 +++
 8 files changed, 524 insertions(+), 474 deletions(-)
 delete mode 100644 dlls/LottieRuntimeComTest/LottieRuntimeComTest.cpp
 delete mode 100644 dlls/LottieRuntimeComTest/LottieRuntimeComTest.vcxproj
 delete mode 100644 dlls/LottieRuntimeDump/LottieRuntimeDump.cpp
 create mode 100644 dlls/LottieRuntimeTool/LottieRuntime.cpp
 rename dlls/{LottieRuntimeDump/LottieRuntimeDump.vcxproj => LottieRuntimeTool/LottieRuntime.vcxproj} (73%)
 create mode 100644 dlls/LottieRuntimeTool/README.md

diff --git a/LottieGen/DotnetTool/LottieGen.csproj b/LottieGen/DotnetTool/LottieGen.csproj
index 6ae9c9ac..79e61622 100644
--- a/LottieGen/DotnetTool/LottieGen.csproj
+++ b/LottieGen/DotnetTool/LottieGen.csproj
@@ -37,4 +37,19 @@
   <ItemGroup>
     <PackageReference Include="Google.FlatBuffers" Version="25.2.10" />
   </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\..\dlls\LottieRuntime\LottieRuntime.cpp" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\dlls\LottieRuntime\LottieRuntime.h" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\dlls\LottieRuntime\LottieRuntimeCom.cpp" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\dlls\LottieRuntime\LottieRuntimeCom.h" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\dlls\LottieRuntime\LottieRuntime.def" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\dlls\LottieRuntime\LottieRuntime.manifest" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\dlls\LottieRuntime\LottieRuntime.vcxproj" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\dlls\LottieRuntime\README.md" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\dlls\LottieRuntime\Generated\lottie_comp_generated.h" Pack="true" PackagePath="LottieRuntime\Generated\" />
+    <None Include="..\..\external\flatbuffers\include\**\*" Pack="true" PackagePath="LottieRuntime\flatbuffers\include\" />
+    <None Include="..\..\external\flatbuffers\LICENSE" Pack="true" PackagePath="LottieRuntime\flatbuffers\" />
+    <None Include="..\..\LICENSE.md" Pack="true" PackagePath="LottieRuntime\" />
+  </ItemGroup>
 </Project>
diff --git a/dlls/LottieRuntime/README.md b/dlls/LottieRuntime/README.md
index 6c2f0541..c5784f88 100644
--- a/dlls/LottieRuntime/README.md
+++ b/dlls/LottieRuntime/README.md
@@ -2,23 +2,22 @@
 
 A native runtime interpreter for Lottie animations.
 
-`LottieRuntime` builds a Windows.UI.Composition visual tree from a serialized
-composition, at runtime, without a JSON parser and without generated code. It is a
-header and a source file, so it can be built as a DLL that several applications
-share, or compiled straight into one.
+`LottieRuntime` builds a `Windows.UI.Composition` visual tree from a serialized
+composition. The DLL consumes FlatBuffer data through a classic COM interface.
+Applications can also link the implementation directly.
 
 ## How it fits in
 
 Lottie-Windows already turns a Lottie file into a `WinCompData` graph, which is a
-description of a composition tree. There were two things that could consume that
-graph:
+description of a composition tree. Three consumers use that graph:
 
 | Consumer | When it runs | Cost |
 | --- | --- | --- |
 | `Instantiator` | Runtime, in the app | Ships the whole JSON reader and translator |
 | `LottieGen` code generators | Build time | No runtime cost, but one class per animation |
+| `LottieRuntime` | Runtime, in the app | One interpreter shared by every animation |
 
-This adds a third. `CompositionSerializer` writes the `WinCompData` graph into a
+`CompositionSerializer` writes the `WinCompData` graph into a
 FlatBuffer at build time, and `LottieRuntime` reads that buffer at runtime. The
 animation stays data, so it can be swapped, downloaded or themed without a rebuild,
 and the code that reads it is the same size no matter how many animations an
@@ -57,24 +56,35 @@ LottieGen -InputFile animation.json -Language flatbuffer -OutputFolder .
 This writes `Animation.lcomp`. The format is described by
 [`source/LottieFlatbuffer/lottie_comp.fbs`](../../source/LottieFlatbuffer/lottie_comp.fbs).
 
-## Using it
+## Using the DLL
 
 ```cpp
-#include <LottieRuntime.h>
+#include <LottieRuntimeCom.h>
 
 auto bytes = ReadFileBytes(L"Animation.lcomp");
-auto root = CommunityToolkit::WinUI::Lottie::LoadComposition(compositor, bytes);
-
-// Drive the animation by animating one scalar from 0 to 1.
-auto progress = CommunityToolkit::WinUI::Lottie::ProgressPropertySet(root);
-progress.StartAnimation(L"Progress", playAnimation);
-
-ElementCompositionPreview::SetElementChildVisual(element, root);
+winrt::com_ptr<ILottieCompositionLoader> loader;
+winrt::check_hresult(CoCreateInstance(
+    CLSID_LottieCompositionLoader,
+    nullptr,
+    CLSCTX_INPROC_SERVER,
+    __uuidof(ILottieCompositionLoader),
+    loader.put_void()));
+
+winrt::Windows::UI::Composition::Visual root{ nullptr };
+winrt::check_hresult(loader->LoadComposition(
+    static_cast<UINT32>(bytes.size()),
+    reinterpret_cast<BYTE const*>(bytes.data()),
+    winrt::guid_of<decltype(root)>(),
+    winrt::put_abi(root)));
 ```
 
-`LoadComposition` returns a `Visual`, which is the least derived type that describes
-the root. A caller that parents the tree and drives its progress never needs more
-than that.
+`LottieRuntime.manifest` declares the private COM assembly. Activate that manifest
+before `CoCreateInstance`; `LottieRuntime.exe` contains the complete activation
+sequence. No system registration is required. The calling thread must own a
+`DispatcherQueue` that outlives the returned visual tree.
+
+`LottieRuntime.h` is the C++ API for applications linking the implementation
+directly. It is not exported by `LottieRuntime.dll`.
 
 ## Design
 
@@ -93,13 +103,13 @@ the state shared by every node is applied by a single function that takes
 `CompositionObject`. Everything is in one translation unit, so `/OPT:REF` discards
 the code for whatever an application never reaches.
 
-**Runtime cost second.** Each node is realized at most once. Lookups are a bounds
-check and an array index; there is no hash table anywhere. The buffer is read in
-place, so no intermediate object model is built.
+**Runtime cost second.** Each node and string is realized at most once. Lookups use
+O(1) bounds-checked array indexing into the FlatBuffer's node vectors. The buffer
+is read in place; no intermediate object model is built.
 
-**Transient memory third.** The only allocations are the caches, which are exactly
-as long as the buffer's node vectors, and the D2D geometries, which are released as
-soon as they have been given to a `CompositionPath`.
+**Transient memory third.** Realization caches are dense vectors matching the
+FlatBuffer's node vectors. D2D geometries are cached while the graph is built so
+shared geometry remains shared and cycles are rejected.
 
 **Untrusted input.** A buffer may have come from a file or a download. It is checked
 for the `LCMP` identifier, run through the FlatBuffers verifier, and every index
@@ -113,23 +123,51 @@ two effects the translator emits. There is no dependency on Win2D: the interpret
 implements `IGeometrySource2DInterop` and `IGraphicsEffectD2D1Interop` itself, which
 is a few dozen lines and avoids pulling a large component into every application.
 
-Requires the FlatBuffers C++ runtime headers (headers only, no library) from
-[flatbuffers 25.2.10](https://github.com/google/flatbuffers/releases/tag/v25.2.10),
-which must match the `flatc` used to generate `Generated/lottie_comp_generated.h`.
+The FlatBuffers C++ headers come from the pinned `external/flatbuffers` submodule.
+The checked-in C++ binding is generated by `flatc` from that commit. The checked-in
+C# binding remains on `Google.FlatBuffers` 25.2.10 from Microsoft's configured
+NuGet source. `build/RegenerateFlatbuffers.ps1` validates both generator versions.
+
+## Incorporate it in a build
+
+`LottieGen.nupkg` contains the complete native source set under
+`LottieRuntime/`.
+
+### C++/WinRT
+
+Add `LottieRuntime.cpp` to the consuming native project. Add `LottieRuntime/`
+and `LottieRuntime/flatbuffers/include/` to its include paths. Build as C++20
+and link:
 
-## Limitations
+```text
+d2d1.lib
+dxguid.lib
+shcore.lib
+shlwapi.lib
+windowsapp.lib
+```
+
+Include `LottieRuntime.h` and call `LoadComposition` with the application's
+`Compositor`. This direct-link path does not use COM activation.
+
+### Managed applications
+
+Add the packaged `LottieRuntime.vcxproj` to the solution. The project builds
+`LottieRuntime.dll`, including the `ILottieCompositionLoader` implementation.
+Copy both files into every managed application output directory:
+
+```text
+LottieRuntime.dll
+LottieRuntime.manifest
+```
 
-`LoadedImageSurface` is a Windows.UI.Xaml.Media type, so an interpreter that is
-usable outside XAML cannot create one. An animation that embeds a raster image
-throws `winrt::hresult_not_implemented`. Custom animation controllers are rejected
-for the same reason the managed `Instantiator` rejects them: the composition engine
-has no way to express one.
+The managed application activates `LottieRuntime.manifest`, calls
+`CoCreateInstance(CLSID_LottieCompositionLoader)`, and invokes
+`ILottieCompositionLoader::LoadComposition`. The calling thread owns the
+`DispatcherQueue` for the lifetime of the returned visual tree.
 
 ## Status
 
-**This code has not been compiled.** It was written on a Linux host, where neither
-MSVC nor the Windows SDK is available, so it has never been through a compiler and
-must be treated as unverified. Its behaviour is specified by `Instantiator.cs` and
-by `CompositionDeserializer.cs`, both of which are exercised by the tests in
-`tests/CompDataFlatbuffer.Tests`, so the shape of what it does is well tested even
-though this particular expression of it is not.
+Debug and Release x64 builds are supported. `LottieRuntime.exe` validates, dumps,
+or displays a composition through registration-free activation.
+`tests/CompDataFlatbuffer.Tests` verifies serializer round trips.
diff --git a/dlls/LottieRuntimeComTest/LottieRuntimeComTest.cpp b/dlls/LottieRuntimeComTest/LottieRuntimeComTest.cpp
deleted file mode 100644
index 50de323f..00000000
--- a/dlls/LottieRuntimeComTest/LottieRuntimeComTest.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-// Exercises the classic COM entry point declared in LottieRuntimeCom.h.
-//
-// LottieRuntime.dll is never registered with the system: its CLSID is only ever
-// known through LottieRuntime.manifest, its own private-assembly manifest, copied
-// next to this exe at build time. This test builds an activation context directly
-// out of that manifest - the same shape a real isolated application uses when it
-// carries a private assembly instead of registering a DLL - and activates it for
-// the duration of the CoCreateInstance call, which is the reason CoCreateInstance
-// resolves the CLSID without anything ever touching HKEY_CLASSES_ROOT.
-
-#include <unknwn.h>
-
-#include <Windows.h>
-#include <combaseapi.h>
-#include <shlwapi.h>
-
-#include <cstdio>
-#include <span>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-#include <winrt/base.h>
-
-#include "LottieRuntimeCom.h"
-
-namespace
-{
-    std::vector<std::byte> ReadCompositionFile(wchar_t const* path)
-    {
-        HANDLE file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
-        if (file == INVALID_HANDLE_VALUE)
-        {
-            throw std::runtime_error("Could not open the composition file.");
-        }
-
-        LARGE_INTEGER size{};
-        GetFileSizeEx(file, &size);
-
-        std::vector<std::byte> buffer(static_cast<size_t>(size.QuadPart));
-        DWORD read = 0;
-        BOOL const ok = ::ReadFile(file, buffer.data(), static_cast<DWORD>(buffer.size()), &read, nullptr);
-        CloseHandle(file);
-
-        if (!ok || read != buffer.size())
-        {
-            throw std::runtime_error("Could not read the composition file.");
-        }
-
-        return buffer;
-    }
-}
-
-int wmain(int argc, wchar_t* argv[])
-{
-    if (argc != 2)
-    {
-        fwprintf(stderr, L"Usage: LottieRuntimeComTest <path-to-flatbuffer-composition>\n");
-        return 1;
-    }
-
-    try
-    {
-        winrt::check_hresult(CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED));
-
-        // The manifest is a private assembly for this exe: it declares the CLSID
-        // directly rather than through a level of indirection, so it is loaded
-        // straight into the activation context as the primary manifest, with no
-        // separate application manifest and no HKEY_CLASSES_ROOT registration.
-        wchar_t moduleDir[MAX_PATH]{};
-        GetModuleFileNameW(nullptr, moduleDir, MAX_PATH);
-        PathRemoveFileSpecW(moduleDir);
-
-        std::wstring const manifestPath = std::wstring(moduleDir) + L"\\LottieRuntime.manifest";
-
-        ACTCTXW actCtx{ sizeof(ACTCTXW) };
-        actCtx.lpSource = manifestPath.c_str();
-        actCtx.lpAssemblyDirectory = moduleDir;
-        actCtx.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
-
-        HANDLE const hActCtx = CreateActCtxW(&actCtx);
-        if (hActCtx == INVALID_HANDLE_VALUE)
-        {
-            fwprintf(stderr, L"CreateActCtx failed: %lu (manifest: %s, dir: %s)\n", GetLastError(), manifestPath.c_str(), moduleDir);
-            return 1;
-        }
-
-        ULONG_PTR cookie = 0;
-        ActivateActCtx(hActCtx, &cookie);
-
-        winrt::com_ptr<ILottieCompositionLoader> loader;
-        HRESULT const hr = CoCreateInstance(
-            CLSID_LottieCompositionLoader,
-            nullptr,
-            CLSCTX_INPROC_SERVER,
-            __uuidof(ILottieCompositionLoader),
-            loader.put_void());
-
-        DeactivateActCtx(0, cookie);
-        ReleaseActCtx(hActCtx);
-
-        if (FAILED(hr))
-        {
-            fwprintf(stderr, L"CoCreateInstance failed (registration-free activation did not resolve the CLSID): 0x%08X (last error %lu)\n", hr, GetLastError());
-            return 1;
-        }
-
-        auto const buffer = ReadCompositionFile(argv[1]);
-
-        winrt::com_ptr<::IUnknown> root;
-        HRESULT const loadHr = loader->LoadComposition(
-            static_cast<UINT32>(buffer.size()),
-            reinterpret_cast<BYTE const*>(buffer.data()),
-            __uuidof(::IUnknown),
-            root.put_void());
-
-        if (FAILED(loadHr))
-        {
-            fwprintf(stderr, L"LoadComposition failed: 0x%08X\n", loadHr);
-            return 1;
-        }
-
-        wprintf(L"Registration-free activation succeeded; loaded a composition with a root object at %p.\n", root.get());
-        return 0;
-    }
-    catch (winrt::hresult_error const& e)
-    {
-        fwprintf(stderr, L"%s\n", e.message().c_str());
-        return 1;
-    }
-    catch (std::exception const& e)
-    {
-        fprintf(stderr, "%s\n", e.what());
-        return 1;
-    }
-}
diff --git a/dlls/LottieRuntimeComTest/LottieRuntimeComTest.vcxproj b/dlls/LottieRuntimeComTest/LottieRuntimeComTest.vcxproj
deleted file mode 100644
index 9ca4357c..00000000
--- a/dlls/LottieRuntimeComTest/LottieRuntimeComTest.vcxproj
+++ /dev/null
@@ -1,88 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|ARM64">
-      <Configuration>Debug</Configuration>
-      <Platform>ARM64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|ARM64">
-      <Configuration>Release</Configuration>
-      <Platform>ARM64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{2B6C4A1E-7F3D-4B7A-9C3E-3D5A8F0B2E49}</ProjectGuid>
-    <RootNamespace>LottieRuntimeComTest</RootNamespace>
-    <ConfigurationType>Application</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-    <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
-    <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
-
-    <!-- This test builds its own activation context out of an in-memory manifest
-         at runtime (see LottieRuntimeComTest.cpp), so its own exe must not carry
-         a default /manifest that Windows auto-activates instead. -->
-    <GenerateManifest>false</GenerateManifest>
-  </PropertyGroup>
-
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-
-  <PropertyGroup>
-    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
-    <UseDebugLibraries Condition="'$(Configuration)'=='Release'">false</UseDebugLibraries>
-    <WholeProgramOptimization Condition="'$(Configuration)'=='Release'">true</WholeProgramOptimization>
-  </PropertyGroup>
-
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <LanguageStandard>stdcpp20</LanguageStandard>
-      <PreprocessorDefinitions>WIN32_LEAN_AND_MEAN;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory)..\LottieRuntime;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <WarningLevel>Level4</WarningLevel>
-      <TreatWarningAsError>true</TreatWarningAsError>
-      <ExceptionHandling>Sync</ExceptionHandling>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <AdditionalDependencies>windowsapp.lib;shlwapi.lib;ole32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <GenerateManifest>false</GenerateManifest>
-    </Link>
-  </ItemDefinitionGroup>
-
-  <ItemGroup>
-    <ClCompile Include="LottieRuntimeComTest.cpp" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\LottieRuntime\LottieRuntime.vcxproj">
-      <Project>{6E0A5B4C-2F1D-4B7A-9C3E-1D5A8F0B2E47}</Project>
-    </ProjectReference>
-  </ItemGroup>
-
-  <!-- No HKEY_CLASSES_ROOT registration ever happens: the test only needs
-       LottieRuntime.dll to sit next to the exe, since its embedded manifest is
-       what an activation context resolves the CLSID against. -->
-  <Target Name="CopyLottieRuntimeDll" AfterTargets="Build">
-    <ItemGroup>
-      <LottieRuntimeDll Include="$(MSBuildThisFileDirectory)..\LottieRuntime\$(Platform)\$(Configuration)\LottieRuntime.dll" />
-      <!-- The private-assembly manifest that declares the CLSID; resolved by
-           name (LottieRuntime.manifest) from the assembly directory the test
-           points ACTCTX at, independent of anything embedded in the DLL. -->
-      <LottieRuntimeManifest Include="$(MSBuildThisFileDirectory)..\LottieRuntime\LottieRuntime.manifest" />
-    </ItemGroup>
-    <Copy SourceFiles="@(LottieRuntimeDll)" DestinationFolder="$(OutDir)" SkipUnchangedFiles="true" />
-    <Copy SourceFiles="@(LottieRuntimeManifest)" DestinationFolder="$(OutDir)" SkipUnchangedFiles="true" />
-  </Target>
-
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-</Project>
diff --git a/dlls/LottieRuntimeDump/LottieRuntimeDump.cpp b/dlls/LottieRuntimeDump/LottieRuntimeDump.cpp
deleted file mode 100644
index 081c961a..00000000
--- a/dlls/LottieRuntimeDump/LottieRuntimeDump.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-// Sample tool: loads a serialized Lottie composition (a .lcomp FlatBuffer produced
-// by LottieGen -Language flatbuffer or CompositionSerializer) through LottieRuntime,
-// then prints the composition object hierarchy of the resulting visual tree.
-//
-// Usage: LottieRuntimeDump.exe <path-to.lcomp>
-
-#include <unknwn.h>
-
-#include <LottieRuntime.h>
-
-#include <winrt/Windows.Foundation.h>
-#include <winrt/Windows.Foundation.Collections.h>
-#include <winrt/Windows.UI.Composition.h>
-
-#include <fstream>
-#include <iostream>
-#include <string>
-#include <vector>
-
-using namespace winrt;
-using namespace winrt::Windows::UI::Composition;
-using namespace winrt::Windows::Foundation;
-using namespace winrt::Windows::Foundation::Collections;
-
-namespace
-{
-    std::vector<std::byte> ReadFileBytes(wchar_t const* path)
-    {
-        std::ifstream file(path, std::ios::binary | std::ios::ate);
-        if (!file)
-        {
-            throw std::runtime_error("Could not open input file.");
-        }
-
-        auto const size = static_cast<size_t>(file.tellg());
-        std::vector<std::byte> result(size);
-        file.seekg(0);
-        file.read(reinterpret_cast<char*>(result.data()), static_cast<std::streamsize>(size));
-        return result;
-    }
-
-    void PrintLine(int depth, std::wstring_view text)
-    {
-        std::wstring indent(static_cast<size_t>(depth) * 2, L' ');
-        std::wcout << indent << text << L"\n";
-    }
-
-    hstring RuntimeClassName(IInspectable const& node)
-    {
-        if (node == nullptr)
-        {
-            return L"(null)";
-        }
-
-        return winrt::get_class_name(node);
-    }
-
-    hstring CommentOf(CompositionObject const& node)
-    {
-        auto comment = node.Comment();
-        return comment.empty() ? L"" : (L" \"" + comment + L"\"");
-    }
-
-    void DumpBrush(CompositionBrush const& brush, int depth);
-    void DumpVisual(Visual const& visual, int depth);
-    void DumpShape(CompositionShape const& shape, int depth);
-
-    void DumpShape(CompositionShape const& shape, int depth)
-    {
-        if (shape == nullptr)
-        {
-            return;
-        }
-
-        PrintLine(depth, RuntimeClassName(shape) + CommentOf(shape));
-
-        if (auto containerShape = shape.try_as<CompositionContainerShape>())
-        {
-            for (auto const& child : containerShape.Shapes())
-            {
-                DumpShape(child, depth + 1);
-            }
-        }
-
-        if (auto spriteShape = shape.try_as<CompositionSpriteShape>())
-        {
-            if (auto fill = spriteShape.FillBrush())
-            {
-                PrintLine(depth + 1, L"FillBrush:");
-                DumpBrush(fill, depth + 2);
-            }
-
-            if (auto stroke = spriteShape.StrokeBrush())
-            {
-                PrintLine(depth + 1, L"StrokeBrush:");
-                DumpBrush(stroke, depth + 2);
-            }
-        }
-    }
-
-    void DumpBrush(CompositionBrush const& brush, int depth)
-    {
-        if (brush == nullptr)
-        {
-            return;
-        }
-
-        PrintLine(depth, RuntimeClassName(brush) + CommentOf(brush));
-
-        if (auto linearGradient = brush.try_as<CompositionLinearGradientBrush>())
-        {
-            for (auto const& stop : linearGradient.ColorStops())
-            {
-                PrintLine(depth + 1, L"ColorStop " + RuntimeClassName(stop));
-            }
-        }
-    }
-
-    void DumpVisual(Visual const& visual, int depth)
-    {
-        if (visual == nullptr)
-        {
-            return;
-        }
-
-        PrintLine(depth, RuntimeClassName(visual) + CommentOf(visual));
-
-        if (auto spriteVisual = visual.try_as<SpriteVisual>())
-        {
-            if (auto brush = spriteVisual.Brush())
-            {
-                PrintLine(depth + 1, L"Brush:");
-                DumpBrush(brush, depth + 2);
-            }
-
-            if (auto shapeVisual = visual.try_as<ShapeVisual>())
-            {
-                for (auto const& shape : shapeVisual.Shapes())
-                {
-                    DumpShape(shape, depth + 1);
-                }
-            }
-        }
-        else if (auto shapeVisual = visual.try_as<ShapeVisual>())
-        {
-            for (auto const& shape : shapeVisual.Shapes())
-            {
-                DumpShape(shape, depth + 1);
-            }
-        }
-
-        if (auto containerVisual = visual.try_as<ContainerVisual>())
-        {
-            for (auto const& child : containerVisual.Children())
-            {
-                DumpVisual(child, depth + 1);
-            }
-        }
-    }
-}
-
-int wmain(int argc, wchar_t* argv[])
-{
-    winrt::init_apartment();
-
-    if (argc != 2)
-    {
-        std::wcerr << L"Usage: LottieRuntimeDump.exe <path-to.lcomp>\n";
-        return 1;
-    }
-
-    try
-    {
-        auto bytes = ReadFileBytes(argv[1]);
-
-        Compositor compositor;
-        auto root = CommunityToolkit::WinUI::Lottie::LoadComposition(
-            compositor,
-            std::span<std::byte const>(bytes.data(), bytes.size()));
-
-        std::wcout << L"Composition object hierarchy:\n";
-        DumpVisual(root, 0);
-    }
-    catch (winrt::hresult_error const& e)
-    {
-        std::wcerr << L"Failed to load composition: " << e.message().c_str() << L"\n";
-        return 1;
-    }
-    catch (std::exception const& e)
-    {
-        std::cerr << "Failed: " << e.what() << "\n";
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/dlls/LottieRuntimeTool/LottieRuntime.cpp b/dlls/LottieRuntimeTool/LottieRuntime.cpp
new file mode 100644
index 00000000..ad8b8daa
--- /dev/null
+++ b/dlls/LottieRuntimeTool/LottieRuntime.cpp
@@ -0,0 +1,363 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// Loads a serialized Lottie composition through the registration-free COM surface.
+
+#include <unknwn.h>
+
+#include <Windows.h>
+#include <DispatcherQueue.h>
+#include <shlwapi.h>
+#include <windows.ui.composition.interop.h>
+
+#include <LottieRuntimeCom.h>
+
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Foundation.Collections.h>
+#include <winrt/Windows.System.h>
+#include <winrt/Windows.UI.Composition.h>
+#include <winrt/Windows.UI.Composition.Desktop.h>
+
+#include <chrono>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+using namespace winrt;
+using namespace winrt::Windows::UI::Composition;
+using namespace winrt::Windows::Foundation;
+using namespace winrt::Windows::Foundation::Collections;
+
+namespace
+{
+    winrt::Windows::System::DispatcherQueueController CreateDispatcherQueue()
+    {
+        DispatcherQueueOptions const options{
+            sizeof(DispatcherQueueOptions),
+            DQTYPE_THREAD_CURRENT,
+            DQTAT_COM_NONE,
+        };
+
+        winrt::Windows::System::DispatcherQueueController controller{ nullptr };
+        winrt::check_hresult(CreateDispatcherQueueController(
+            options,
+            reinterpret_cast<PDISPATCHERQUEUECONTROLLER*>(winrt::put_abi(controller))));
+        return controller;
+    }
+
+    winrt::com_ptr<ILottieCompositionLoader> CreateLoader()
+    {
+        wchar_t moduleDirectory[MAX_PATH]{};
+        winrt::check_bool(GetModuleFileNameW(nullptr, moduleDirectory, MAX_PATH));
+        winrt::check_bool(PathRemoveFileSpecW(moduleDirectory));
+
+        auto const manifestPath =
+            std::wstring(moduleDirectory) + L"\\LottieRuntime.manifest";
+
+        ACTCTXW context{ sizeof(ACTCTXW) };
+        context.lpSource = manifestPath.c_str();
+        context.lpAssemblyDirectory = moduleDirectory;
+        context.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
+
+        auto const activationContext = CreateActCtxW(&context);
+        winrt::check_bool(activationContext != INVALID_HANDLE_VALUE);
+
+        ULONG_PTR cookie{};
+        winrt::check_bool(ActivateActCtx(activationContext, &cookie));
+
+        winrt::com_ptr<ILottieCompositionLoader> loader;
+        auto const result = CoCreateInstance(
+            CLSID_LottieCompositionLoader,
+            nullptr,
+            CLSCTX_INPROC_SERVER,
+            __uuidof(ILottieCompositionLoader),
+            loader.put_void());
+
+        DeactivateActCtx(0, cookie);
+        ReleaseActCtx(activationContext);
+        winrt::check_hresult(result);
+        return loader;
+    }
+
+    std::vector<std::byte> ReadFileBytes(wchar_t const* path)
+    {
+        std::ifstream file(path, std::ios::binary | std::ios::ate);
+        if (!file)
+        {
+            throw std::runtime_error("Could not open input file.");
+        }
+
+        auto const size = static_cast<size_t>(file.tellg());
+        std::vector<std::byte> result(size);
+        file.seekg(0);
+        file.read(reinterpret_cast<char*>(result.data()), static_cast<std::streamsize>(size));
+        return result;
+    }
+
+    void PrintLine(int depth, std::wstring_view text)
+    {
+        std::wstring indent(static_cast<size_t>(depth) * 2, L' ');
+        std::wcout << indent << text << L"\n";
+    }
+
+    hstring RuntimeClassName(winrt::Windows::Foundation::IInspectable const& node)
+    {
+        if (node == nullptr)
+        {
+            return L"(null)";
+        }
+
+        return winrt::get_class_name(node);
+    }
+
+    hstring CommentOf(CompositionObject const& node)
+    {
+        auto comment = node.Comment();
+        return comment.empty() ? L"" : (L" \"" + comment + L"\"");
+    }
+
+    void DumpBrush(CompositionBrush const& brush, int depth);
+    void DumpVisual(Visual const& visual, int depth);
+    void DumpShape(CompositionShape const& shape, int depth);
+
+    void DumpShape(CompositionShape const& shape, int depth)
+    {
+        if (shape == nullptr)
+        {
+            return;
+        }
+
+        PrintLine(depth, RuntimeClassName(shape) + CommentOf(shape));
+
+        if (auto containerShape = shape.try_as<CompositionContainerShape>())
+        {
+            for (auto const& child : containerShape.Shapes())
+            {
+                DumpShape(child, depth + 1);
+            }
+        }
+
+        if (auto spriteShape = shape.try_as<CompositionSpriteShape>())
+        {
+            if (auto fill = spriteShape.FillBrush())
+            {
+                PrintLine(depth + 1, L"FillBrush:");
+                DumpBrush(fill, depth + 2);
+            }
+
+            if (auto stroke = spriteShape.StrokeBrush())
+            {
+                PrintLine(depth + 1, L"StrokeBrush:");
+                DumpBrush(stroke, depth + 2);
+            }
+        }
+    }
+
+    void DumpBrush(CompositionBrush const& brush, int depth)
+    {
+        if (brush == nullptr)
+        {
+            return;
+        }
+
+        PrintLine(depth, RuntimeClassName(brush) + CommentOf(brush));
+
+        if (auto linearGradient = brush.try_as<CompositionLinearGradientBrush>())
+        {
+            for (auto const& stop : linearGradient.ColorStops())
+            {
+                PrintLine(depth + 1, L"ColorStop " + RuntimeClassName(stop));
+            }
+        }
+    }
+
+    void DumpVisual(Visual const& visual, int depth)
+    {
+        if (visual == nullptr)
+        {
+            return;
+        }
+
+        PrintLine(depth, RuntimeClassName(visual) + CommentOf(visual));
+
+        if (auto spriteVisual = visual.try_as<SpriteVisual>())
+        {
+            if (auto brush = spriteVisual.Brush())
+            {
+                PrintLine(depth + 1, L"Brush:");
+                DumpBrush(brush, depth + 2);
+            }
+
+            if (auto shapeVisual = visual.try_as<ShapeVisual>())
+            {
+                for (auto const& shape : shapeVisual.Shapes())
+                {
+                    DumpShape(shape, depth + 1);
+                }
+            }
+        }
+        else if (auto shapeVisual = visual.try_as<ShapeVisual>())
+        {
+            for (auto const& shape : shapeVisual.Shapes())
+            {
+                DumpShape(shape, depth + 1);
+            }
+        }
+
+        if (auto containerVisual = visual.try_as<ContainerVisual>())
+        {
+            for (auto const& child : containerVisual.Children())
+            {
+                DumpVisual(child, depth + 1);
+            }
+        }
+    }
+
+    LRESULT CALLBACK WindowProc(HWND window, UINT message, WPARAM wParam, LPARAM lParam)
+    {
+        if (message == WM_DESTROY)
+        {
+            PostQuitMessage(0);
+            return 0;
+        }
+
+        return DefWindowProcW(window, message, wParam, lParam);
+    }
+
+    void ShowVisual(Visual const& root)
+    {
+        auto const instance = GetModuleHandleW(nullptr);
+        wchar_t const className[] = L"LottieRuntimeWindow";
+
+        WNDCLASSW windowClass{};
+        windowClass.lpfnWndProc = WindowProc;
+        windowClass.hInstance = instance;
+        windowClass.hCursor = LoadCursorW(nullptr, IDC_ARROW);
+        windowClass.hbrBackground = static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH));
+        windowClass.lpszClassName = className;
+        winrt::check_bool(RegisterClassW(&windowClass) != 0);
+
+        auto const window = CreateWindowExW(
+            0,
+            className,
+            L"LottieRuntime",
+            WS_OVERLAPPEDWINDOW,
+            CW_USEDEFAULT,
+            CW_USEDEFAULT,
+            900,
+            700,
+            nullptr,
+            nullptr,
+            instance,
+            nullptr);
+        winrt::check_bool(window != nullptr);
+
+        auto compositor = root.Compositor();
+        auto compositorInterop =
+            compositor.as<ABI::Windows::UI::Composition::Desktop::ICompositorDesktopInterop>();
+        winrt::Windows::UI::Composition::Desktop::DesktopWindowTarget target{ nullptr };
+        winrt::check_hresult(compositorInterop->CreateDesktopWindowTarget(
+            window,
+            false,
+            reinterpret_cast<ABI::Windows::UI::Composition::Desktop::IDesktopWindowTarget**>(
+                winrt::put_abi(target))));
+        target.Root(root);
+
+        auto progress = compositor.CreateScalarKeyFrameAnimation();
+        progress.InsertKeyFrame(0.0f, 0.0f);
+        progress.InsertKeyFrame(1.0f, 1.0f);
+        progress.Duration(std::chrono::seconds(5));
+        progress.IterationBehavior(AnimationIterationBehavior::Forever);
+        root.Properties().StartAnimation(L"Progress", progress);
+
+        ShowWindow(window, SW_SHOW);
+        UpdateWindow(window);
+
+        MSG message{};
+        while (GetMessageW(&message, nullptr, 0, 0) > 0)
+        {
+            TranslateMessage(&message);
+            DispatchMessageW(&message);
+        }
+    }
+}
+
+int wmain(int argc, wchar_t* argv[])
+{
+    if (argc < 2 || argc > 3)
+    {
+        std::wcerr << L"Usage: LottieRuntime.exe <path-to-flatbuffer> [--dump|--show]\n";
+        return 1;
+    }
+
+    try
+    {
+        enum class Mode
+        {
+            Validate,
+            Dump,
+            Show,
+        };
+
+        auto mode = Mode::Validate;
+        if (argc == 3)
+        {
+            if (std::wstring_view(argv[2]) == L"--dump")
+            {
+                mode = Mode::Dump;
+            }
+            else if (std::wstring_view(argv[2]) == L"--show")
+            {
+                mode = Mode::Show;
+            }
+            else
+            {
+                throw std::invalid_argument("Mode must be --dump or --show.");
+            }
+        }
+
+        winrt::check_hresult(CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED));
+        auto dispatcherQueueController = CreateDispatcherQueue();
+        auto bytes = ReadFileBytes(argv[1]);
+
+        auto loader = CreateLoader();
+        Visual root{ nullptr };
+        winrt::check_hresult(loader->LoadComposition(
+            static_cast<UINT32>(bytes.size()),
+            reinterpret_cast<BYTE const*>(bytes.data()),
+            winrt::guid_of<Visual>(),
+            winrt::put_abi(root)));
+
+        switch (mode)
+        {
+        case Mode::Validate:
+            std::wcout << L"Composition loaded successfully.\n";
+            break;
+        case Mode::Dump:
+            std::wcout << L"Composition object hierarchy:\n";
+            DumpVisual(root, 0);
+            break;
+        case Mode::Show:
+            ShowVisual(root);
+            break;
+        }
+
+        root = nullptr;
+        loader = nullptr;
+        dispatcherQueueController.ShutdownQueueAsync();
+    }
+    catch (winrt::hresult_error const& e)
+    {
+        std::wcerr << L"Failed to load composition: " << e.message().c_str() << L"\n";
+        return 1;
+    }
+    catch (std::exception const& e)
+    {
+        std::cerr << "Failed: " << e.what() << "\n";
+        return 1;
+    }
+
+    return 0;
+}
diff --git a/dlls/LottieRuntimeDump/LottieRuntimeDump.vcxproj b/dlls/LottieRuntimeTool/LottieRuntime.vcxproj
similarity index 73%
rename from dlls/LottieRuntimeDump/LottieRuntimeDump.vcxproj
rename to dlls/LottieRuntimeTool/LottieRuntime.vcxproj
index 33e8a74c..ebe01e7a 100644
--- a/dlls/LottieRuntimeDump/LottieRuntimeDump.vcxproj
+++ b/dlls/LottieRuntimeTool/LottieRuntime.vcxproj
@@ -21,7 +21,8 @@
 
   <PropertyGroup Label="Globals">
     <ProjectGuid>{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}</ProjectGuid>
-    <RootNamespace>LottieRuntimeDump</RootNamespace>
+    <RootNamespace>LottieRuntime</RootNamespace>
+    <TargetName>LottieRuntime</TargetName>
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
@@ -49,25 +50,32 @@
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
-      <AdditionalDependencies>windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CoreMessaging.lib;ole32.lib;shlwapi.lib;user32.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
 
   <ItemGroup>
-    <ClCompile Include="LottieRuntimeDump.cpp" />
+    <ClCompile Include="LottieRuntime.cpp" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\LottieRuntime\LottieRuntime.vcxproj">
       <Project>{6E0A5B4C-2F1D-4B7A-9C3E-1D5A8F0B2E47}</Project>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
     </ProjectReference>
   </ItemGroup>
 
-  <Target Name="CopyLottieRuntimeDll" AfterTargets="Build">
+  <Target Name="CopyLottieRuntimeFiles" AfterTargets="Build">
+    <MSBuild
+        Projects="..\LottieRuntime\LottieRuntime.vcxproj"
+        Targets="GetTargetPath"
+        Properties="Configuration=$(Configuration);Platform=$(Platform)">
+      <Output TaskParameter="TargetOutputs" ItemName="_LottieRuntimeTarget" />
+    </MSBuild>
     <ItemGroup>
-      <LottieRuntimeDll Include="$(MSBuildThisFileDirectory)..\LottieRuntime\$(Platform)\$(Configuration)\LottieRuntime.dll" />
+      <LottieRuntimeManifest Include="$(MSBuildThisFileDirectory)..\LottieRuntime\LottieRuntime.manifest" />
     </ItemGroup>
-    <Copy SourceFiles="@(LottieRuntimeDll)" DestinationFolder="$(OutDir)" SkipUnchangedFiles="true" />
+    <Copy SourceFiles="@(_LottieRuntimeTarget);@(LottieRuntimeManifest)" DestinationFolder="$(OutDir)" SkipUnchangedFiles="true" />
   </Target>
 
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
diff --git a/dlls/LottieRuntimeTool/README.md b/dlls/LottieRuntimeTool/README.md
new file mode 100644
index 00000000..289bbf05
--- /dev/null
+++ b/dlls/LottieRuntimeTool/README.md
@@ -0,0 +1,54 @@
+# LottieRuntime tool
+
+`LottieRuntime.exe` loads FlatBuffer compositions through the registration-free
+`ILottieCompositionLoader` COM interface.
+
+## Build
+
+```powershell
+& "C:\Program Files\Microsoft Visual Studio\18\Professional\Common7\Tools\Launch-VsDevShell.ps1" -SkipAutomaticLocation
+msbuild .\dlls\LottieRuntimeTool\LottieRuntime.vcxproj /p:Platform=x64 /p:Configuration=Release
+```
+
+The executable is written to:
+
+```text
+dlls\LottieRuntimeTool\x64\Release\LottieRuntime.exe
+```
+
+## Convert Lottie JSON
+
+```powershell
+$output = Join-Path $env:TEMP "lottie-runtime"
+New-Item -ItemType Directory -Force $output | Out-Null
+
+dotnet run --project .\LottieGen\DotnetTool\LottieGen.csproj -- `
+    -InputFile .\LottieSamples\Assets\LottieLogo1.json `
+    -Language flatbuffer `
+    -OutputFolder $output
+```
+
+The command writes `$output\LottieLogo1.lcomp`.
+
+## Load, inspect, or display
+
+Validate the composition:
+
+```powershell
+.\dlls\LottieRuntimeTool\x64\Release\LottieRuntime.exe `
+    "$output\LottieLogo1.lcomp"
+```
+
+Print the interpreted Composition object hierarchy:
+
+```powershell
+.\dlls\LottieRuntimeTool\x64\Release\LottieRuntime.exe `
+    "$output\LottieLogo1.lcomp" --dump
+```
+
+Display and animate the interpreted visual:
+
+```powershell
+.\dlls\LottieRuntimeTool\x64\Release\LottieRuntime.exe `
+    "$output\LottieLogo1.lcomp" --show
+```

From aa21a6d6b7d3dfdde82a4d9d87a48be130ce908b Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 15:58:24 -0700
Subject: [PATCH 25/39] Optimize LottieRuntime tool for size

Disable incremental linking and enable /O1, function-level linking, string pooling, LTCG, reference elimination, and COMDAT folding for Release builds.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 dlls/LottieRuntimeTool/LottieRuntime.vcxproj | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/dlls/LottieRuntimeTool/LottieRuntime.vcxproj b/dlls/LottieRuntimeTool/LottieRuntime.vcxproj
index ebe01e7a..ee8b65c3 100644
--- a/dlls/LottieRuntimeTool/LottieRuntime.vcxproj
+++ b/dlls/LottieRuntimeTool/LottieRuntime.vcxproj
@@ -37,6 +37,7 @@
     <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
     <UseDebugLibraries Condition="'$(Configuration)'=='Release'">false</UseDebugLibraries>
     <WholeProgramOptimization Condition="'$(Configuration)'=='Release'">true</WholeProgramOptimization>
+    <LinkIncremental Condition="'$(Configuration)'=='Release'">false</LinkIncremental>
   </PropertyGroup>
 
   <ItemDefinitionGroup>
@@ -54,6 +55,20 @@
     </Link>
   </ItemDefinitionGroup>
 
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MinSpace</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <StringPooling>true</StringPooling>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+    </ClCompile>
+    <Link>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+    </Link>
+  </ItemDefinitionGroup>
+
   <ItemGroup>
     <ClCompile Include="LottieRuntime.cpp" />
   </ItemGroup>

From 93b1cb90959b19913ff9a94a6b349dfda49c6841 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 1 Sep 2026 16:37:12 -0700
Subject: [PATCH 26/39] Validate buffer UAP requirements

Keep the runtime loadable on Windows 10 1809 while rejecting compositions whose declared UniversalApiContract version is unavailable before graph hydration.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 58fac82f-0489-4c57-a18d-2b7ba273faa6
---
 dlls/LottieRuntime/LottieRuntime.cpp     | 10 ++++++++++
 dlls/LottieRuntime/LottieRuntime.vcxproj |  5 ++---
 dlls/LottieRuntime/README.md             |  3 ++-
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/dlls/LottieRuntime/LottieRuntime.cpp b/dlls/LottieRuntime/LottieRuntime.cpp
index e059bbcc..209b9655 100644
--- a/dlls/LottieRuntime/LottieRuntime.cpp
+++ b/dlls/LottieRuntime/LottieRuntime.cpp
@@ -48,6 +48,7 @@
 
 #include <winrt/Windows.Foundation.h>
 #include <winrt/Windows.Foundation.Collections.h>
+#include <winrt/Windows.Foundation.Metadata.h>
 #include <winrt/Windows.Foundation.Numerics.h>
 #include <winrt/Windows.Graphics.Effects.h>
 #include <winrt/Windows.Storage.Streams.h>
@@ -2139,6 +2140,15 @@ namespace CommunityToolkit::WinUI::Lottie
             ThrowUnsupported();
         }
 
+        auto const requiredUapVersion = root->required_uap_version();
+        if (requiredUapVersion != 0 &&
+            !winrt::Windows::Foundation::Metadata::ApiInformation::IsApiContractPresent(
+                L"Windows.Foundation.UniversalApiContract",
+                requiredUapVersion))
+        {
+            ThrowUnsupported();
+        }
+
         return Interpreter(compositor, *root).Run();
     }
 
diff --git a/dlls/LottieRuntime/LottieRuntime.vcxproj b/dlls/LottieRuntime/LottieRuntime.vcxproj
index 075df1be..5cad979f 100644
--- a/dlls/LottieRuntime/LottieRuntime.vcxproj
+++ b/dlls/LottieRuntime/LottieRuntime.vcxproj
@@ -27,9 +27,8 @@
     <CharacterSet>Unicode</CharacterSet>
     <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
 
-    <!-- The interpreter targets the same minimum as the rest of Lottie-Windows.
-         Anything newer is reached through the buffer's required UAP version, which
-         a caller checks before it loads. -->
+    <!-- The DLL loads on the Lottie-Windows minimum. Each buffer declares and
+         validates the UniversalApiContract version needed by its graph. -->
     <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
     <FlatBuffersIncludeDirectory
         Condition="'$(FlatBuffersIncludeDirectory)'=='' and Exists('$(MSBuildThisFileDirectory)..\..\external\flatbuffers\include')">$(MSBuildThisFileDirectory)..\..\external\flatbuffers\include</FlatBuffersIncludeDirectory>
diff --git a/dlls/LottieRuntime/README.md b/dlls/LottieRuntime/README.md
index c5784f88..fcac423d 100644
--- a/dlls/LottieRuntime/README.md
+++ b/dlls/LottieRuntime/README.md
@@ -114,7 +114,8 @@ shared geometry remains shared and cycles are rejected.
 **Untrusted input.** A buffer may have come from a file or a download. It is checked
 for the `LCMP` identifier, run through the FlatBuffers verifier, and every index
 read out of it is range checked. A malformed buffer throws
-`winrt::hresult_invalid_argument`; it never reads outside the buffer.
+`winrt::hresult_invalid_argument`; it never reads outside the buffer. The declared
+Universal API contract is checked before graph hydration.
 
 ## Dependencies
 

From f215215051223fda65a9f5892f8735c910c40eee Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 2 Sep 2026 16:17:45 +0000
Subject: [PATCH 27/39] Add a managed FlatBuffer interpreter with
 dump-and-compare tests

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 dlls/LottieRuntime/README.md                  |    6 +
 .../LottieRuntime/CompositionInterpreter.cs   | 1798 +++++++++++++++++
 source/LottieRuntime/LottieRuntime.projitems  |   14 +
 source/LottieRuntime/LottieRuntime.shproj     |   13 +
 source/LottieRuntime/README.md                |  108 +
 .../CompDataFlatbuffer.Tests.csproj           |    1 +
 .../CompositionApiStandIns.cs                 | 1112 ++++++++++
 .../CompDataFlatbuffer.Tests/CoverageTests.cs |   17 +
 .../InterpretedTreeDumper.cs                  |  805 ++++++++
 .../InterpreterTests.cs                       |  214 ++
 10 files changed, 4088 insertions(+)
 create mode 100644 source/LottieRuntime/CompositionInterpreter.cs
 create mode 100644 source/LottieRuntime/LottieRuntime.projitems
 create mode 100644 source/LottieRuntime/LottieRuntime.shproj
 create mode 100644 source/LottieRuntime/README.md
 create mode 100644 tests/CompDataFlatbuffer.Tests/CompositionApiStandIns.cs
 create mode 100644 tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs
 create mode 100644 tests/CompDataFlatbuffer.Tests/InterpreterTests.cs

diff --git a/dlls/LottieRuntime/README.md b/dlls/LottieRuntime/README.md
index fcac423d..ac9a5d20 100644
--- a/dlls/LottieRuntime/README.md
+++ b/dlls/LottieRuntime/README.md
@@ -153,6 +153,12 @@ Include `LottieRuntime.h` and call `LoadComposition` with the application's
 
 ### Managed applications
 
+A managed application can also use the C# interpreter in
+[`source/LottieRuntime`](../../source/LottieRuntime/README.md), which reads the same
+buffer and performs the same validation, and needs no COM activation. Use the DLL
+instead when the application should not take a Win2D dependency, or when the same
+animation is loaded from both native and managed code.
+
 Add the packaged `LottieRuntime.vcxproj` to the solution. The project builds
 `LottieRuntime.dll`, including the `ILottieCompositionLoader` implementation.
 Copy both files into every managed application output directory:
diff --git a/source/LottieRuntime/CompositionInterpreter.cs b/source/LottieRuntime/CompositionInterpreter.cs
new file mode 100644
index 00000000..123061a1
--- /dev/null
+++ b/source/LottieRuntime/CompositionInterpreter.cs
@@ -0,0 +1,1798 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Numerics;
+using System.Runtime.InteropServices.WindowsRuntime;
+using CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer;
+using Google.FlatBuffers;
+using Microsoft.Graphics.Canvas.Geometry;
+using Windows.Foundation.Metadata;
+using Windows.Graphics.Effects;
+using Fb = CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema;
+using Mgc = Microsoft.Graphics.Canvas;
+using Mgce = Microsoft.Graphics.Canvas.Effects;
+#if WINAPPSDK
+using Wc = Microsoft.UI.Composition;
+using Wm = Microsoft.UI.Xaml.Media;
+#else
+using Wc = Windows.UI.Composition;
+using Wm = Windows.UI.Xaml.Media;
+#endif
+using Wui = Windows.UI;
+
+namespace CommunityToolkit.WinUI.Lottie.LottieRuntime
+{
+    /// <summary>
+    /// Builds a <see cref="Wc.Visual"/> tree directly from a serialized composition.
+    /// </summary>
+    /// <remarks>
+    /// This is the managed counterpart of the native interpreter in
+    /// <c>dlls/LottieRuntime</c>. Both read the same FlatBuffer and build the same
+    /// visual tree, and both are structured the same way, so that a change to the
+    /// format only ever has to be made twice rather than in a different shape each
+    /// time.
+    /// <para/>
+    /// It differs from <c>Instantiator</c> in that it never builds a WinCompData
+    /// graph: the buffer is read in place and the composition objects are created as
+    /// the walk reaches them. That makes an animation data rather than code, so it can
+    /// be downloaded, themed or swapped without a rebuild, and the amount of code in
+    /// the application does not grow with the number of animations.
+    /// <para/>
+    /// A buffer is untrusted input. It is checked for the <c>LCMP</c> identifier, run
+    /// through the FlatBuffers verifier, and every index read out of it is range
+    /// checked. A malformed buffer is reported as a
+    /// <see cref="FlatBufferFormatException"/>; a buffer that needs something this
+    /// build cannot provide is reported as a <see cref="NotSupportedException"/>.
+    /// Neither reads outside the buffer.
+    /// </remarks>
+#if PUBLIC_LottieRuntime
+    public
+#endif
+    sealed class CompositionInterpreter
+    {
+        // The smallest buffer that could possibly be a composition: a root offset
+        // followed by the four byte file identifier. Checked before the identifier is
+        // read so that a short buffer is reported as a format error.
+        const int MinimumBufferLength = 8;
+
+        readonly Wc.Compositor _compositor;
+        readonly Fb.LottieComposition _root;
+        readonly string[] _strings;
+
+        // Realization caches. These are indexed identically to the node vectors in the
+        // buffer, so looking up an already realized node is an array index rather than
+        // a hash lookup, and a node that is reached by more than one path is realized
+        // exactly once. Each holds the least derived type that a reference to that
+        // category needs, which is what keeps the interpreter free of downcasts.
+        readonly Wc.Visual?[] _visuals;
+        readonly Wc.CompositionShape?[] _shapes;
+        readonly Wc.CompositionGeometry?[] _geometries;
+        readonly CanvasGeometry?[] _canvasGeometries;
+        readonly CanvasGeometryState[] _canvasGeometryStates;
+        readonly Wc.CompositionBrush?[] _brushes;
+        readonly Wc.CompositionColorGradientStop?[] _gradientStops;
+        readonly Wc.CompositionViewBox?[] _viewBoxes;
+        readonly Wc.CompositionClip?[] _clips;
+        readonly Wc.CompositionShadow?[] _shadows;
+        readonly Wc.ICompositionSurface?[] _surfaces;
+        readonly IGraphicsEffect?[] _effects;
+        readonly Wc.CompositionEasingFunction?[] _easings;
+        readonly Wc.CompositionAnimation?[] _animations;
+        readonly Wc.CompositionPropertySet?[] _propertySets;
+        readonly Wc.AnimationController?[] _controllers;
+
+        CompositionInterpreter(Wc.Compositor compositor, Fb.LottieComposition root)
+        {
+            _compositor = compositor;
+            _root = root;
+
+            _strings = new string[root.StringsLength];
+            for (var i = 0; i < _strings.Length; i++)
+            {
+                _strings[i] = root.Strings(i) ?? string.Empty;
+            }
+
+            _visuals = new Wc.Visual?[root.VisualsLength];
+            _shapes = new Wc.CompositionShape?[root.ShapesLength];
+            _geometries = new Wc.CompositionGeometry?[root.GeometriesLength];
+            _canvasGeometries = new CanvasGeometry?[root.CanvasGeometriesLength];
+            _canvasGeometryStates = new CanvasGeometryState[root.CanvasGeometriesLength];
+            _brushes = new Wc.CompositionBrush?[root.BrushesLength];
+            _gradientStops = new Wc.CompositionColorGradientStop?[root.GradientStopsLength];
+            _viewBoxes = new Wc.CompositionViewBox?[root.ViewBoxesLength];
+            _clips = new Wc.CompositionClip?[root.ClipsLength];
+            _shadows = new Wc.CompositionShadow?[root.ShadowsLength];
+            _surfaces = new Wc.ICompositionSurface?[root.SurfacesLength];
+            _effects = new IGraphicsEffect?[root.EffectsLength];
+            _easings = new Wc.CompositionEasingFunction?[root.EasingsLength];
+            _animations = new Wc.CompositionAnimation?[root.AnimationsLength];
+            _propertySets = new Wc.CompositionPropertySet?[root.PropertySetsLength];
+            _controllers = new Wc.AnimationController?[root.ControllersLength];
+        }
+
+        // A canvas geometry is built from other canvas geometries, so the walk has to
+        // be able to tell a shared geometry from a cycle.
+        enum CanvasGeometryState
+        {
+            Unrealized,
+            Realizing,
+            Realized,
+        }
+
+        /// <summary>
+        /// Builds the visual tree described by a serialized composition.
+        /// </summary>
+        /// <param name="compositor">The compositor that creates the objects.</param>
+        /// <param name="bytes">A buffer produced by <c>CompositionSerializer</c>.</param>
+        /// <returns>The root of the visual tree.</returns>
+        /// <exception cref="FlatBufferFormatException">The buffer is not a well formed composition.</exception>
+        /// <exception cref="NotSupportedException">The composition needs a newer schema or a newer version of Windows.</exception>
+        public static Wc.Visual LoadComposition(Wc.Compositor compositor, ReadOnlySpan<byte> bytes)
+        {
+            if (compositor is null)
+            {
+                throw new ArgumentNullException(nameof(compositor));
+            }
+
+            // The buffer is untrusted, so nothing is read out of it until the verifier
+            // has agreed that every offset in it is inside it.
+            var buffer = new ByteBuffer(bytes.ToArray());
+
+            if (bytes.Length < MinimumBufferLength ||
+                !Fb.LottieComposition.LottieCompositionBufferHasIdentifier(buffer))
+            {
+                throw new FlatBufferFormatException("The buffer is not a composition.");
+            }
+
+            Fb.LottieComposition root;
+
+            // Verification proves that the buffer is structurally sound, but it cannot
+            // prove that the indices stored in it point at the right things. Neither
+            // the verifier nor the reader reports a malformed buffer purely by
+            // returning false; both also throw. Everything that reads the buffer is
+            // therefore done inside a handler, so that a corrupt buffer always surfaces
+            // as a format error and never as an exception that a caller could not have
+            // anticipated.
+            try
+            {
+                if (!Fb.LottieComposition.VerifyLottieComposition(buffer))
+                {
+                    throw new FlatBufferFormatException("The buffer is not a valid composition.");
+                }
+
+                root = Fb.LottieComposition.GetRootAsLottieComposition(buffer);
+            }
+            catch (Exception e) when (IsBufferFailure(e))
+            {
+                throw new FlatBufferFormatException("The buffer is malformed.", e);
+            }
+
+            // A newer schema may store things in fields this build does not read, so a
+            // buffer that declares one is refused rather than silently misinterpreted.
+            if (root.SchemaVersion > Format.Version)
+            {
+                throw new NotSupportedException(
+                    $"Schema version {root.SchemaVersion} is newer than the supported version {Format.Version}.");
+            }
+
+            // The translator records the API contract that the graph needs. Checking it
+            // before anything is created means that an animation which cannot run on
+            // this version of Windows is refused rather than half built.
+            var requiredUapVersion = root.RequiredUapVersion;
+            if (requiredUapVersion != 0 &&
+                !ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", requiredUapVersion))
+            {
+                throw new NotSupportedException(
+                    $"The composition requires UniversalApiContract {requiredUapVersion}.");
+            }
+
+            try
+            {
+                var interpreter = new CompositionInterpreter(compositor, root);
+
+                return interpreter.GetVisual(root.RootVisual)
+                    ?? throw new FlatBufferFormatException("The composition has no root visual.");
+            }
+            catch (Exception e) when (IsBufferFailure(e))
+            {
+                throw new FlatBufferFormatException("The buffer is malformed.", e);
+            }
+        }
+
+        /// <summary>
+        /// Returns the property set that drives an interpreted composition.
+        /// </summary>
+        /// <param name="root">A root returned by <see cref="LoadComposition"/>.</param>
+        /// <returns>The property set that holds the animation's Progress property.</returns>
+        public static Wc.CompositionPropertySet ProgressPropertySet(Wc.Visual root)
+        {
+            if (root is null)
+            {
+                throw new ArgumentNullException(nameof(root));
+            }
+
+            return root.Properties;
+        }
+
+        // The failures that reading a structurally valid but semantically wrong buffer
+        // can produce. Reading past the end of the buffer is not a safety problem
+        // because ByteBuffer is bounds checked; the only thing being corrected here is
+        // the type of the exception.
+        static bool IsBufferFailure(Exception e)
+            => e is ArgumentException or IndexOutOfRangeException or
+                    InvalidOperationException or OverflowException or
+                    FormatException or NullReferenceException;
+
+        // ---------------------------------------------------------------------
+        // Table accessors. Every index is bounds checked, because a buffer that
+        // passes verification can still contain an out of range index.
+        // ---------------------------------------------------------------------
+        static T Require<T>(T? value, string what)
+            where T : struct
+            => value ?? throw new FlatBufferFormatException($"A {what} is missing.");
+
+        static uint RequireIndex(uint index, string what)
+            => index != Format.NullIndex
+                ? index
+                : throw new FlatBufferFormatException($"A required {what} is missing.");
+
+        string? GetString(uint index)
+            => index == Format.NullIndex
+                ? null
+                : index < (uint)_strings.Length
+                    ? _strings[index]
+                    : throw new FlatBufferFormatException($"String index {index} is out of range.");
+
+        string GetRequiredString(uint index)
+            => GetString(index) ?? throw new FlatBufferFormatException("A required string is missing.");
+
+        // ---------------------------------------------------------------------
+        // Shared state.
+        // ---------------------------------------------------------------------
+        // Applies the state that every CompositionObject has. Called after the object
+        // has been placed in its realization cache, so that a cycle terminates.
+        void InitializeCompositionObject(Wc.CompositionObject target, Fb.CompObj? source)
+        {
+            if (source is null)
+            {
+                return;
+            }
+
+            var value = source.Value;
+
+            if (GetString(value.Comment) is string comment)
+            {
+                target.Comment = comment;
+            }
+
+            // The property set is realized through the object that owns it, so that the
+            // owner and its property set can never both create it.
+            if (value.Properties != Format.NullIndex)
+            {
+                RealizePropertySet(value.Properties, target.Properties);
+            }
+
+            // Animations are started last, because setting a property stops any
+            // animation that is running on it.
+            for (var i = 0; i < value.AnimatorsLength; i++)
+            {
+                var animator = Require(value.Animators(i), "animator");
+                var property = GetRequiredString(animator.Property);
+                var animation = GetAnimation(animator.Animation)
+                    ?? throw new FlatBufferFormatException($"Animator '{property}' has no animation.");
+
+                // A non custom controller comes into existence when the animation is
+                // started, so only a custom one is passed in. Either way the resulting
+                // controller is cached under the index that the buffer gave it.
+                var controllerIndex = animator.Controller;
+                var customController = controllerIndex != Format.NullIndex && IsCustomController(controllerIndex)
+                    ? GetController(controllerIndex)
+                    : null;
+
+                // An expression animation is driven by its inputs and so cannot have a
+                // controller. This is checked here in order to reject the buffer rather
+                // than build an unusable tree.
+                if (customController is not null && animation is Wc.ExpressionAnimation)
+                {
+                    throw new FlatBufferFormatException(
+                        $"Animator '{property}' gives a controller to an expression animation.");
+                }
+
+                if (customController is null)
+                {
+                    target.StartAnimation(property, animation);
+                }
+                else
+                {
+                    target.StartAnimation(property, animation, customController);
+                }
+
+                if (controllerIndex != Format.NullIndex && customController is null)
+                {
+                    RealizeController(
+                        controllerIndex,
+                        target.TryGetAnimationController(property)
+                        ?? throw new FlatBufferFormatException($"Animator '{property}' has no controller."));
+                }
+            }
+        }
+
+        bool IsCustomController(uint index)
+            => GetControllerTable(index).IsCustom;
+
+        Fb.Controller GetControllerTable(uint index)
+            => index < (uint)_controllers.Length
+                ? Require(_root.Controllers((int)index), "controller")
+                : throw new FlatBufferFormatException($"Controller index {index} is out of range.");
+
+        void RealizeController(uint index, Wc.AnimationController controller)
+        {
+            if (_controllers[index] is not null)
+            {
+                return;
+            }
+
+            _controllers[index] = controller;
+
+            var table = GetControllerTable(index);
+
+            if (table.IsPaused)
+            {
+                controller.Pause();
+            }
+
+            InitializeCompositionObject(controller, table.Base);
+        }
+
+        Wc.AnimationController? GetController(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            var table = GetControllerTable(index);
+
+            if (_controllers[index] is null)
+            {
+                if (table.IsCustom)
+                {
+                    RealizeController(index, _compositor.CreateAnimationController());
+                }
+                else
+                {
+                    // A non custom controller comes into existence when its target
+                    // object starts the animation, so realizing the target realizes the
+                    // controller.
+                    GetObjectReference(table.TargetObject);
+                }
+            }
+
+            return _controllers[index]
+                ?? throw new FlatBufferFormatException($"Controller {index} could not be realized.");
+        }
+
+        // ---------------------------------------------------------------------
+        // Property sets.
+        // ---------------------------------------------------------------------
+        void RealizePropertySet(uint index, Wc.CompositionPropertySet propertySet)
+        {
+            if (index >= (uint)_propertySets.Length)
+            {
+                throw new FlatBufferFormatException($"Property set index {index} is out of range.");
+            }
+
+            if (_propertySets[index] is not null)
+            {
+                return;
+            }
+
+            // Cached before the values are applied, because a value may be an
+            // expression that refers back to this property set.
+            _propertySets[index] = propertySet;
+
+            var table = Require(_root.PropertySets((int)index), "property set");
+
+            for (var i = 0; i < table.ValuesLength; i++)
+            {
+                var value = Require(table.Values(i), "property value");
+                var name = GetRequiredString(value.Name);
+
+                switch (value.Type)
+                {
+                    case Fb.PropertyValueType.Color:
+                        propertySet.InsertColor(name, ToColor(Require(value.Color, "color")));
+                        break;
+                    case Fb.PropertyValueType.Scalar:
+                        propertySet.InsertScalar(name, value.Scalar);
+                        break;
+                    case Fb.PropertyValueType.Vector2:
+                        propertySet.InsertVector2(name, ToVector2(value.Vector));
+                        break;
+                    case Fb.PropertyValueType.Vector3:
+                        propertySet.InsertVector3(name, ToVector3(value.Vector));
+                        break;
+                    case Fb.PropertyValueType.Vector4:
+                        propertySet.InsertVector4(name, ToVector4(value.Vector));
+                        break;
+                    case Fb.PropertyValueType.None:
+                        break;
+                    default:
+                        throw new FlatBufferFormatException($"Unsupported property value type {value.Type}.");
+                }
+            }
+
+            InitializeCompositionObject(propertySet, table.Base);
+        }
+
+        Wc.CompositionPropertySet? GetPropertySet(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_propertySets.Length)
+            {
+                throw new FlatBufferFormatException($"Property set index {index} is out of range.");
+            }
+
+            if (_propertySets[index] is null)
+            {
+                var table = Require(_root.PropertySets((int)index), "property set");
+
+                if (table.Owner == Format.NullIndex)
+                {
+                    // A property set with no owner is a standalone one, which is how the
+                    // translator exposes theming properties.
+                    RealizePropertySet(index, _compositor.CreatePropertySet());
+                }
+                else
+                {
+                    // Realizing the owner realizes its property set as a side effect.
+                    GetObjectReference(table.Owner);
+                }
+            }
+
+            return _propertySets[index]
+                ?? throw new FlatBufferFormatException($"Property set {index} could not be realized.");
+        }
+
+        // Resolves a packed (category, index) reference. Only used by the fields that
+        // can point at an object of any category.
+        Wc.CompositionObject? GetObjectReference(uint reference)
+        {
+            if (reference == Format.NullIndex)
+            {
+                return null;
+            }
+
+            var category = Format.UnpackCategory(reference);
+            var index = (uint)Format.UnpackIndex(reference);
+
+            return category switch
+            {
+                Fb.ObjectCategory.Visual => GetVisual(index),
+                Fb.ObjectCategory.Shape => GetShape(index),
+                Fb.ObjectCategory.Geometry => GetGeometry(index),
+                Fb.ObjectCategory.Brush => GetBrush(index),
+                Fb.ObjectCategory.Animation => GetAnimation(index),
+                Fb.ObjectCategory.Easing => GetEasing(index),
+                Fb.ObjectCategory.PropertySet => GetPropertySet(index),
+
+                // Only a visual surface is a CompositionObject; an image surface is not,
+                // and nothing can legitimately reference one this way.
+                Fb.ObjectCategory.Surface => GetSurface(index) as Wc.CompositionObject
+                    ?? throw new FlatBufferFormatException("An image surface cannot be referenced."),
+                Fb.ObjectCategory.Clip => GetClip(index),
+                Fb.ObjectCategory.Controller => GetController(index),
+                Fb.ObjectCategory.Shadow => GetShadow(index),
+                Fb.ObjectCategory.GradientStop => GetGradientStop(index),
+                Fb.ObjectCategory.ViewBox => GetViewBox(index),
+                _ => throw new FlatBufferFormatException($"Unsupported object category {category}."),
+            };
+        }
+
+        // ---------------------------------------------------------------------
+        // Visuals.
+        // ---------------------------------------------------------------------
+        Wc.Visual? GetVisual(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_visuals.Length)
+            {
+                throw new FlatBufferFormatException($"Visual index {index} is out of range.");
+            }
+
+            if (_visuals[index] is Wc.Visual cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Visuals((int)index), "visual");
+
+            // The concrete type is known only here. Everything below this point,
+            // including the recursive walk into the children, uses a base type.
+            Wc.ContainerVisual result = table.Kind switch
+            {
+                Fb.VisualKind.Shape => _compositor.CreateShapeVisual(),
+                Fb.VisualKind.Sprite => _compositor.CreateSpriteVisual(),
+                Fb.VisualKind.Layer => _compositor.CreateLayerVisual(),
+                Fb.VisualKind.Container => _compositor.CreateContainerVisual(),
+                _ => throw new FlatBufferFormatException($"Unsupported visual kind {table.Kind}."),
+            };
+
+            // Cached before anything it refers to is realized, so that a cycle
+            // terminates.
+            _visuals[index] = result;
+
+            if (table.BorderMode.HasValue)
+            {
+                result.BorderMode = (Wc.CompositionBorderMode)table.BorderMode.Value;
+            }
+
+            if (ToVector3(table.CenterPoint) is Vector3 centerPoint)
+            {
+                result.CenterPoint = centerPoint;
+            }
+
+            if (table.Clip != Format.NullIndex)
+            {
+                result.Clip = GetClip(table.Clip);
+            }
+
+            if (table.IsVisible.HasValue)
+            {
+                result.IsVisible = table.IsVisible.Value;
+            }
+
+            if (ToVector3(table.Offset) is Vector3 offset)
+            {
+                result.Offset = offset;
+            }
+
+            if (table.Opacity.HasValue)
+            {
+                result.Opacity = table.Opacity.Value;
+            }
+
+            if (table.RotationAngleInDegrees.HasValue)
+            {
+                result.RotationAngleInDegrees = table.RotationAngleInDegrees.Value;
+            }
+
+            if (ToVector3(table.RotationAxis) is Vector3 rotationAxis)
+            {
+                result.RotationAxis = rotationAxis;
+            }
+
+            if (ToVector3(table.Scale) is Vector3 scale)
+            {
+                result.Scale = scale;
+            }
+
+            if (ToVector2(table.Size) is Vector2 size)
+            {
+                result.Size = size;
+            }
+
+            if (ToMatrix4x4(table.TransformMatrix) is Matrix4x4 transformMatrix)
+            {
+                result.TransformMatrix = transformMatrix;
+            }
+
+            switch (result)
+            {
+                case Wc.ShapeVisual shapeVisual:
+                    for (var i = 0; i < table.ShapesLength; i++)
+                    {
+                        shapeVisual.Shapes.Add(
+                            GetShape(table.Shapes(i))
+                            ?? throw new FlatBufferFormatException("A shape is missing."));
+                    }
+
+                    if (table.ViewBox != Format.NullIndex)
+                    {
+                        shapeVisual.ViewBox = GetViewBox(table.ViewBox);
+                    }
+
+                    break;
+                case Wc.SpriteVisual spriteVisual:
+                    if (table.Brush != Format.NullIndex)
+                    {
+                        spriteVisual.Brush = GetBrush(table.Brush);
+                    }
+
+                    if (table.Shadow != Format.NullIndex)
+                    {
+                        spriteVisual.Shadow = GetShadow(table.Shadow);
+                    }
+
+                    break;
+                case Wc.LayerVisual layerVisual:
+                    if (table.Shadow != Format.NullIndex)
+                    {
+                        layerVisual.Shadow = GetShadow(table.Shadow);
+                    }
+
+                    break;
+            }
+
+            for (var i = 0; i < table.ChildrenLength; i++)
+            {
+                result.Children.InsertAtTop(
+                    GetVisual(table.Children(i))
+                    ?? throw new FlatBufferFormatException("A visual child is missing."));
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        // ---------------------------------------------------------------------
+        // Shapes.
+        // ---------------------------------------------------------------------
+        Wc.CompositionShape? GetShape(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_shapes.Length)
+            {
+                throw new FlatBufferFormatException($"Shape index {index} is out of range.");
+            }
+
+            if (_shapes[index] is Wc.CompositionShape cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Shapes((int)index), "shape");
+
+            Wc.CompositionShape result = table.Kind switch
+            {
+                Fb.ShapeKind.Sprite => _compositor.CreateSpriteShape(),
+                Fb.ShapeKind.Container => _compositor.CreateContainerShape(),
+                _ => throw new FlatBufferFormatException($"Unsupported shape kind {table.Kind}."),
+            };
+
+            _shapes[index] = result;
+
+            if (ToVector2(table.CenterPoint) is Vector2 centerPoint)
+            {
+                result.CenterPoint = centerPoint;
+            }
+
+            if (ToVector2(table.Offset) is Vector2 offset)
+            {
+                result.Offset = offset;
+            }
+
+            if (table.RotationAngleInDegrees.HasValue)
+            {
+                result.RotationAngleInDegrees = table.RotationAngleInDegrees.Value;
+            }
+
+            if (ToVector2(table.Scale) is Vector2 scale)
+            {
+                result.Scale = scale;
+            }
+
+            if (ToMatrix3x2(table.TransformMatrix) is Matrix3x2 transformMatrix)
+            {
+                result.TransformMatrix = transformMatrix;
+            }
+
+            switch (result)
+            {
+                case Wc.CompositionContainerShape containerShape:
+                    for (var i = 0; i < table.ShapesLength; i++)
+                    {
+                        containerShape.Shapes.Add(
+                            GetShape(table.Shapes(i))
+                            ?? throw new FlatBufferFormatException("A shape is missing."));
+                    }
+
+                    break;
+                case Wc.CompositionSpriteShape spriteShape:
+                    ApplySpriteShapeProperties(spriteShape, table);
+                    break;
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        void ApplySpriteShapeProperties(Wc.CompositionSpriteShape target, Fb.Shape table)
+        {
+            if (table.FillBrush != Format.NullIndex)
+            {
+                target.FillBrush = GetBrush(table.FillBrush);
+            }
+
+            if (table.StrokeBrush != Format.NullIndex)
+            {
+                target.StrokeBrush = GetBrush(table.StrokeBrush);
+            }
+
+            if (table.Geometry != Format.NullIndex)
+            {
+                target.Geometry = GetGeometry(table.Geometry);
+            }
+
+            if (table.IsStrokeNonScaling.HasValue)
+            {
+                target.IsStrokeNonScaling = table.IsStrokeNonScaling.Value;
+            }
+
+            if (table.StrokeDashOffset.HasValue)
+            {
+                target.StrokeDashOffset = table.StrokeDashOffset.Value;
+            }
+
+            for (var i = 0; i < table.StrokeDashArrayLength; i++)
+            {
+                target.StrokeDashArray.Add(table.StrokeDashArray(i));
+            }
+
+            if (table.StrokeDashCap.HasValue)
+            {
+                target.StrokeDashCap = (Wc.CompositionStrokeCap)table.StrokeDashCap.Value;
+            }
+
+            if (table.StrokeStartCap.HasValue)
+            {
+                target.StrokeStartCap = (Wc.CompositionStrokeCap)table.StrokeStartCap.Value;
+            }
+
+            if (table.StrokeEndCap.HasValue)
+            {
+                target.StrokeEndCap = (Wc.CompositionStrokeCap)table.StrokeEndCap.Value;
+            }
+
+            if (table.StrokeLineJoin.HasValue)
+            {
+                target.StrokeLineJoin = (Wc.CompositionStrokeLineJoin)table.StrokeLineJoin.Value;
+            }
+
+            if (table.StrokeMiterLimit.HasValue)
+            {
+                target.StrokeMiterLimit = table.StrokeMiterLimit.Value;
+            }
+
+            if (table.StrokeThickness.HasValue)
+            {
+                target.StrokeThickness = table.StrokeThickness.Value;
+            }
+        }
+
+        // ---------------------------------------------------------------------
+        // Geometries.
+        // ---------------------------------------------------------------------
+        Wc.CompositionGeometry? GetGeometry(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_geometries.Length)
+            {
+                throw new FlatBufferFormatException($"Geometry index {index} is out of range.");
+            }
+
+            if (_geometries[index] is Wc.CompositionGeometry cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Geometries((int)index), "geometry");
+
+            Wc.CompositionGeometry result = table.Kind switch
+            {
+                Fb.GeometryKind.Rectangle => _compositor.CreateRectangleGeometry(),
+                Fb.GeometryKind.RoundedRectangle => _compositor.CreateRoundedRectangleGeometry(),
+                Fb.GeometryKind.Ellipse => _compositor.CreateEllipseGeometry(),
+                Fb.GeometryKind.Path => _compositor.CreatePathGeometry(),
+                _ => throw new FlatBufferFormatException($"Unsupported geometry kind {table.Kind}."),
+            };
+
+            _geometries[index] = result;
+
+            if (table.TrimStart.HasValue)
+            {
+                result.TrimStart = table.TrimStart.Value;
+            }
+
+            if (table.TrimEnd.HasValue)
+            {
+                result.TrimEnd = table.TrimEnd.Value;
+            }
+
+            if (table.TrimOffset.HasValue)
+            {
+                result.TrimOffset = table.TrimOffset.Value;
+            }
+
+            switch (result)
+            {
+                case Wc.CompositionPathGeometry pathGeometry:
+                    var path = GetCanvasGeometry(table.Path);
+                    pathGeometry.Path = path is null ? null : new Wc.CompositionPath(path);
+                    break;
+                case Wc.CompositionRoundedRectangleGeometry roundedRectangle:
+                    if (ToVector2(table.Offset) is Vector2 roundedOffset)
+                    {
+                        roundedRectangle.Offset = roundedOffset;
+                    }
+
+                    if (ToVector2(table.Size) is Vector2 roundedSize)
+                    {
+                        roundedRectangle.Size = roundedSize;
+                    }
+
+                    roundedRectangle.CornerRadius = ToVector2(table.CornerRadius) ?? Vector2.Zero;
+                    break;
+                case Wc.CompositionRectangleGeometry rectangle:
+                    if (ToVector2(table.Offset) is Vector2 rectangleOffset)
+                    {
+                        rectangle.Offset = rectangleOffset;
+                    }
+
+                    if (ToVector2(table.Size) is Vector2 rectangleSize)
+                    {
+                        rectangle.Size = rectangleSize;
+                    }
+
+                    break;
+                case Wc.CompositionEllipseGeometry ellipse:
+                    ellipse.Center = ToVector2(table.Center) ?? Vector2.Zero;
+                    ellipse.Radius = ToVector2(table.Radius) ?? Vector2.Zero;
+                    break;
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        // ---------------------------------------------------------------------
+        // Brushes.
+        // ---------------------------------------------------------------------
+        Wc.CompositionBrush? GetBrush(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_brushes.Length)
+            {
+                throw new FlatBufferFormatException($"Brush index {index} is out of range.");
+            }
+
+            if (_brushes[index] is Wc.CompositionBrush cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Brushes((int)index), "brush");
+
+            Wc.CompositionBrush result;
+            switch (table.Kind)
+            {
+                case Fb.BrushKind.Color:
+                    result = _compositor.CreateColorBrush();
+                    break;
+                case Fb.BrushKind.LinearGradient:
+                    result = _compositor.CreateLinearGradientBrush();
+                    break;
+                case Fb.BrushKind.RadialGradient:
+                    result = _compositor.CreateRadialGradientBrush();
+                    break;
+                case Fb.BrushKind.Mask:
+                    result = _compositor.CreateMaskBrush();
+                    break;
+                case Fb.BrushKind.Surface:
+                    // The surface is needed in order to construct the brush, so it is
+                    // realized before the brush is placed in the cache.
+                    result = _compositor.CreateSurfaceBrush(
+                        GetSurface(RequireIndex(table.Surface, "surface"))
+                        ?? throw new FlatBufferFormatException("A surface brush has no surface."));
+                    break;
+                case Fb.BrushKind.Effect:
+                    var effect = GetEffect(RequireIndex(table.Effect, "effect"))
+                        ?? throw new FlatBufferFormatException("An effect brush has no effect.");
+                    result = _compositor.CreateEffectFactory(effect).CreateBrush();
+                    break;
+                default:
+                    throw new FlatBufferFormatException($"Unsupported brush kind {table.Kind}.");
+            }
+
+            _brushes[index] = result;
+
+            switch (result)
+            {
+                case Wc.CompositionColorBrush colorBrush:
+                    if (table.Color.HasValue)
+                    {
+                        colorBrush.Color = ToColor(table.Color.Value);
+                    }
+
+                    break;
+                case Wc.CompositionMaskBrush maskBrush:
+                    if (table.Source != Format.NullIndex)
+                    {
+                        maskBrush.Source = GetBrush(table.Source);
+                    }
+
+                    if (table.Mask != Format.NullIndex)
+                    {
+                        maskBrush.Mask = GetBrush(table.Mask);
+                    }
+
+                    break;
+                case Wc.CompositionEffectBrush effectBrush:
+                    for (var i = 0; i < table.SourceParametersLength; i++)
+                    {
+                        var parameter = Require(table.SourceParameters(i), "source parameter");
+                        effectBrush.SetSourceParameter(
+                            GetRequiredString(parameter.Name),
+                            GetBrush(parameter.Brush)
+                            ?? throw new FlatBufferFormatException("An effect source has no brush."));
+                    }
+
+                    break;
+            }
+
+            if (result is Wc.CompositionGradientBrush gradientBrush)
+            {
+                ApplyGradientBrushProperties(gradientBrush, table);
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        void ApplyGradientBrushProperties(Wc.CompositionGradientBrush target, Fb.Brush table)
+        {
+            if (ToVector2(table.AnchorPoint) is Vector2 anchorPoint)
+            {
+                target.AnchorPoint = anchorPoint;
+            }
+
+            if (ToVector2(table.CenterPoint) is Vector2 centerPoint)
+            {
+                target.CenterPoint = centerPoint;
+            }
+
+            for (var i = 0; i < table.ColorStopsLength; i++)
+            {
+                target.ColorStops.Add(
+                    GetGradientStop(table.ColorStops(i))
+                    ?? throw new FlatBufferFormatException("A gradient stop is missing."));
+            }
+
+            if (table.ExtendMode.HasValue)
+            {
+                target.ExtendMode = (Wc.CompositionGradientExtendMode)table.ExtendMode.Value;
+            }
+
+            if (table.InterpolationSpace.HasValue)
+            {
+                target.InterpolationSpace = (Wc.CompositionColorSpace)table.InterpolationSpace.Value;
+            }
+
+            if (table.MappingMode.HasValue)
+            {
+                target.MappingMode = (Wc.CompositionMappingMode)table.MappingMode.Value;
+            }
+
+            if (ToVector2(table.Offset) is Vector2 offset)
+            {
+                target.Offset = offset;
+            }
+
+            if (table.RotationAngleInDegrees.HasValue)
+            {
+                target.RotationAngleInDegrees = table.RotationAngleInDegrees.Value;
+            }
+
+            if (ToVector2(table.Scale) is Vector2 scale)
+            {
+                target.Scale = scale;
+            }
+
+            if (ToMatrix3x2(table.TransformMatrix) is Matrix3x2 transformMatrix)
+            {
+                target.TransformMatrix = transformMatrix;
+            }
+
+            switch (target)
+            {
+                case Wc.CompositionLinearGradientBrush linear:
+                    if (ToVector2(table.StartPoint) is Vector2 startPoint)
+                    {
+                        linear.StartPoint = startPoint;
+                    }
+
+                    if (ToVector2(table.EndPoint) is Vector2 endPoint)
+                    {
+                        linear.EndPoint = endPoint;
+                    }
+
+                    break;
+                case Wc.CompositionRadialGradientBrush radial:
+                    if (ToVector2(table.EllipseCenter) is Vector2 ellipseCenter)
+                    {
+                        radial.EllipseCenter = ellipseCenter;
+                    }
+
+                    if (ToVector2(table.EllipseRadius) is Vector2 ellipseRadius)
+                    {
+                        radial.EllipseRadius = ellipseRadius;
+                    }
+
+                    if (ToVector2(table.GradientOriginOffset) is Vector2 gradientOriginOffset)
+                    {
+                        radial.GradientOriginOffset = gradientOriginOffset;
+                    }
+
+                    break;
+            }
+        }
+
+        Wc.CompositionColorGradientStop? GetGradientStop(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_gradientStops.Length)
+            {
+                throw new FlatBufferFormatException($"Gradient stop index {index} is out of range.");
+            }
+
+            if (_gradientStops[index] is Wc.CompositionColorGradientStop cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.GradientStops((int)index), "gradient stop");
+            var result = _compositor.CreateColorGradientStop();
+            _gradientStops[index] = result;
+
+            result.Color = ToColor(Require(table.Color, "color"));
+            result.Offset = table.Offset;
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        // ---------------------------------------------------------------------
+        // Clips, view boxes, shadows and surfaces.
+        // ---------------------------------------------------------------------
+        Wc.CompositionViewBox? GetViewBox(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_viewBoxes.Length)
+            {
+                throw new FlatBufferFormatException($"View box index {index} is out of range.");
+            }
+
+            if (_viewBoxes[index] is Wc.CompositionViewBox cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.ViewBoxes((int)index), "view box");
+            var result = _compositor.CreateViewBox();
+            _viewBoxes[index] = result;
+
+            result.Size = ToVector2(table.Size) ?? Vector2.Zero;
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        Wc.CompositionClip? GetClip(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_clips.Length)
+            {
+                throw new FlatBufferFormatException($"Clip index {index} is out of range.");
+            }
+
+            if (_clips[index] is Wc.CompositionClip cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Clips((int)index), "clip");
+
+            Wc.CompositionClip result = table.Kind switch
+            {
+                Fb.ClipKind.Geometric => _compositor.CreateGeometricClip(),
+                Fb.ClipKind.Inset => _compositor.CreateInsetClip(),
+                _ => throw new FlatBufferFormatException($"Unsupported clip kind {table.Kind}."),
+            };
+
+            _clips[index] = result;
+
+            if (ToVector2(table.CenterPoint) is Vector2 centerPoint)
+            {
+                result.CenterPoint = centerPoint;
+            }
+
+            if (ToVector2(table.Scale) is Vector2 scale)
+            {
+                result.Scale = scale;
+            }
+
+            switch (result)
+            {
+                case Wc.InsetClip inset:
+                    if (table.LeftInset.HasValue)
+                    {
+                        inset.LeftInset = table.LeftInset.Value;
+                    }
+
+                    if (table.RightInset.HasValue)
+                    {
+                        inset.RightInset = table.RightInset.Value;
+                    }
+
+                    if (table.TopInset.HasValue)
+                    {
+                        inset.TopInset = table.TopInset.Value;
+                    }
+
+                    if (table.BottomInset.HasValue)
+                    {
+                        inset.BottomInset = table.BottomInset.Value;
+                    }
+
+                    break;
+                case Wc.CompositionGeometricClip geometric:
+                    if (table.Geometry != Format.NullIndex)
+                    {
+                        geometric.Geometry = GetGeometry(table.Geometry);
+                    }
+
+                    break;
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        Wc.CompositionShadow? GetShadow(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_shadows.Length)
+            {
+                throw new FlatBufferFormatException($"Shadow index {index} is out of range.");
+            }
+
+            if (_shadows[index] is Wc.CompositionShadow cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Shadows((int)index), "shadow");
+
+            Wc.CompositionShadow result = table.Kind switch
+            {
+                Fb.ShadowKind.Drop => _compositor.CreateDropShadow(),
+                _ => throw new FlatBufferFormatException($"Unsupported shadow kind {table.Kind}."),
+            };
+
+            _shadows[index] = result;
+
+            if (result is Wc.DropShadow dropShadow)
+            {
+                if (table.BlurRadius.HasValue)
+                {
+                    dropShadow.BlurRadius = table.BlurRadius.Value;
+                }
+
+                if (table.Color.HasValue)
+                {
+                    dropShadow.Color = ToColor(table.Color.Value);
+                }
+
+                if (table.Mask != Format.NullIndex)
+                {
+                    dropShadow.Mask = GetBrush(table.Mask);
+                }
+
+                if (ToVector3(table.Offset) is Vector3 offset)
+                {
+                    dropShadow.Offset = offset;
+                }
+
+                if (table.Opacity.HasValue)
+                {
+                    dropShadow.Opacity = table.Opacity.Value;
+                }
+
+                if (table.SourcePolicy.HasValue)
+                {
+                    dropShadow.SourcePolicy = (Wc.CompositionDropShadowSourcePolicy)table.SourcePolicy.Value;
+                }
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        Wc.ICompositionSurface? GetSurface(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_surfaces.Length)
+            {
+                throw new FlatBufferFormatException($"Surface index {index} is out of range.");
+            }
+
+            if (_surfaces[index] is Wc.ICompositionSurface cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Surfaces((int)index), "surface");
+
+            switch (table.Kind)
+            {
+                case Fb.SurfaceKind.VisualSurface:
+                    var visualSurface = _compositor.CreateVisualSurface();
+                    _surfaces[index] = visualSurface;
+
+                    if (table.SourceVisual != Format.NullIndex)
+                    {
+                        visualSurface.SourceVisual = GetVisual(table.SourceVisual);
+                    }
+
+                    if (ToVector2(table.SourceSize) is Vector2 sourceSize)
+                    {
+                        visualSurface.SourceSize = sourceSize;
+                    }
+
+                    if (ToVector2(table.SourceOffset) is Vector2 sourceOffset)
+                    {
+                        visualSurface.SourceOffset = sourceOffset;
+                    }
+
+                    InitializeCompositionObject(visualSurface, table.Base);
+                    return visualSurface;
+
+                case Fb.SurfaceKind.LoadedImageFromUri:
+                    var uri = GetRequiredString(table.Uri);
+                    var fromUri = Wm.LoadedImageSurface.StartLoadFromUri(new Uri(uri, UriKind.RelativeOrAbsolute));
+                    _surfaces[index] = fromUri;
+                    return fromUri;
+
+                case Fb.SurfaceKind.LoadedImageFromStream:
+                    var bytes = new byte[table.BytesLength];
+                    for (var i = 0; i < bytes.Length; i++)
+                    {
+                        bytes[i] = table.Bytes(i);
+                    }
+
+                    var fromStream = Wm.LoadedImageSurface.StartLoadFromStream(
+                        bytes.AsBuffer().AsStream().AsRandomAccessStream());
+                    _surfaces[index] = fromStream;
+                    return fromStream;
+
+                default:
+                    throw new FlatBufferFormatException($"Unsupported surface kind {table.Kind}.");
+            }
+        }
+
+        // ---------------------------------------------------------------------
+        // Effects.
+        // ---------------------------------------------------------------------
+        IGraphicsEffect? GetEffect(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_effects.Length)
+            {
+                throw new FlatBufferFormatException($"Effect index {index} is out of range.");
+            }
+
+            if (_effects[index] is IGraphicsEffect cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Effects((int)index), "effect");
+
+            // The sources are the names that the brush later binds real brushes to. The
+            // composition engine matches them up by name.
+            var sources = new List<Wc.CompositionEffectSourceParameter>(table.SourcesLength);
+            for (var i = 0; i < table.SourcesLength; i++)
+            {
+                sources.Add(new Wc.CompositionEffectSourceParameter(GetRequiredString(table.Sources(i))));
+            }
+
+            IGraphicsEffect result;
+            switch (table.Kind)
+            {
+                case Fb.EffectKind.Composite:
+                    var composite = new Mgce.CompositeEffect
+                    {
+                        Mode = (Mgc.CanvasComposite)table.Mode,
+                    };
+
+                    foreach (var source in sources)
+                    {
+                        composite.Sources.Add(source);
+                    }
+
+                    result = composite;
+                    break;
+                case Fb.EffectKind.GaussianBlur:
+                    if (sources.Count != 1)
+                    {
+                        throw new FlatBufferFormatException("A blur effect must have exactly one source.");
+                    }
+
+                    result = new Mgce.GaussianBlurEffect
+                    {
+                        BlurAmount = table.BlurAmount,
+                        Source = sources[0],
+                    };
+                    break;
+                default:
+                    throw new FlatBufferFormatException($"Unsupported effect kind {table.Kind}.");
+            }
+
+            _effects[index] = result;
+            return result;
+        }
+
+        // ---------------------------------------------------------------------
+        // Easings.
+        // ---------------------------------------------------------------------
+        Wc.CompositionEasingFunction? GetEasing(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_easings.Length)
+            {
+                throw new FlatBufferFormatException($"Easing index {index} is out of range.");
+            }
+
+            if (_easings[index] is Wc.CompositionEasingFunction cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Easings((int)index), "easing");
+
+            Wc.CompositionEasingFunction result;
+            switch (table.Kind)
+            {
+                case Fb.EasingKind.Linear:
+                    result = _compositor.CreateLinearEasingFunction();
+                    break;
+                case Fb.EasingKind.CubicBezier:
+                    result = _compositor.CreateCubicBezierEasingFunction(
+                        ToVector2(table.ControlPoint1) ?? Vector2.Zero,
+                        ToVector2(table.ControlPoint2) ?? Vector2.Zero);
+                    break;
+                case Fb.EasingKind.Step:
+                    var step = _compositor.CreateStepEasingFunction();
+
+                    if (table.StepCount.HasValue)
+                    {
+                        step.StepCount = table.StepCount.Value;
+                    }
+
+                    if (table.InitialStep.HasValue)
+                    {
+                        step.InitialStep = table.InitialStep.Value;
+                    }
+
+                    if (table.FinalStep.HasValue)
+                    {
+                        step.FinalStep = table.FinalStep.Value;
+                    }
+
+                    if (table.IsInitialStepSingleFrame.HasValue)
+                    {
+                        step.IsInitialStepSingleFrame = table.IsInitialStepSingleFrame.Value;
+                    }
+
+                    if (table.IsFinalStepSingleFrame.HasValue)
+                    {
+                        step.IsFinalStepSingleFrame = table.IsFinalStepSingleFrame.Value;
+                    }
+
+                    result = step;
+                    break;
+                default:
+                    throw new FlatBufferFormatException($"Unsupported easing kind {table.Kind}.");
+            }
+
+            _easings[index] = result;
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        // ---------------------------------------------------------------------
+        // Animations.
+        // ---------------------------------------------------------------------
+        Wc.CompositionAnimation? GetAnimation(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_animations.Length)
+            {
+                throw new FlatBufferFormatException($"Animation index {index} is out of range.");
+            }
+
+            if (_animations[index] is Wc.CompositionAnimation cached)
+            {
+                return cached;
+            }
+
+            var table = Require(_root.Animations((int)index), "animation");
+
+            Wc.CompositionAnimation result = table.Kind == Fb.AnimationKind.Expression
+                ? _compositor.CreateExpressionAnimation(GetRequiredString(table.Expression))
+                : CreateKeyFrameAnimation(table);
+
+            _animations[index] = result;
+
+            if (GetString(table.Target) is string target)
+            {
+                result.Target = target;
+            }
+
+            for (var i = 0; i < table.ReferenceParametersLength; i++)
+            {
+                var parameter = Require(table.ReferenceParameters(i), "reference parameter");
+                result.SetReferenceParameter(
+                    GetRequiredString(parameter.Name),
+                    GetObjectReference(parameter.Target)
+                    ?? throw new FlatBufferFormatException("A reference parameter has no target."));
+            }
+
+            InitializeCompositionObject(result, table.Base);
+            return result;
+        }
+
+        // Creates the animation and inserts its key frames in one place, because the
+        // concrete type is only needed in order to insert a value key frame and would
+        // otherwise have to be recovered with a cast.
+        Wc.CompositionAnimation CreateKeyFrameAnimation(Fb.Animation table)
+        {
+            Wc.KeyFrameAnimation result;
+
+            switch (table.Kind)
+            {
+                case Fb.AnimationKind.Scalar:
+                    var scalar = _compositor.CreateScalarKeyFrameAnimation();
+                    ForEachValueKeyFrame(table, frame =>
+                        scalar.InsertKeyFrame(frame.Progress, frame.Scalar, GetEasing(frame.Easing)));
+                    result = scalar;
+                    break;
+                case Fb.AnimationKind.Vector2:
+                    var vector2 = _compositor.CreateVector2KeyFrameAnimation();
+                    ForEachValueKeyFrame(table, frame =>
+                        vector2.InsertKeyFrame(frame.Progress, ToVector2(frame.Vector), GetEasing(frame.Easing)));
+                    result = vector2;
+                    break;
+                case Fb.AnimationKind.Vector3:
+                    var vector3 = _compositor.CreateVector3KeyFrameAnimation();
+                    ForEachValueKeyFrame(table, frame =>
+                        vector3.InsertKeyFrame(frame.Progress, ToVector3(frame.Vector), GetEasing(frame.Easing)));
+                    result = vector3;
+                    break;
+                case Fb.AnimationKind.Vector4:
+                    var vector4 = _compositor.CreateVector4KeyFrameAnimation();
+                    ForEachValueKeyFrame(table, frame =>
+                        vector4.InsertKeyFrame(frame.Progress, ToVector4(frame.Vector), GetEasing(frame.Easing)));
+                    result = vector4;
+                    break;
+                case Fb.AnimationKind.Color:
+                    var color = _compositor.CreateColorKeyFrameAnimation();
+
+                    if (table.InterpolationColorSpace.HasValue)
+                    {
+                        color.InterpolationColorSpace =
+                            (Wc.CompositionColorSpace)table.InterpolationColorSpace.Value;
+                    }
+
+                    ForEachValueKeyFrame(table, frame =>
+                        color.InsertKeyFrame(
+                            frame.Progress,
+                            ToColor(Require(frame.Color, "color")),
+                            GetEasing(frame.Easing)));
+                    result = color;
+                    break;
+                case Fb.AnimationKind.Boolean:
+                    var boolean = _compositor.CreateBooleanKeyFrameAnimation();
+
+                    // A boolean cannot be interpolated, so it has no easing.
+                    ForEachValueKeyFrame(table, frame =>
+                        boolean.InsertKeyFrame(frame.Progress, frame.Scalar != 0));
+                    result = boolean;
+                    break;
+                case Fb.AnimationKind.Path:
+                    var path = _compositor.CreatePathKeyFrameAnimation();
+                    ForEachValueKeyFrame(table, frame =>
+                        path.InsertKeyFrame(
+                            frame.Progress,
+                            new Wc.CompositionPath(
+                                GetCanvasGeometry(frame.Path)
+                                ?? throw new FlatBufferFormatException("A path key frame has no path.")),
+                            GetEasing(frame.Easing)));
+                    result = path;
+                    break;
+                default:
+                    throw new FlatBufferFormatException($"Unsupported animation kind {table.Kind}.");
+            }
+
+            // Expression key frames are inserted through the base type, so they do not
+            // have to be repeated in every branch above. They are inserted after the
+            // value key frames, which is safe because a key frame animation is a map
+            // keyed on progress rather than a list.
+            for (var i = 0; i < table.KeyFramesLength; i++)
+            {
+                var frame = Require(table.KeyFrames(i), "key frame");
+
+                if (frame.Kind == Fb.KeyFrameKind.Expression)
+                {
+                    result.InsertExpressionKeyFrame(
+                        frame.Progress,
+                        GetRequiredString(frame.Expression),
+                        GetEasing(frame.Easing));
+                }
+            }
+
+            result.Duration = TimeSpan.FromTicks(table.DurationTicks);
+
+            return result;
+        }
+
+        void ForEachValueKeyFrame(Fb.Animation table, Action<Fb.KeyFrame> apply)
+        {
+            for (var i = 0; i < table.KeyFramesLength; i++)
+            {
+                var frame = Require(table.KeyFrames(i), "key frame");
+
+                if (frame.Kind == Fb.KeyFrameKind.Value)
+                {
+                    apply(frame);
+                }
+            }
+        }
+
+        // ---------------------------------------------------------------------
+        // Paths.
+        //
+        // A canvas geometry is not a CompositionObject, so it has no shared state and
+        // no animators; it is only ever a value.
+        // ---------------------------------------------------------------------
+        CanvasGeometry? GetCanvasGeometry(uint index)
+        {
+            if (index == Format.NullIndex)
+            {
+                return null;
+            }
+
+            if (index >= (uint)_canvasGeometries.Length)
+            {
+                throw new FlatBufferFormatException($"Canvas geometry index {index} is out of range.");
+            }
+
+            switch (_canvasGeometryStates[index])
+            {
+                case CanvasGeometryState.Realized:
+                    return _canvasGeometries[index];
+                case CanvasGeometryState.Realizing:
+                    // A geometry that is built from itself would never finish.
+                    throw new FlatBufferFormatException($"Canvas geometry {index} is cyclic.");
+            }
+
+            _canvasGeometryStates[index] = CanvasGeometryState.Realizing;
+
+            var table = Require(_root.CanvasGeometries((int)index), "canvas geometry");
+
+            CanvasGeometry result;
+            switch (table.Kind)
+            {
+                case Fb.CanvasGeometryKind.Combination:
+                    var a = GetCanvasGeometry(RequireIndex(table.A, "geometry"))
+                        ?? throw new FlatBufferFormatException("A combination has no first geometry.");
+                    var b = GetCanvasGeometry(RequireIndex(table.B, "geometry"))
+                        ?? throw new FlatBufferFormatException("A combination has no second geometry.");
+                    result = a.CombineWith(
+                        b,
+                        ToMatrix3x2(table.Matrix) ?? Matrix3x2.Identity,
+                        (CanvasGeometryCombine)table.CombineMode);
+                    break;
+
+                case Fb.CanvasGeometryKind.TransformedGeometry:
+                    var source = GetCanvasGeometry(RequireIndex(table.Source, "geometry"))
+                        ?? throw new FlatBufferFormatException("A transformed geometry has no source.");
+                    result = source.Transform(ToMatrix3x2(table.Matrix) ?? Matrix3x2.Identity);
+                    break;
+
+                case Fb.CanvasGeometryKind.Group:
+                    var geometries = new CanvasGeometry[table.GeometriesLength];
+                    for (var i = 0; i < geometries.Length; i++)
+                    {
+                        geometries[i] = GetCanvasGeometry(table.Geometries(i))
+                            ?? throw new FlatBufferFormatException("A grouped geometry is missing.");
+                    }
+
+                    result = CanvasGeometry.CreateGroup(
+                        null,
+                        geometries,
+                        (CanvasFilledRegionDetermination)table.FillRule);
+                    break;
+
+                case Fb.CanvasGeometryKind.Path:
+                    result = CreatePath(table);
+                    break;
+
+                case Fb.CanvasGeometryKind.Ellipse:
+                    result = CanvasGeometry.CreateEllipse(null, table.X, table.Y, table.RadiusX, table.RadiusY);
+                    break;
+
+                case Fb.CanvasGeometryKind.RoundedRectangle:
+                    result = CanvasGeometry.CreateRoundedRectangle(
+                        null, table.X, table.Y, table.W, table.H, table.RadiusX, table.RadiusY);
+                    break;
+
+                default:
+                    throw new FlatBufferFormatException($"Unsupported canvas geometry kind {table.Kind}.");
+            }
+
+            _canvasGeometries[index] = result;
+            _canvasGeometryStates[index] = CanvasGeometryState.Realized;
+            return result;
+        }
+
+        // Replays the flattened opcode and operand streams of a path. The operands of
+        // every command are consecutive in one array, which is why there is no table
+        // per command.
+        static CanvasGeometry CreatePath(Fb.CanvasGeometry table)
+        {
+            using var builder = new CanvasPathBuilder(null);
+            builder.SetFilledRegionDetermination((CanvasFilledRegionDetermination)table.FillRule);
+
+            var operand = 0;
+            var inFigure = false;
+
+            float Next()
+                => operand < table.OperandsLength
+                    ? table.Operands(operand++)
+                    : throw new FlatBufferFormatException("A path ran out of operands.");
+
+            void RequireFigure(bool expected)
+            {
+                if (inFigure != expected)
+                {
+                    throw new FlatBufferFormatException("A path has a figure that does not begin and end.");
+                }
+            }
+
+            for (var i = 0; i < table.OpsLength; i++)
+            {
+                switch ((Fb.PathOp)table.Ops(i))
+                {
+                    case Fb.PathOp.BeginFigure:
+                        RequireFigure(false);
+                        builder.BeginFigure(new Vector2(Next(), Next()));
+                        inFigure = true;
+                        break;
+                    case Fb.PathOp.EndFigure:
+                        RequireFigure(true);
+                        builder.EndFigure((CanvasFigureLoop)Next());
+                        inFigure = false;
+                        break;
+                    case Fb.PathOp.AddLine:
+                        RequireFigure(true);
+                        builder.AddLine(new Vector2(Next(), Next()));
+                        break;
+                    case Fb.PathOp.AddCubicBezier:
+                        RequireFigure(true);
+                        builder.AddCubicBezier(
+                            new Vector2(Next(), Next()),
+                            new Vector2(Next(), Next()),
+                            new Vector2(Next(), Next()));
+                        break;
+                    default:
+                        throw new FlatBufferFormatException($"Unsupported path opcode {table.Ops(i)}.");
+                }
+            }
+
+            RequireFigure(false);
+
+            return CanvasGeometry.CreatePath(builder);
+        }
+
+        // ---------------------------------------------------------------------
+        // Value helpers. An absent struct field means the property was never set,
+        // so these return null rather than a default value.
+        // ---------------------------------------------------------------------
+        static Wui.Color ToColor(Fb.Color value)
+            => Wui.Color.FromArgb(value.A, value.R, value.G, value.B);
+
+        static Vector2? ToVector2(Fb.Vec2? value)
+            => value.HasValue ? new Vector2(value.Value.X, value.Value.Y) : null;
+
+        static Vector3? ToVector3(Fb.Vec3? value)
+            => value.HasValue ? new Vector3(value.Value.X, value.Value.Y, value.Value.Z) : null;
+
+        static Vector2 ToVector2(Fb.Vec4? value)
+            => value.HasValue ? new Vector2(value.Value.X, value.Value.Y) : Vector2.Zero;
+
+        static Vector3 ToVector3(Fb.Vec4? value)
+            => value.HasValue ? new Vector3(value.Value.X, value.Value.Y, value.Value.Z) : Vector3.Zero;
+
+        static Vector4 ToVector4(Fb.Vec4? value)
+            => value.HasValue
+                ? new Vector4(value.Value.X, value.Value.Y, value.Value.Z, value.Value.W)
+                : Vector4.Zero;
+
+        static Matrix3x2? ToMatrix3x2(Fb.Mat3x2? value)
+            => value.HasValue
+                ? new Matrix3x2(
+                    value.Value.M11, value.Value.M12,
+                    value.Value.M21, value.Value.M22,
+                    value.Value.M31, value.Value.M32)
+                : null;
+
+        static Matrix4x4? ToMatrix4x4(Fb.Mat4x4? value)
+            => value.HasValue
+                ? new Matrix4x4(
+                    value.Value.M11, value.Value.M12, value.Value.M13, value.Value.M14,
+                    value.Value.M21, value.Value.M22, value.Value.M23, value.Value.M24,
+                    value.Value.M31, value.Value.M32, value.Value.M33, value.Value.M34,
+                    value.Value.M41, value.Value.M42, value.Value.M43, value.Value.M44)
+                : null;
+    }
+}
diff --git a/source/LottieRuntime/LottieRuntime.projitems b/source/LottieRuntime/LottieRuntime.projitems
new file mode 100644
index 00000000..bfd579d4
--- /dev/null
+++ b/source/LottieRuntime/LottieRuntime.projitems
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <SharedGUID>7c8b1d02-4e5f-4a76-9c3b-2f0d8e6a41b9</SharedGUID>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration">
+    <Import_RootNamespace>LottieRuntime</Import_RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)CompositionInterpreter.cs" />
+  </ItemGroup>
+</Project>
diff --git a/source/LottieRuntime/LottieRuntime.shproj b/source/LottieRuntime/LottieRuntime.shproj
new file mode 100644
index 00000000..fb5026ae
--- /dev/null
+++ b/source/LottieRuntime/LottieRuntime.shproj
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>7c8b1d02-4e5f-4a76-9c3b-2f0d8e6a41b9</ProjectGuid>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.Default.props" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.props" />
+  <PropertyGroup />
+  <Import Project="LottieRuntime.projitems" Label="Shared" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.CSharp.targets" />
+</Project>
diff --git a/source/LottieRuntime/README.md b/source/LottieRuntime/README.md
new file mode 100644
index 00000000..23d6015f
--- /dev/null
+++ b/source/LottieRuntime/README.md
@@ -0,0 +1,108 @@
+# LottieRuntime (managed)
+
+A managed runtime interpreter for Lottie animations.
+
+`CompositionInterpreter` builds a `Windows.UI.Composition` visual tree from a
+serialized composition. It is the C# counterpart of the native interpreter in
+[`dlls/LottieRuntime`](../../dlls/LottieRuntime/README.md): both read the same
+`.lcomp` buffer, make the same composition calls, and perform the same validation,
+so an application can choose whichever one suits its language and packaging without
+changing what appears on screen.
+
+## How it fits in
+
+Lottie-Windows turns a Lottie file into a `WinCompData` graph, which is a
+description of a composition tree. Four consumers use that graph:
+
+| Consumer | When it runs | Cost |
+| --- | --- | --- |
+| `Instantiator` | Runtime, in the app | Ships the whole JSON reader and translator |
+| `LottieGen` code generators | Build time | No runtime cost, but one class per animation |
+| `LottieRuntime` (C++) | Runtime, in the app | One interpreter shared by every animation |
+| `CompositionInterpreter` (C#) | Runtime, in the app | One interpreter shared by every animation |
+
+`CompositionSerializer` writes the graph into a FlatBuffer at build time and the
+interpreter reads that buffer at runtime. The animation stays data, so it can be
+swapped, downloaded or themed without a rebuild, and the amount of code in the
+application does not grow with the number of animations.
+
+Note the difference from `CompositionDeserializer`, which is also managed and also
+reads the same buffer: the deserializer rebuilds a `WinCompData` graph, which is the
+object model that the translator and the code generators work in, while the
+interpreter creates live composition objects and no intermediate model at all. The
+deserializer is a tool; the interpreter is a player.
+
+## Producing a buffer
+
+```
+LottieGen -InputFile animation.json -Language flatbuffer -OutputFolder .
+```
+
+This writes `Animation.lcomp`. The format is described by
+[`source/LottieFlatbuffer/lottie_comp.fbs`](../LottieFlatbuffer/lottie_comp.fbs).
+
+## Using it
+
+```csharp
+var bytes = File.ReadAllBytes("Animation.lcomp");
+var root = CompositionInterpreter.LoadComposition(compositor, bytes);
+
+ElementCompositionPreview.SetElementChildVisual(element, root);
+
+// Drive the animation by setting Progress between 0 and 1.
+CompositionInterpreter.ProgressPropertySet(root).InsertScalar("Progress", 0.5f);
+```
+
+The `Compositor` must belong to the calling thread, which must own a
+`DispatcherQueue` that outlives the returned visual tree.
+
+## Design
+
+**One function per category, not per type.** A node's concrete type is known only
+inside the function that creates it. The realization caches hold `Visual`,
+`CompositionShape`, `CompositionBrush`, `CompositionGeometry` and so on, and
+everything the interpreter does afterwards is declared on those types, so there is
+no point at which it has to ask what a node actually is. The state that every
+`CompositionObject` has is applied by one function that takes `CompositionObject`.
+
+**Runtime cost second.** Each node and string is realized at most once. Lookups are
+bounds-checked array indexing into the buffer's node vectors, because the caches are
+indexed identically to those vectors. The buffer is read in place.
+
+**Untrusted input.** A buffer may have come from a file or a download. It is checked
+for the `LCMP` identifier, run through the FlatBuffers verifier, and every index read
+out of it is range checked. Canvas geometries are checked for cycles and paths for
+figures that do not begin and end. A malformed buffer is reported as a
+`FlatBufferFormatException` and never reads outside the buffer. A buffer that needs a
+newer schema, or a Universal API contract that this version of Windows does not have,
+is reported as a `NotSupportedException` before any object is created.
+
+## Dependencies
+
+`Windows.UI.Composition`, Win2D for path geometry and the two effects that the
+translator emits, and `Google.FlatBuffers` for the generated schema binding. The
+native interpreter avoids Win2D by implementing the two Direct2D interop interfaces
+itself; that is not available to managed code, so a consumer of this interpreter
+takes the Win2D dependency, exactly as a consumer of `Instantiator` or of
+`LottieGen`'s C# output already does.
+
+## Incorporate it in a build
+
+`LottieRuntime.projitems` is a shared project. Import it into the application
+project alongside `CompDataFlatbuffer.projitems`, which contains the generated schema
+binding and the format constants, and add a package reference to
+`Google.FlatBuffers`.
+
+Define `WINAPPSDK` when building for the Windows App SDK, which switches the
+interpreter from `Windows.UI.Composition` to `Microsoft.UI.Composition`. Define
+`PUBLIC_LottieRuntime` to make the type public.
+
+## Tests
+
+`tests/CompDataFlatbuffer.Tests` dumps the interpreted tree in the same canonical
+text as the `WinCompData` graph that the buffer was written from and asserts that the
+two are equal, for every animation in the sample corpus and for a synthetic graph
+that contains one of every node type. The same tests check that malformed, truncated
+and corrupted buffers are rejected. The composition APIs only exist on Windows, so
+the tests run against stand-ins for them, which is what makes the interpreter
+testable on any platform.
diff --git a/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj b/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj
index 5eaab357..03c5c47e 100644
--- a/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj
+++ b/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj
@@ -21,6 +21,7 @@
   <Import Project="$(_SourceDir)GenericData\GenericData.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)LottieData\LottieData.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)LottieMetadata\LottieMetadata.projitems" Label="Shared" />
+  <Import Project="$(_SourceDir)LottieRuntime\LottieRuntime.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)LottieReader\LottieReader.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)LottieToWinComp\LottieToWinComp.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)UIData\UIData.projitems" Label="Shared" />
diff --git a/tests/CompDataFlatbuffer.Tests/CompositionApiStandIns.cs b/tests/CompDataFlatbuffer.Tests/CompositionApiStandIns.cs
new file mode 100644
index 00000000..59bfc1e1
--- /dev/null
+++ b/tests/CompDataFlatbuffer.Tests/CompositionApiStandIns.cs
@@ -0,0 +1,1112 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// Stand-ins for the Windows.UI.Composition, Windows.UI.Xaml.Media and Win2D APIs
+// that CompositionInterpreter is written against.
+//
+// The interpreter's whole job is to make the right sequence of calls into those
+// APIs, and those APIs are only present on Windows. Rather than testing the
+// interpreter by looking at pixels on a Windows machine, these types stand in for
+// the real ones: they are declared in the real namespaces with the real names and
+// the members that the interpreter uses, and they record what was done to them so
+// that the resulting tree can be dumped and compared against the WinCompData graph
+// that produced the buffer.
+//
+// They are deliberately dumb. They contain no logic beyond recording, so a test
+// failure is always a fault in the interpreter rather than in the stand-ins. The
+// same technique is used by tests/Mocks.cs, which mocks Win2D so that LottieGen's
+// generated code can be compiled off Windows.
+//
+// Two details are modelled rather than merely recorded, because the dump depends
+// on them:
+//
+//  * A property that has never been set is distinguishable from one that has been
+//    set to its default value, which is what makes the dump comparable with the
+//    WinCompData dump. That is why the properties are nullable.
+//  * StartAnimation creates an AnimationController for every animation that is not
+//    an ExpressionAnimation, which is what Windows.UI.Composition does and what
+//    WinCompData models.
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Numerics;
+using Windows.Graphics.Effects;
+using Windows.Storage.Streams;
+using Windows.UI.Composition;
+using Mgc = Microsoft.Graphics.Canvas;
+using Mgcg = Microsoft.Graphics.Canvas.Geometry;
+
+namespace Windows.UI
+{
+    struct Color
+    {
+        public byte A { get; private set; }
+
+        public byte R { get; private set; }
+
+        public byte G { get; private set; }
+
+        public byte B { get; private set; }
+
+        public static Color FromArgb(byte a, byte r, byte g, byte b)
+            => new Color { A = a, R = r, G = g, B = b };
+    }
+}
+
+namespace Windows.Foundation.Metadata
+{
+    static class ApiInformation
+    {
+        // The version of the API contract that the stand-ins pretend to implement.
+        // It is well beyond any version that the translator asks for, so that a
+        // composition from the corpus always loads, and a test that wants the check
+        // to fail asks for a version that no version of Windows will ever have.
+        public const ushort UniversalApiContractVersion = 20;
+
+        public static bool IsApiContractPresent(string contractName, ushort majorVersion)
+            => contractName == "Windows.Foundation.UniversalApiContract" &&
+               majorVersion <= UniversalApiContractVersion;
+    }
+}
+
+namespace Windows.Graphics.Effects
+{
+    interface IGraphicsEffectSource
+    {
+    }
+
+    interface IGraphicsEffect : IGraphicsEffectSource
+    {
+    }
+}
+
+namespace Windows.Storage.Streams
+{
+    interface IBuffer
+    {
+        byte[] Bytes { get; }
+    }
+
+    interface IRandomAccessStream
+    {
+        byte[] Bytes { get; }
+    }
+
+    sealed class ByteArrayBuffer : IBuffer
+    {
+        internal ByteArrayBuffer(byte[] bytes) => Bytes = bytes;
+
+        public byte[] Bytes { get; }
+    }
+
+    sealed class RandomAccessStream : IRandomAccessStream
+    {
+        internal RandomAccessStream(byte[] bytes) => Bytes = bytes;
+
+        public byte[] Bytes { get; }
+    }
+
+    // Stands in for the stream that a byte array is wrapped in on the way to
+    // LoadedImageSurface. The bytes are carried through unchanged so that the dump
+    // can show what the surface was given.
+    sealed class ByteArrayStream : MemoryStream
+    {
+        internal ByteArrayStream(byte[] bytes)
+            : base(bytes, writable: false)
+        {
+            Bytes = bytes;
+        }
+
+        public byte[] Bytes { get; }
+    }
+}
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+    static class WindowsRuntimeBufferExtensions
+    {
+        public static IBuffer AsBuffer(this byte[] source) => new ByteArrayBuffer(source);
+
+        public static Stream AsStream(this IBuffer source) => new ByteArrayStream(source.Bytes);
+    }
+}
+
+namespace System.IO
+{
+    static class WindowsRuntimeStreamExtensions
+    {
+        public static IRandomAccessStream AsRandomAccessStream(this Stream source)
+            => new RandomAccessStream(((ByteArrayStream)source).Bytes);
+    }
+}
+
+namespace Microsoft.Graphics.Canvas
+{
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.Mgc.CanvasComposite.
+    enum CanvasComposite
+    {
+        SourceOver,
+        DestinationOver,
+        SourceIn,
+        DestinationIn,
+        SourceOut,
+        DestinationOut,
+        SourceAtop,
+        DestinationAtop,
+        Xor,
+        Add,
+        Copy,
+        BoundedCopy,
+        MaskInvert,
+    }
+}
+
+namespace Microsoft.Graphics.Canvas.Effects
+{
+    sealed class CompositeEffect : IGraphicsEffect
+    {
+        public Mgc.CanvasComposite Mode { get; set; }
+
+        public IList<IGraphicsEffectSource> Sources { get; } = new List<IGraphicsEffectSource>();
+    }
+
+    sealed class GaussianBlurEffect : IGraphicsEffect
+    {
+        public float BlurAmount { get; set; }
+
+        public IGraphicsEffectSource? Source { get; set; }
+    }
+}
+
+namespace Microsoft.Graphics.Canvas.Geometry
+{
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg.CanvasFigureLoop.
+    enum CanvasFigureLoop
+    {
+        Open,
+        Closed,
+    }
+
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg.CanvasFilledRegionDetermination.
+    enum CanvasFilledRegionDetermination
+    {
+        Alternate,
+        Winding,
+    }
+
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg.CanvasGeometryCombine.
+    enum CanvasGeometryCombine
+    {
+        Union,
+        Exclude,
+        Intersect,
+        Xor,
+    }
+
+    // The shape of a geometry is recorded rather than rasterized. The nested types
+    // mirror the ones in WinCompData.Mgcg.CanvasGeometry so that the two can be
+    // compared.
+    abstract class CanvasGeometry
+    {
+        public static CanvasGeometry CreateEllipse(object? device, float x, float y, float radiusX, float radiusY)
+            => new Ellipse(x, y, radiusX, radiusY);
+
+        public static CanvasGeometry CreateRoundedRectangle(
+            object? device, float x, float y, float w, float h, float radiusX, float radiusY)
+            => new RoundedRectangle(x, y, w, h, radiusX, radiusY);
+
+        public static CanvasGeometry CreateGroup(
+            object? device, CanvasGeometry[] geometries, CanvasFilledRegionDetermination filledRegionDetermination)
+            => new Group(geometries, filledRegionDetermination);
+
+        public static CanvasGeometry CreatePath(CanvasPathBuilder builder)
+            => new Path(builder.Commands, builder.FilledRegionDetermination);
+
+        public CanvasGeometry CombineWith(
+            CanvasGeometry other, Matrix3x2 matrix, CanvasGeometryCombine combineMode)
+            => new Combination(this, other, matrix, combineMode);
+
+        public CanvasGeometry Transform(Matrix3x2 transformMatrix)
+            => new TransformedGeometry(this, transformMatrix);
+
+        public sealed class Combination : CanvasGeometry
+        {
+            internal Combination(CanvasGeometry a, CanvasGeometry b, Matrix3x2 matrix, CanvasGeometryCombine combineMode)
+                => (A, B, Matrix, CombineMode) = (a, b, matrix, combineMode);
+
+            public CanvasGeometry A { get; }
+
+            public CanvasGeometry B { get; }
+
+            public Matrix3x2 Matrix { get; }
+
+            public CanvasGeometryCombine CombineMode { get; }
+        }
+
+        public sealed class TransformedGeometry : CanvasGeometry
+        {
+            internal TransformedGeometry(CanvasGeometry sourceGeometry, Matrix3x2 transformMatrix)
+                => (SourceGeometry, TransformMatrix) = (sourceGeometry, transformMatrix);
+
+            public CanvasGeometry SourceGeometry { get; }
+
+            public Matrix3x2 TransformMatrix { get; }
+        }
+
+        public sealed class Group : CanvasGeometry
+        {
+            internal Group(CanvasGeometry[] geometries, CanvasFilledRegionDetermination filledRegionDetermination)
+                => (Geometries, FilledRegionDetermination) = (geometries, filledRegionDetermination);
+
+            public CanvasGeometry[] Geometries { get; }
+
+            public CanvasFilledRegionDetermination FilledRegionDetermination { get; }
+        }
+
+        public sealed class Path : CanvasGeometry
+        {
+            internal Path(
+                IReadOnlyList<CanvasPathBuilder.Command> commands,
+                CanvasFilledRegionDetermination filledRegionDetermination)
+                => (Commands, FilledRegionDetermination) = (commands, filledRegionDetermination);
+
+            public IReadOnlyList<CanvasPathBuilder.Command> Commands { get; }
+
+            public CanvasFilledRegionDetermination FilledRegionDetermination { get; }
+        }
+
+        public sealed class Ellipse : CanvasGeometry
+        {
+            internal Ellipse(float x, float y, float radiusX, float radiusY)
+                => (X, Y, RadiusX, RadiusY) = (x, y, radiusX, radiusY);
+
+            public float X { get; }
+
+            public float Y { get; }
+
+            public float RadiusX { get; }
+
+            public float RadiusY { get; }
+        }
+
+        public sealed class RoundedRectangle : CanvasGeometry
+        {
+            internal RoundedRectangle(float x, float y, float w, float h, float radiusX, float radiusY)
+                => (X, Y, W, H, RadiusX, RadiusY) = (x, y, w, h, radiusX, radiusY);
+
+            public float X { get; }
+
+            public float Y { get; }
+
+            public float W { get; }
+
+            public float H { get; }
+
+            public float RadiusX { get; }
+
+            public float RadiusY { get; }
+        }
+    }
+
+    sealed class CanvasPathBuilder : IDisposable
+    {
+        readonly List<Command> _commands = new List<Command>();
+
+        public CanvasPathBuilder(object? device)
+        {
+        }
+
+        internal IReadOnlyList<Command> Commands => _commands;
+
+        internal CanvasFilledRegionDetermination FilledRegionDetermination { get; private set; }
+
+        public void SetFilledRegionDetermination(CanvasFilledRegionDetermination value)
+            => FilledRegionDetermination = value;
+
+        public void BeginFigure(Vector2 startPoint) => _commands.Add(new Command.BeginFigure(startPoint));
+
+        public void EndFigure(CanvasFigureLoop figureLoop) => _commands.Add(new Command.EndFigure(figureLoop));
+
+        public void AddLine(Vector2 endPoint) => _commands.Add(new Command.AddLine(endPoint));
+
+        public void AddCubicBezier(Vector2 controlPoint1, Vector2 controlPoint2, Vector2 endPoint)
+            => _commands.Add(new Command.AddCubicBezier(controlPoint1, controlPoint2, endPoint));
+
+        public void Dispose()
+        {
+        }
+
+        internal abstract class Command
+        {
+            internal sealed class BeginFigure : Command
+            {
+                internal BeginFigure(Vector2 startPoint) => StartPoint = startPoint;
+
+                public Vector2 StartPoint { get; }
+            }
+
+            internal sealed class EndFigure : Command
+            {
+                internal EndFigure(CanvasFigureLoop figureLoop) => FigureLoop = figureLoop;
+
+                public CanvasFigureLoop FigureLoop { get; }
+            }
+
+            internal sealed class AddLine : Command
+            {
+                internal AddLine(Vector2 endPoint) => EndPoint = endPoint;
+
+                public Vector2 EndPoint { get; }
+            }
+
+            internal sealed class AddCubicBezier : Command
+            {
+                internal AddCubicBezier(Vector2 controlPoint1, Vector2 controlPoint2, Vector2 endPoint)
+                    => (ControlPoint1, ControlPoint2, EndPoint) = (controlPoint1, controlPoint2, endPoint);
+
+                public Vector2 ControlPoint1 { get; }
+
+                public Vector2 ControlPoint2 { get; }
+
+                public Vector2 EndPoint { get; }
+            }
+        }
+    }
+}
+
+namespace Windows.UI.Xaml.Media
+{
+    // The two loaded image surfaces are separate types here, unlike in the real API
+    // where one type is returned by both factories, so that the dump can tell them
+    // apart in the same way that the WinCompData dump does.
+    abstract class LoadedImageSurface : ICompositionSurface
+    {
+        public static LoadedImageSurface StartLoadFromUri(Uri uri) => new LoadedImageSurfaceFromUri(uri);
+
+        public static LoadedImageSurface StartLoadFromStream(IRandomAccessStream stream)
+            => new LoadedImageSurfaceFromStream(stream.Bytes);
+    }
+
+    sealed class LoadedImageSurfaceFromUri : LoadedImageSurface
+    {
+        internal LoadedImageSurfaceFromUri(Uri uri) => Uri = uri;
+
+        public Uri Uri { get; }
+    }
+
+    sealed class LoadedImageSurfaceFromStream : LoadedImageSurface
+    {
+        internal LoadedImageSurfaceFromStream(byte[] bytes) => Bytes = bytes;
+
+        public byte[] Bytes { get; }
+    }
+}
+
+namespace Windows.UI.Composition
+{
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionBorderMode.
+    enum CompositionBorderMode
+    {
+        Inherit = 0,
+        Soft = 1,
+        Hard = 2,
+    }
+
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionStrokeCap.
+    enum CompositionStrokeCap
+    {
+        Flat,
+        Square,
+        Round,
+        Triangle,
+    }
+
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionStrokeLineJoin.
+    enum CompositionStrokeLineJoin
+    {
+        Miter,
+        Bevel,
+        Round,
+        MiterOrBevel,
+    }
+
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionGradientExtendMode.
+    enum CompositionGradientExtendMode
+    {
+        Clamp = 0,
+        Wrap = 1,
+        Mirror = 2,
+    }
+
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionColorSpace.
+    enum CompositionColorSpace
+    {
+        Auto = 0,
+        Hsl = 1,
+        Rgb = 2,
+        HslLinear = 3,
+        RgbLinear = 4,
+    }
+
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionMappingMode.
+    enum CompositionMappingMode
+    {
+        Absolute = 0,
+        Relative = 1,
+    }
+
+    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionDropShadowSourcePolicy.
+    enum CompositionDropShadowSourcePolicy
+    {
+        Default = 0,
+        InheritFromVisualContent = 1,
+    }
+
+    interface ICompositionSurface
+    {
+    }
+
+    abstract class CompositionObject
+    {
+        readonly List<Animator> _animators = new List<Animator>();
+
+        private protected CompositionObject()
+            => Properties = this as CompositionPropertySet ?? new CompositionPropertySet(this);
+
+        public string? Comment { get; set; }
+
+        public CompositionPropertySet Properties { get; }
+
+        internal IReadOnlyList<Animator> Animators => _animators;
+
+        public void StartAnimation(string propertyName, CompositionAnimation animation)
+            => StartAnimation(propertyName, animation, null);
+
+        public void StartAnimation(
+            string propertyName, CompositionAnimation animation, AnimationController? animationController)
+        {
+            // A controller comes into existence with the animation, unless the
+            // animation is an expression, which is driven by its inputs rather than by
+            // a clock and so has nothing to control.
+            var controller = animationController ??
+                (animation is ExpressionAnimation ? null : new AnimationController(this, propertyName));
+
+            _animators.Add(new Animator(propertyName, animation, controller));
+        }
+
+        public AnimationController? TryGetAnimationController(string propertyName)
+        {
+            foreach (var animator in _animators)
+            {
+                if (animator.AnimatedProperty == propertyName)
+                {
+                    return animator.Controller;
+                }
+            }
+
+            return null;
+        }
+
+        internal sealed class Animator
+        {
+            internal Animator(string animatedProperty, CompositionAnimation animation, AnimationController? controller)
+                => (AnimatedProperty, Animation, Controller) = (animatedProperty, animation, controller);
+
+            public string AnimatedProperty { get; }
+
+            public CompositionAnimation Animation { get; }
+
+            public AnimationController? Controller { get; }
+        }
+    }
+
+    sealed class AnimationController : CompositionObject
+    {
+        internal AnimationController(CompositionObject targetObject, string targetProperty)
+            => (TargetObject, TargetProperty) = (targetObject, targetProperty);
+
+        internal AnimationController()
+        {
+        }
+
+        public bool IsCustom => TargetObject is null;
+
+        public CompositionObject? TargetObject { get; }
+
+        public string? TargetProperty { get; }
+
+        public bool IsPaused { get; private set; }
+
+        public void Pause() => IsPaused = true;
+    }
+
+    enum PropertySetValueType
+    {
+        Color,
+        Scalar,
+        Vector2,
+        Vector3,
+        Vector4,
+    }
+
+    sealed class CompositionPropertySet : CompositionObject
+    {
+        // A SortedDictionary with the default comparer, exactly as WinCompData uses,
+        // so that the dump of a property set is in the same order on both sides.
+        readonly SortedDictionary<string, PropertySetValueType> _names =
+            new SortedDictionary<string, PropertySetValueType>();
+
+        readonly Dictionary<string, object> _values = new Dictionary<string, object>();
+
+        internal CompositionPropertySet(CompositionObject? owner) => Owner = owner;
+
+        public CompositionObject? Owner { get; }
+
+        internal IReadOnlyDictionary<string, PropertySetValueType> Names => _names;
+
+        public void InsertColor(string propertyName, UI.Color value)
+            => Insert(propertyName, PropertySetValueType.Color, value);
+
+        public void InsertScalar(string propertyName, float value)
+            => Insert(propertyName, PropertySetValueType.Scalar, value);
+
+        public void InsertVector2(string propertyName, Vector2 value)
+            => Insert(propertyName, PropertySetValueType.Vector2, value);
+
+        public void InsertVector3(string propertyName, Vector3 value)
+            => Insert(propertyName, PropertySetValueType.Vector3, value);
+
+        public void InsertVector4(string propertyName, Vector4 value)
+            => Insert(propertyName, PropertySetValueType.Vector4, value);
+
+        internal object GetValue(string propertyName) => _values[propertyName];
+
+        void Insert(string propertyName, PropertySetValueType type, object value)
+        {
+            _names[propertyName] = type;
+            _values[propertyName] = value;
+        }
+    }
+
+    sealed class CompositionPath
+    {
+        public CompositionPath(Mgcg.CanvasGeometry source) => Source = source;
+
+        public Mgcg.CanvasGeometry Source { get; }
+    }
+
+    sealed class CompositionEffectSourceParameter : IGraphicsEffectSource
+    {
+        public CompositionEffectSourceParameter(string name) => Name = name;
+
+        public string Name { get; }
+    }
+
+    abstract class Visual : CompositionObject
+    {
+        public CompositionBorderMode? BorderMode { get; set; }
+
+        public Vector3? CenterPoint { get; set; }
+
+        public CompositionClip? Clip { get; set; }
+
+        public bool? IsVisible { get; set; }
+
+        public Vector3? Offset { get; set; }
+
+        public float? Opacity { get; set; }
+
+        public float? RotationAngleInDegrees { get; set; }
+
+        public Vector3? RotationAxis { get; set; }
+
+        public Vector3? Scale { get; set; }
+
+        public Vector2? Size { get; set; }
+
+        public Matrix4x4? TransformMatrix { get; set; }
+    }
+
+    sealed class VisualCollection
+    {
+        readonly List<Visual> _visuals = new List<Visual>();
+
+        internal IReadOnlyList<Visual> Visuals => _visuals;
+
+        public void InsertAtTop(Visual visual) => _visuals.Add(visual);
+    }
+
+    class ContainerVisual : Visual
+    {
+        public VisualCollection Children { get; } = new VisualCollection();
+    }
+
+    sealed class ShapeVisual : ContainerVisual
+    {
+        public IList<CompositionShape> Shapes { get; } = new List<CompositionShape>();
+
+        public CompositionViewBox? ViewBox { get; set; }
+    }
+
+    sealed class SpriteVisual : ContainerVisual
+    {
+        public CompositionBrush? Brush { get; set; }
+
+        public CompositionShadow? Shadow { get; set; }
+    }
+
+    sealed class LayerVisual : ContainerVisual
+    {
+        public CompositionShadow? Shadow { get; set; }
+    }
+
+    abstract class CompositionShape : CompositionObject
+    {
+        public Vector2? CenterPoint { get; set; }
+
+        public Vector2? Offset { get; set; }
+
+        public float? RotationAngleInDegrees { get; set; }
+
+        public Vector2? Scale { get; set; }
+
+        public Matrix3x2? TransformMatrix { get; set; }
+    }
+
+    sealed class CompositionContainerShape : CompositionShape
+    {
+        public IList<CompositionShape> Shapes { get; } = new List<CompositionShape>();
+    }
+
+    sealed class CompositionSpriteShape : CompositionShape
+    {
+        public CompositionBrush? FillBrush { get; set; }
+
+        public CompositionBrush? StrokeBrush { get; set; }
+
+        public CompositionGeometry? Geometry { get; set; }
+
+        public bool? IsStrokeNonScaling { get; set; }
+
+        public float? StrokeDashOffset { get; set; }
+
+        public IList<float> StrokeDashArray { get; } = new List<float>();
+
+        public CompositionStrokeCap? StrokeDashCap { get; set; }
+
+        public CompositionStrokeCap? StrokeStartCap { get; set; }
+
+        public CompositionStrokeCap? StrokeEndCap { get; set; }
+
+        public CompositionStrokeLineJoin? StrokeLineJoin { get; set; }
+
+        public float? StrokeMiterLimit { get; set; }
+
+        public float? StrokeThickness { get; set; }
+    }
+
+    abstract class CompositionGeometry : CompositionObject
+    {
+        public float? TrimStart { get; set; }
+
+        public float? TrimEnd { get; set; }
+
+        public float? TrimOffset { get; set; }
+    }
+
+    sealed class CompositionPathGeometry : CompositionGeometry
+    {
+        public CompositionPath? Path { get; set; }
+    }
+
+    sealed class CompositionRectangleGeometry : CompositionGeometry
+    {
+        public Vector2? Offset { get; set; }
+
+        public Vector2? Size { get; set; }
+    }
+
+    sealed class CompositionRoundedRectangleGeometry : CompositionGeometry
+    {
+        public Vector2? Offset { get; set; }
+
+        public Vector2? Size { get; set; }
+
+        public Vector2? CornerRadius { get; set; }
+    }
+
+    sealed class CompositionEllipseGeometry : CompositionGeometry
+    {
+        public Vector2? Center { get; set; }
+
+        public Vector2? Radius { get; set; }
+    }
+
+    abstract class CompositionBrush : CompositionObject
+    {
+    }
+
+    sealed class CompositionColorBrush : CompositionBrush
+    {
+        public UI.Color? Color { get; set; }
+    }
+
+    abstract class CompositionGradientBrush : CompositionBrush
+    {
+        public Vector2? AnchorPoint { get; set; }
+
+        public Vector2? CenterPoint { get; set; }
+
+        public IList<CompositionColorGradientStop> ColorStops { get; } = new List<CompositionColorGradientStop>();
+
+        public CompositionGradientExtendMode? ExtendMode { get; set; }
+
+        public CompositionColorSpace? InterpolationSpace { get; set; }
+
+        public CompositionMappingMode? MappingMode { get; set; }
+
+        public Vector2? Offset { get; set; }
+
+        public float? RotationAngleInDegrees { get; set; }
+
+        public Vector2? Scale { get; set; }
+
+        public Matrix3x2? TransformMatrix { get; set; }
+    }
+
+    sealed class CompositionLinearGradientBrush : CompositionGradientBrush
+    {
+        public Vector2? StartPoint { get; set; }
+
+        public Vector2? EndPoint { get; set; }
+    }
+
+    sealed class CompositionRadialGradientBrush : CompositionGradientBrush
+    {
+        public Vector2? EllipseCenter { get; set; }
+
+        public Vector2? EllipseRadius { get; set; }
+
+        public Vector2? GradientOriginOffset { get; set; }
+    }
+
+    sealed class CompositionMaskBrush : CompositionBrush
+    {
+        public CompositionBrush? Source { get; set; }
+
+        public CompositionBrush? Mask { get; set; }
+    }
+
+    sealed class CompositionSurfaceBrush : CompositionBrush
+    {
+        internal CompositionSurfaceBrush(ICompositionSurface? surface) => Surface = surface;
+
+        public ICompositionSurface? Surface { get; set; }
+    }
+
+    sealed class CompositionEffectBrush : CompositionBrush
+    {
+        readonly Dictionary<string, CompositionBrush> _sources = new Dictionary<string, CompositionBrush>();
+        readonly CompositionEffectFactory _factory;
+
+        internal CompositionEffectBrush(CompositionEffectFactory factory) => _factory = factory;
+
+        public void SetSourceParameter(string name, CompositionBrush source) => _sources[name] = source;
+
+        internal CompositionEffectFactory GetEffectFactory() => _factory;
+
+        internal CompositionBrush? GetSourceParameter(string name)
+            => _sources.TryGetValue(name, out var result) ? result : null;
+    }
+
+    sealed class CompositionEffectFactory : CompositionObject
+    {
+        internal CompositionEffectFactory(IGraphicsEffect effect) => Effect = effect;
+
+        internal IGraphicsEffect Effect { get; }
+
+        public CompositionEffectBrush CreateBrush() => new CompositionEffectBrush(this);
+    }
+
+    sealed class CompositionColorGradientStop : CompositionObject
+    {
+        public UI.Color? Color { get; set; }
+
+        public float? Offset { get; set; }
+    }
+
+    sealed class CompositionViewBox : CompositionObject
+    {
+        public Vector2? Size { get; set; }
+    }
+
+    abstract class CompositionClip : CompositionObject
+    {
+        public Vector2? CenterPoint { get; set; }
+
+        public Vector2? Scale { get; set; }
+    }
+
+    sealed class InsetClip : CompositionClip
+    {
+        public float? LeftInset { get; set; }
+
+        public float? RightInset { get; set; }
+
+        public float? TopInset { get; set; }
+
+        public float? BottomInset { get; set; }
+    }
+
+    sealed class CompositionGeometricClip : CompositionClip
+    {
+        public CompositionGeometry? Geometry { get; set; }
+    }
+
+    abstract class CompositionShadow : CompositionObject
+    {
+    }
+
+    sealed class DropShadow : CompositionShadow
+    {
+        public float? BlurRadius { get; set; }
+
+        public UI.Color? Color { get; set; }
+
+        public CompositionBrush? Mask { get; set; }
+
+        public Vector3? Offset { get; set; }
+
+        public float? Opacity { get; set; }
+
+        public CompositionDropShadowSourcePolicy? SourcePolicy { get; set; }
+    }
+
+    sealed class CompositionVisualSurface : CompositionObject, ICompositionSurface
+    {
+        public Visual? SourceVisual { get; set; }
+
+        public Vector2? SourceSize { get; set; }
+
+        public Vector2? SourceOffset { get; set; }
+    }
+
+    abstract class CompositionEasingFunction : CompositionObject
+    {
+    }
+
+    sealed class LinearEasingFunction : CompositionEasingFunction
+    {
+    }
+
+    sealed class CubicBezierEasingFunction : CompositionEasingFunction
+    {
+        internal CubicBezierEasingFunction(Vector2 controlPoint1, Vector2 controlPoint2)
+            => (ControlPoint1, ControlPoint2) = (controlPoint1, controlPoint2);
+
+        public Vector2 ControlPoint1 { get; }
+
+        public Vector2 ControlPoint2 { get; }
+    }
+
+    sealed class StepEasingFunction : CompositionEasingFunction
+    {
+        public int? StepCount { get; set; }
+
+        public int? InitialStep { get; set; }
+
+        public int? FinalStep { get; set; }
+
+        public bool? IsInitialStepSingleFrame { get; set; }
+
+        public bool? IsFinalStepSingleFrame { get; set; }
+    }
+
+    abstract class CompositionAnimation : CompositionObject
+    {
+        readonly SortedDictionary<string, CompositionObject> _referenceParameters =
+            new SortedDictionary<string, CompositionObject>(StringComparer.Ordinal);
+
+        public string? Target { get; set; }
+
+        internal IReadOnlyDictionary<string, CompositionObject> ReferenceParameters => _referenceParameters;
+
+        public void SetReferenceParameter(string key, CompositionObject compositionObject)
+            => _referenceParameters[key] = compositionObject;
+    }
+
+    sealed class ExpressionAnimation : CompositionAnimation
+    {
+        internal ExpressionAnimation(string expression) => Expression = expression;
+
+        public string Expression { get; }
+    }
+
+    abstract class KeyFrameAnimation : CompositionAnimation
+    {
+        // Key frames are held in progress order and one deep per progress, which is
+        // what Windows.UI.Composition does and what makes the dump canonical.
+        readonly SortedList<float, KeyFrame> _keyFrames = new SortedList<float, KeyFrame>();
+
+        public TimeSpan Duration { get; set; }
+
+        internal IEnumerable<KeyFrame> KeyFrames => _keyFrames.Values;
+
+        public void InsertExpressionKeyFrame(float progress, string expression, CompositionEasingFunction? easing)
+            => Insert(new ExpressionKeyFrame(progress, easing, expression));
+
+        private protected void Insert(KeyFrame keyFrame) => _keyFrames[keyFrame.Progress] = keyFrame;
+
+        internal abstract class KeyFrame
+        {
+            private protected KeyFrame(float progress, CompositionEasingFunction? easing)
+                => (Progress, Easing) = (progress, easing);
+
+            public float Progress { get; }
+
+            public CompositionEasingFunction? Easing { get; }
+        }
+
+        internal sealed class ExpressionKeyFrame : KeyFrame
+        {
+            internal ExpressionKeyFrame(float progress, CompositionEasingFunction? easing, string expression)
+                : base(progress, easing)
+                => Expression = expression;
+
+            public string Expression { get; }
+        }
+
+        internal sealed class ValueKeyFrame : KeyFrame
+        {
+            internal ValueKeyFrame(float progress, CompositionEasingFunction? easing, object value)
+                : base(progress, easing)
+                => Value = value;
+
+            public object Value { get; }
+        }
+    }
+
+    sealed class ScalarKeyFrameAnimation : KeyFrameAnimation
+    {
+        public void InsertKeyFrame(float progress, float value, CompositionEasingFunction? easing)
+            => Insert(new ValueKeyFrame(progress, easing, value));
+    }
+
+    sealed class Vector2KeyFrameAnimation : KeyFrameAnimation
+    {
+        public void InsertKeyFrame(float progress, Vector2 value, CompositionEasingFunction? easing)
+            => Insert(new ValueKeyFrame(progress, easing, value));
+    }
+
+    sealed class Vector3KeyFrameAnimation : KeyFrameAnimation
+    {
+        public void InsertKeyFrame(float progress, Vector3 value, CompositionEasingFunction? easing)
+            => Insert(new ValueKeyFrame(progress, easing, value));
+    }
+
+    sealed class Vector4KeyFrameAnimation : KeyFrameAnimation
+    {
+        public void InsertKeyFrame(float progress, Vector4 value, CompositionEasingFunction? easing)
+            => Insert(new ValueKeyFrame(progress, easing, value));
+    }
+
+    sealed class ColorKeyFrameAnimation : KeyFrameAnimation
+    {
+        public CompositionColorSpace? InterpolationColorSpace { get; set; }
+
+        public void InsertKeyFrame(float progress, UI.Color value, CompositionEasingFunction? easing)
+            => Insert(new ValueKeyFrame(progress, easing, value));
+    }
+
+    sealed class BooleanKeyFrameAnimation : KeyFrameAnimation
+    {
+        public void InsertKeyFrame(float progress, bool value)
+            => Insert(new ValueKeyFrame(progress, null, value));
+    }
+
+    sealed class PathKeyFrameAnimation : KeyFrameAnimation
+    {
+        public void InsertKeyFrame(float progress, CompositionPath value, CompositionEasingFunction? easing)
+            => Insert(new ValueKeyFrame(progress, easing, value));
+    }
+
+    sealed class Compositor
+    {
+        public ContainerVisual CreateContainerVisual() => new ContainerVisual();
+
+        public ShapeVisual CreateShapeVisual() => new ShapeVisual();
+
+        public SpriteVisual CreateSpriteVisual() => new SpriteVisual();
+
+        public LayerVisual CreateLayerVisual() => new LayerVisual();
+
+        public CompositionContainerShape CreateContainerShape() => new CompositionContainerShape();
+
+        public CompositionSpriteShape CreateSpriteShape() => new CompositionSpriteShape();
+
+        public CompositionPathGeometry CreatePathGeometry() => new CompositionPathGeometry();
+
+        public CompositionRectangleGeometry CreateRectangleGeometry() => new CompositionRectangleGeometry();
+
+        public CompositionRoundedRectangleGeometry CreateRoundedRectangleGeometry()
+            => new CompositionRoundedRectangleGeometry();
+
+        public CompositionEllipseGeometry CreateEllipseGeometry() => new CompositionEllipseGeometry();
+
+        public CompositionColorBrush CreateColorBrush() => new CompositionColorBrush();
+
+        public CompositionLinearGradientBrush CreateLinearGradientBrush() => new CompositionLinearGradientBrush();
+
+        public CompositionRadialGradientBrush CreateRadialGradientBrush() => new CompositionRadialGradientBrush();
+
+        public CompositionMaskBrush CreateMaskBrush() => new CompositionMaskBrush();
+
+        public CompositionSurfaceBrush CreateSurfaceBrush(ICompositionSurface? surface)
+            => new CompositionSurfaceBrush(surface);
+
+        public CompositionEffectFactory CreateEffectFactory(IGraphicsEffect effect)
+            => new CompositionEffectFactory(effect);
+
+        public CompositionColorGradientStop CreateColorGradientStop() => new CompositionColorGradientStop();
+
+        public CompositionViewBox CreateViewBox() => new CompositionViewBox();
+
+        public InsetClip CreateInsetClip() => new InsetClip();
+
+        public CompositionGeometricClip CreateGeometricClip() => new CompositionGeometricClip();
+
+        public DropShadow CreateDropShadow() => new DropShadow();
+
+        public CompositionVisualSurface CreateVisualSurface() => new CompositionVisualSurface();
+
+        public CompositionPropertySet CreatePropertySet() => new CompositionPropertySet(null);
+
+        public AnimationController CreateAnimationController() => new AnimationController();
+
+        public LinearEasingFunction CreateLinearEasingFunction() => new LinearEasingFunction();
+
+        public CubicBezierEasingFunction CreateCubicBezierEasingFunction(Vector2 controlPoint1, Vector2 controlPoint2)
+            => new CubicBezierEasingFunction(controlPoint1, controlPoint2);
+
+        public StepEasingFunction CreateStepEasingFunction() => new StepEasingFunction();
+
+        public ExpressionAnimation CreateExpressionAnimation(string expression) => new ExpressionAnimation(expression);
+
+        public ScalarKeyFrameAnimation CreateScalarKeyFrameAnimation() => new ScalarKeyFrameAnimation();
+
+        public Vector2KeyFrameAnimation CreateVector2KeyFrameAnimation() => new Vector2KeyFrameAnimation();
+
+        public Vector3KeyFrameAnimation CreateVector3KeyFrameAnimation() => new Vector3KeyFrameAnimation();
+
+        public Vector4KeyFrameAnimation CreateVector4KeyFrameAnimation() => new Vector4KeyFrameAnimation();
+
+        public ColorKeyFrameAnimation CreateColorKeyFrameAnimation() => new ColorKeyFrameAnimation();
+
+        public BooleanKeyFrameAnimation CreateBooleanKeyFrameAnimation() => new BooleanKeyFrameAnimation();
+
+        public PathKeyFrameAnimation CreatePathKeyFrameAnimation() => new PathKeyFrameAnimation();
+    }
+}
diff --git a/tests/CompDataFlatbuffer.Tests/CoverageTests.cs b/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
index b06281cf..547b6d54 100644
--- a/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
+++ b/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
@@ -61,6 +61,23 @@ public void EveryNodeTypeSurvivesARoundTrip()
             Assert.Equal(expected, actual);
         }
 
+        [Fact]
+        public void EveryNodeTypeIsInterpreted()
+        {
+            var root = BuildGraph();
+
+            // The interpreter has a branch per node type just as the deserializer does,
+            // so it is held to the same standard: every node type that a graph can
+            // contain must come out of the buffer unchanged.
+            var expected = CompositionTreeDumper.Dump(root);
+            var actual = InterpretedTreeDumper.Dump(
+                LottieRuntime.CompositionInterpreter.LoadComposition(
+                    new Windows.UI.Composition.Compositor(),
+                    CompositionSerializer.Serialize(root, 14, null, null, 100, 100)));
+
+            Assert.Equal(expected, actual);
+        }
+
         // Builds a graph containing one of everything. It is not a sensible animation;
         // its only job is to reach every branch of the serializer and the deserializer.
         static Visual BuildGraph()
diff --git a/tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs b/tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs
new file mode 100644
index 00000000..c323243d
--- /dev/null
+++ b/tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs
@@ -0,0 +1,805 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using Microsoft.Graphics.Canvas.Geometry;
+using Windows.Graphics.Effects;
+using Windows.UI.Composition;
+using Windows.UI.Xaml.Media;
+using Mgce = Microsoft.Graphics.Canvas.Effects;
+using Wui = Windows.UI;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Tests
+{
+    /// <summary>
+    /// Renders a tree of composition objects as canonical text.
+    /// </summary>
+    /// <remarks>
+    /// This is <see cref="CompositionTreeDumper"/> for the tree that
+    /// <c>CompositionInterpreter</c> builds. It writes the same text for the same
+    /// animation, which is what lets the interpreter be compared against the
+    /// WinCompData graph that the buffer was written from: the graph and the
+    /// interpreted tree are different object models, but if the two dumps are equal
+    /// then the interpreter created the same objects, gave them the same values, and
+    /// shared them in the same way.
+    /// <para/>
+    /// The two dumpers are deliberately not factored into one. Each is a plain
+    /// description of one object model, and keeping them separate means neither can
+    /// paper over a difference by describing both models in the same terms.
+    /// </remarks>
+    static class InterpretedTreeDumper
+    {
+        /// <summary>
+        /// Renders an interpreted tree as canonical text.
+        /// </summary>
+        /// <param name="root">The root of the tree.</param>
+        /// <returns>The canonical text of the tree.</returns>
+        public static string Dump(Visual root)
+        {
+            var writer = new Writer();
+            writer.WriteVisual(root);
+            return writer.ToString();
+        }
+
+        sealed class Writer
+        {
+            readonly StringBuilder _builder = new StringBuilder();
+
+            readonly Dictionary<object, int> _ids =
+                new Dictionary<object, int>(ReferenceEqualityComparer.Instance);
+
+            int _indent;
+
+            public override string ToString() => _builder.ToString();
+
+            public void WriteVisual(Visual? value)
+            {
+                if (WriteNodeHeader(value, "Visual"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                WriteOptional("BorderMode", value!.BorderMode);
+                WriteOptional("CenterPoint", value.CenterPoint);
+                WriteChild("Clip", value.Clip, WriteClip);
+                WriteOptional("IsVisible", value.IsVisible);
+                WriteOptional("Offset", value.Offset);
+                WriteOptional("Opacity", value.Opacity);
+                WriteOptional("RotationAngleInDegrees", value.RotationAngleInDegrees);
+                WriteOptional("RotationAxis", value.RotationAxis);
+                WriteOptional("Scale", value.Scale);
+                WriteOptional("Size", value.Size);
+                WriteOptional("TransformMatrix", value.TransformMatrix);
+
+                if (value is ContainerVisual container)
+                {
+                    WriteList("Children", container.Children.Visuals, WriteVisual);
+                }
+
+                switch (value)
+                {
+                    case ShapeVisual shapeVisual:
+                        WriteList("Shapes", shapeVisual.Shapes, WriteShape);
+                        WriteChild("ViewBox", shapeVisual.ViewBox, WriteViewBox);
+                        break;
+                    case SpriteVisual spriteVisual:
+                        WriteChild("Brush", spriteVisual.Brush, WriteBrush);
+                        WriteChild("Shadow", spriteVisual.Shadow, WriteShadow);
+                        break;
+                    case LayerVisual layerVisual:
+                        WriteChild("Shadow", layerVisual.Shadow, WriteShadow);
+                        break;
+                    case ContainerVisual _:
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected visual {value.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteShape(CompositionShape? value)
+            {
+                if (WriteNodeHeader(value, "Shape"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                WriteOptional("CenterPoint", value!.CenterPoint);
+                WriteOptional("Offset", value.Offset);
+                WriteOptional("RotationAngleInDegrees", value.RotationAngleInDegrees);
+                WriteOptional("Scale", value.Scale);
+                WriteOptional("TransformMatrix", value.TransformMatrix);
+
+                switch (value)
+                {
+                    case CompositionContainerShape containerShape:
+                        WriteList("Shapes", containerShape.Shapes, WriteShape);
+                        break;
+                    case CompositionSpriteShape spriteShape:
+                        WriteChild("FillBrush", spriteShape.FillBrush, WriteBrush);
+                        WriteChild("StrokeBrush", spriteShape.StrokeBrush, WriteBrush);
+                        WriteChild("Geometry", spriteShape.Geometry, WriteGeometry);
+                        WriteOptional("IsStrokeNonScaling", spriteShape.IsStrokeNonScaling);
+                        WriteOptional("StrokeDashOffset", spriteShape.StrokeDashOffset);
+                        WriteFloats("StrokeDashArray", spriteShape.StrokeDashArray);
+                        WriteOptional("StrokeDashCap", spriteShape.StrokeDashCap);
+                        WriteOptional("StrokeStartCap", spriteShape.StrokeStartCap);
+                        WriteOptional("StrokeEndCap", spriteShape.StrokeEndCap);
+                        WriteOptional("StrokeLineJoin", spriteShape.StrokeLineJoin);
+                        WriteOptional("StrokeMiterLimit", spriteShape.StrokeMiterLimit);
+                        WriteOptional("StrokeThickness", spriteShape.StrokeThickness);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected shape {value.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteGeometry(CompositionGeometry? value)
+            {
+                if (WriteNodeHeader(value, "Geometry"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                WriteOptional("TrimStart", value!.TrimStart);
+                WriteOptional("TrimEnd", value.TrimEnd);
+                WriteOptional("TrimOffset", value.TrimOffset);
+
+                switch (value)
+                {
+                    case CompositionPathGeometry pathGeometry:
+                        WriteChild("Path", pathGeometry.Path?.Source, WriteCanvasGeometry);
+                        break;
+                    case CompositionRoundedRectangleGeometry roundedRectangle:
+                        WriteOptional("Offset", roundedRectangle.Offset);
+                        WriteOptional("Size", roundedRectangle.Size);
+                        Write("CornerRadius", roundedRectangle.CornerRadius ?? default);
+                        break;
+                    case CompositionRectangleGeometry rectangle:
+                        WriteOptional("Offset", rectangle.Offset);
+                        WriteOptional("Size", rectangle.Size);
+                        break;
+                    case CompositionEllipseGeometry ellipse:
+                        Write("Center", ellipse.Center ?? default);
+                        Write("Radius", ellipse.Radius ?? default);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected geometry {value.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteBrush(CompositionBrush? value)
+            {
+                if (WriteNodeHeader(value, "Brush"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                switch (value)
+                {
+                    case CompositionColorBrush colorBrush:
+                        WriteOptional("Color", colorBrush.Color);
+                        break;
+                    case CompositionMaskBrush maskBrush:
+                        WriteChild("Source", maskBrush.Source, WriteBrush);
+                        WriteChild("Mask", maskBrush.Mask, WriteBrush);
+                        break;
+                    case CompositionSurfaceBrush surfaceBrush:
+                        WriteChild("Surface", surfaceBrush.Surface, WriteSurface);
+                        break;
+                    case CompositionEffectBrush effectBrush:
+                        var effect = effectBrush.GetEffectFactory().Effect;
+                        WriteChild("Effect", effect, WriteEffect);
+
+                        foreach (var source in SourcesOf(effect))
+                        {
+                            WriteChild(
+                                $"Source({source.Name})",
+                                effectBrush.GetSourceParameter(source.Name),
+                                WriteBrush);
+                        }
+
+                        break;
+                    case CompositionLinearGradientBrush _:
+                    case CompositionRadialGradientBrush _:
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected brush {value!.GetType().Name}.");
+                }
+
+                if (value is CompositionGradientBrush gradientBrush)
+                {
+                    WriteOptional("AnchorPoint", gradientBrush.AnchorPoint);
+                    WriteOptional("CenterPoint", gradientBrush.CenterPoint);
+                    WriteList("ColorStops", gradientBrush.ColorStops, WriteGradientStop);
+                    WriteOptional("ExtendMode", gradientBrush.ExtendMode);
+                    WriteOptional("InterpolationSpace", gradientBrush.InterpolationSpace);
+                    WriteOptional("MappingMode", gradientBrush.MappingMode);
+                    WriteOptional("Offset", gradientBrush.Offset);
+                    WriteOptional("RotationAngleInDegrees", gradientBrush.RotationAngleInDegrees);
+                    WriteOptional("Scale", gradientBrush.Scale);
+                    WriteOptional("TransformMatrix", gradientBrush.TransformMatrix);
+
+                    switch (gradientBrush)
+                    {
+                        case CompositionLinearGradientBrush linear:
+                            WriteOptional("StartPoint", linear.StartPoint);
+                            WriteOptional("EndPoint", linear.EndPoint);
+                            break;
+                        case CompositionRadialGradientBrush radial:
+                            WriteOptional("EllipseCenter", radial.EllipseCenter);
+                            WriteOptional("EllipseRadius", radial.EllipseRadius);
+                            WriteOptional("GradientOriginOffset", radial.GradientOriginOffset);
+                            break;
+                    }
+                }
+
+                _indent--;
+            }
+
+            public void WriteGradientStop(CompositionColorGradientStop? value)
+            {
+                if (WriteNodeHeader(value, "GradientStop"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+                Write("Color", value!.Color ?? default);
+                Write("Offset", value.Offset ?? default);
+                _indent--;
+            }
+
+            public void WriteViewBox(CompositionViewBox? value)
+            {
+                if (WriteNodeHeader(value, "ViewBox"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+                Write("Size", value!.Size ?? default);
+                _indent--;
+            }
+
+            public void WriteClip(CompositionClip? value)
+            {
+                if (WriteNodeHeader(value, "Clip"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+                WriteOptional("CenterPoint", value!.CenterPoint);
+                WriteOptional("Scale", value.Scale);
+
+                switch (value)
+                {
+                    case InsetClip inset:
+                        WriteOptional("LeftInset", inset.LeftInset);
+                        WriteOptional("RightInset", inset.RightInset);
+                        WriteOptional("TopInset", inset.TopInset);
+                        WriteOptional("BottomInset", inset.BottomInset);
+                        break;
+                    case CompositionGeometricClip geometric:
+                        WriteChild("Geometry", geometric.Geometry, WriteGeometry);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected clip {value.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteShadow(CompositionShadow? value)
+            {
+                if (WriteNodeHeader(value, "Shadow"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                switch (value)
+                {
+                    case DropShadow dropShadow:
+                        WriteOptional("BlurRadius", dropShadow.BlurRadius);
+                        WriteOptional("Color", dropShadow.Color);
+                        WriteChild("Mask", dropShadow.Mask, WriteBrush);
+                        WriteOptional("Offset", dropShadow.Offset);
+                        WriteOptional("Opacity", dropShadow.Opacity);
+                        WriteOptional("SourcePolicy", dropShadow.SourcePolicy);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected shadow {value!.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteSurface(ICompositionSurface? value)
+            {
+                if (WriteNodeHeader(value, "Surface"))
+                {
+                    return;
+                }
+
+                switch (value)
+                {
+                    case CompositionVisualSurface visualSurface:
+                        WriteCompositionObject(visualSurface);
+                        WriteChild("SourceVisual", visualSurface.SourceVisual, WriteVisual);
+                        WriteOptional("SourceSize", visualSurface.SourceSize);
+                        WriteOptional("SourceOffset", visualSurface.SourceOffset);
+                        break;
+                    case LoadedImageSurfaceFromUri fromUri:
+                        WriteLine($"Kind: FromUri");
+                        WriteLine($"Uri: {fromUri.Uri}");
+                        break;
+                    case LoadedImageSurfaceFromStream fromStream:
+                        WriteLine($"Kind: FromStream");
+                        WriteLine($"Bytes: {Convert.ToBase64String(fromStream.Bytes)}");
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected surface {value!.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteEffect(IGraphicsEffect? value)
+            {
+                if (WriteNodeHeader(value, "Effect"))
+                {
+                    return;
+                }
+
+                WriteLine($"Sources: {string.Join(", ", SourcesOf(value!).Select(s => s.Name))}");
+
+                switch (value)
+                {
+                    case Mgce.CompositeEffect composite:
+                        Write("Mode", composite.Mode);
+                        break;
+                    case Mgce.GaussianBlurEffect blur:
+                        Write("BlurAmount", blur.BlurAmount);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected effect {value!.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteEasing(CompositionEasingFunction? value)
+            {
+                if (WriteNodeHeader(value, "Easing"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+
+                switch (value)
+                {
+                    case LinearEasingFunction _:
+                        break;
+                    case CubicBezierEasingFunction cubicBezier:
+                        Write("ControlPoint1", cubicBezier.ControlPoint1);
+                        Write("ControlPoint2", cubicBezier.ControlPoint2);
+                        break;
+                    case StepEasingFunction step:
+                        WriteOptional("StepCount", step.StepCount);
+                        WriteOptional("InitialStep", step.InitialStep);
+                        WriteOptional("FinalStep", step.FinalStep);
+                        WriteOptional("IsInitialStepSingleFrame", step.IsInitialStepSingleFrame);
+                        WriteOptional("IsFinalStepSingleFrame", step.IsFinalStepSingleFrame);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected easing {value!.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteAnimation(CompositionAnimation? value)
+            {
+                if (WriteNodeHeader(value, "Animation"))
+                {
+                    return;
+                }
+
+                WriteCompositionObject(value!);
+                WriteLine($"Target: {Text(value!.Target)}");
+
+                foreach (var parameter in value.ReferenceParameters.OrderBy(p => p.Key, StringComparer.Ordinal))
+                {
+                    WriteChild($"Reference({parameter.Key})", parameter.Value, WriteCompositionObjectReference);
+                }
+
+                switch (value)
+                {
+                    case ExpressionAnimation expression:
+                        WriteLine($"Expression: {expression.Expression}");
+                        break;
+                    case KeyFrameAnimation keyFrameAnimation:
+                        WriteLine($"Duration: {keyFrameAnimation.Duration.Ticks}");
+
+                        if (value is ColorKeyFrameAnimation color)
+                        {
+                            Write("InterpolationColorSpace", color.InterpolationColorSpace ?? CompositionColorSpace.Auto);
+                        }
+
+                        foreach (var keyFrame in keyFrameAnimation.KeyFrames)
+                        {
+                            WriteKeyFrame(keyFrame);
+                        }
+
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected animation {value.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            void WriteKeyFrame(KeyFrameAnimation.KeyFrame value)
+            {
+                WriteLine($"KeyFrame @{Text(value.Progress)}");
+                _indent++;
+                WriteChild("Easing", value.Easing, WriteEasing);
+
+                switch (value)
+                {
+                    case KeyFrameAnimation.ExpressionKeyFrame expression:
+                        WriteLine($"Expression: {expression.Expression}");
+                        break;
+                    case KeyFrameAnimation.ValueKeyFrame valueKeyFrame:
+                        if (valueKeyFrame.Value is CompositionPath path)
+                        {
+                            WriteChild("Value", path.Source, WriteCanvasGeometry);
+                        }
+                        else
+                        {
+                            WriteLine($"Value: {Text(valueKeyFrame.Value)}");
+                        }
+
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected key frame {value.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            public void WriteCanvasGeometry(CanvasGeometry? value)
+            {
+                if (WriteNodeHeader(value, "CanvasGeometry"))
+                {
+                    return;
+                }
+
+                switch (value)
+                {
+                    case CanvasGeometry.Combination combination:
+                        WriteChild("A", combination.A, WriteCanvasGeometry);
+                        WriteChild("B", combination.B, WriteCanvasGeometry);
+                        Write("CombineMode", combination.CombineMode);
+                        Write("Matrix", combination.Matrix);
+                        break;
+                    case CanvasGeometry.TransformedGeometry transformed:
+                        WriteChild("Source", transformed.SourceGeometry, WriteCanvasGeometry);
+                        Write("TransformMatrix", transformed.TransformMatrix);
+                        break;
+                    case CanvasGeometry.Group group:
+                        Write("FilledRegionDetermination", group.FilledRegionDetermination);
+                        WriteList("Geometries", group.Geometries, WriteCanvasGeometry);
+                        break;
+                    case CanvasGeometry.Path path:
+                        Write("FilledRegionDetermination", path.FilledRegionDetermination);
+
+                        foreach (var command in path.Commands)
+                        {
+                            WriteLine(Text(command));
+                        }
+
+                        break;
+                    case CanvasGeometry.Ellipse ellipse:
+                        WriteLine(
+                            $"Ellipse: {Text(ellipse.X)} {Text(ellipse.Y)} " +
+                            $"{Text(ellipse.RadiusX)} {Text(ellipse.RadiusY)}");
+                        break;
+                    case CanvasGeometry.RoundedRectangle rectangle:
+                        WriteLine(
+                            $"RoundedRectangle: {Text(rectangle.X)} {Text(rectangle.Y)} " +
+                            $"{Text(rectangle.W)} {Text(rectangle.H)} " +
+                            $"{Text(rectangle.RadiusX)} {Text(rectangle.RadiusY)}");
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected canvas geometry {value!.GetType().Name}.");
+                }
+
+                _indent--;
+            }
+
+            void WriteCompositionObjectReference(CompositionObject? value)
+            {
+                switch (value)
+                {
+                    case null:
+                        WriteLine("null");
+                        break;
+                    case Visual visual:
+                        WriteVisual(visual);
+                        break;
+                    case CompositionShape shape:
+                        WriteShape(shape);
+                        break;
+                    case CompositionGeometry geometry:
+                        WriteGeometry(geometry);
+                        break;
+                    case CompositionBrush brush:
+                        WriteBrush(brush);
+                        break;
+                    case CompositionAnimation animation:
+                        WriteAnimation(animation);
+                        break;
+                    case CompositionEasingFunction easing:
+                        WriteEasing(easing);
+                        break;
+                    case CompositionPropertySet propertySet:
+                        WritePropertySet(propertySet);
+                        break;
+                    case CompositionVisualSurface surface:
+                        WriteSurface(surface);
+                        break;
+                    case CompositionClip clip:
+                        WriteClip(clip);
+                        break;
+                    case AnimationController controller:
+                        WriteController(controller);
+                        break;
+                    case CompositionShadow shadow:
+                        WriteShadow(shadow);
+                        break;
+                    case CompositionColorGradientStop stop:
+                        WriteGradientStop(stop);
+                        break;
+                    case CompositionViewBox viewBox:
+                        WriteViewBox(viewBox);
+                        break;
+                    default:
+                        throw new InvalidOperationException($"Unexpected reference to {value.GetType().Name}.");
+                }
+            }
+
+            void WritePropertySet(CompositionPropertySet? value)
+            {
+                if (WriteNodeHeader(value, "PropertySet"))
+                {
+                    return;
+                }
+
+                WritePropertySetContents(value!);
+                _indent--;
+            }
+
+            void WriteController(AnimationController? value)
+            {
+                if (WriteNodeHeader(value, "Controller"))
+                {
+                    return;
+                }
+
+                WriteLine($"IsCustom: {value!.IsCustom}");
+                WriteLine($"IsPaused: {value.IsPaused}");
+                WriteLine($"TargetProperty: {Text(value.TargetProperty)}");
+                WriteCompositionObject(value);
+                _indent--;
+            }
+
+            void WriteCompositionObject(CompositionObject value)
+            {
+                if (value.Comment is not null)
+                {
+                    WriteLine($"Comment: {value.Comment}");
+                }
+
+                var properties = value.Properties;
+                if (value is not CompositionPropertySet &&
+                    (properties.Names.Count > 0 || properties.Animators.Count > 0))
+                {
+                    WriteLine("Properties");
+                    _indent++;
+                    WritePropertySetContents(properties);
+                    _indent--;
+                }
+
+                foreach (var animator in value.Animators)
+                {
+                    WriteLine($"Animator: {animator.AnimatedProperty}");
+                    _indent++;
+                    WriteChild("Animation", animator.Animation, WriteAnimation);
+
+                    if (animator.Controller is not null)
+                    {
+                        WriteChild("Controller", animator.Controller, WriteController);
+                    }
+
+                    _indent--;
+                }
+            }
+
+            void WritePropertySetContents(CompositionPropertySet value)
+            {
+                foreach (var (name, _) in value.Names.Select(n => (n.Key, n.Value)))
+                {
+                    WriteLine($"{name}: {Text(value.GetValue(name))}");
+                }
+
+                foreach (var animator in value.Animators)
+                {
+                    WriteLine($"Animator: {animator.AnimatedProperty}");
+                    _indent++;
+                    WriteChild("Animation", animator.Animation, WriteAnimation);
+                    _indent--;
+                }
+            }
+
+            // The sources of an effect, in the order that they were given to it.
+            static IEnumerable<CompositionEffectSourceParameter> SourcesOf(IGraphicsEffect effect)
+                => effect switch
+                {
+                    Mgce.CompositeEffect composite => composite.Sources.Cast<CompositionEffectSourceParameter>(),
+                    Mgce.GaussianBlurEffect blur => new[] { (CompositionEffectSourceParameter)blur.Source! },
+                    _ => throw new InvalidOperationException($"Unexpected effect {effect.GetType().Name}."),
+                };
+
+            bool WriteNodeHeader(object? value, string category)
+            {
+                if (value is null)
+                {
+                    WriteLine($"{category}: null");
+                    return true;
+                }
+
+                if (_ids.TryGetValue(value, out var existing))
+                {
+                    WriteLine($"{category} #{existing} (shared)");
+                    return true;
+                }
+
+                var id = _ids.Count;
+                _ids.Add(value, id);
+                WriteLine($"{category} #{id} {TypeNameOf(value)}");
+                _indent++;
+                return false;
+            }
+
+            // The names of the stand-in types are the names of the real composition
+            // types, which are also the names of the WinCompData types, so the two
+            // dumps name the same object identically.
+            static string TypeNameOf(object value)
+                => value switch
+                {
+                    LoadedImageSurfaceFromUri _ => "FromUri",
+                    LoadedImageSurfaceFromStream _ => "FromStream",
+                    _ => value.GetType().Name,
+                };
+
+            void WriteChild<T>(string name, T? value, Action<T?> write)
+                where T : class
+            {
+                WriteLine($"{name}:");
+                _indent++;
+                write(value);
+                _indent--;
+            }
+
+            void WriteList<T>(string name, IEnumerable<T> values, Action<T?> write)
+                where T : class
+            {
+                var array = values.ToArray();
+                if (array.Length == 0)
+                {
+                    return;
+                }
+
+                WriteLine($"{name}: [{array.Length}]");
+                _indent++;
+                foreach (var value in array)
+                {
+                    write(value);
+                }
+
+                _indent--;
+            }
+
+            void WriteOptional<T>(string name, T? value)
+                where T : struct
+            {
+                if (value.HasValue)
+                {
+                    WriteLine($"{name}: {Text(value.Value)}");
+                }
+            }
+
+            void Write<T>(string name, T value)
+                where T : struct
+                => WriteLine($"{name}: {Text(value)}");
+
+            void WriteFloats(string name, IEnumerable<float> values)
+            {
+                var array = values.ToArray();
+                if (array.Length > 0)
+                {
+                    WriteLine($"{name}: {string.Join(", ", array.Select(v => Text(v)))}");
+                }
+            }
+
+            void WriteLine(string text)
+                => _builder.Append(' ', _indent * 2).Append(text).Append('\n');
+
+            static string Text(object? value)
+                => value switch
+                {
+                    null => "null",
+                    float f => f.ToString("R", CultureInfo.InvariantCulture),
+                    Vector2 v => $"<{Text(v.X)}, {Text(v.Y)}>",
+                    Vector3 v => $"<{Text(v.X)}, {Text(v.Y)}, {Text(v.Z)}>",
+                    Vector4 v => $"<{Text(v.X)}, {Text(v.Y)}, {Text(v.Z)}, {Text(v.W)}>",
+                    Matrix3x2 m =>
+                        $"[{Text(m.M11)}, {Text(m.M12)}, {Text(m.M21)}, " +
+                        $"{Text(m.M22)}, {Text(m.M31)}, {Text(m.M32)}]",
+                    Matrix4x4 m =>
+                        $"[{Text(m.M11)}, {Text(m.M12)}, {Text(m.M13)}, {Text(m.M14)}, " +
+                        $"{Text(m.M21)}, {Text(m.M22)}, {Text(m.M23)}, {Text(m.M24)}, " +
+                        $"{Text(m.M31)}, {Text(m.M32)}, {Text(m.M33)}, {Text(m.M34)}, " +
+                        $"{Text(m.M41)}, {Text(m.M42)}, {Text(m.M43)}, {Text(m.M44)}]",
+                    Wui.Color c => $"#{c.A:X2}{c.R:X2}{c.G:X2}{c.B:X2}",
+                    CanvasPathBuilder.Command.BeginFigure begin => $"BeginFigure {Text(begin.StartPoint)}",
+                    CanvasPathBuilder.Command.EndFigure end => $"EndFigure {end.FigureLoop}",
+                    CanvasPathBuilder.Command.AddLine line => $"AddLine {Text(line.EndPoint)}",
+                    CanvasPathBuilder.Command.AddCubicBezier bezier =>
+                        $"AddCubicBezier {Text(bezier.ControlPoint1)} " +
+                        $"{Text(bezier.ControlPoint2)} {Text(bezier.EndPoint)}",
+                    _ => value.ToString() ?? string.Empty,
+                };
+        }
+
+        sealed class ReferenceEqualityComparer : IEqualityComparer<object>
+        {
+            internal static readonly ReferenceEqualityComparer Instance = new ReferenceEqualityComparer();
+
+            ReferenceEqualityComparer()
+            {
+            }
+
+            bool IEqualityComparer<object>.Equals(object? x, object? y) => ReferenceEquals(x, y);
+
+            int IEqualityComparer<object>.GetHashCode(object obj)
+                => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+        }
+    }
+}
diff --git a/tests/CompDataFlatbuffer.Tests/InterpreterTests.cs b/tests/CompDataFlatbuffer.Tests/InterpreterTests.cs
new file mode 100644
index 00000000..224cbf6a
--- /dev/null
+++ b/tests/CompDataFlatbuffer.Tests/InterpreterTests.cs
@@ -0,0 +1,214 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Linq;
+using CommunityToolkit.WinUI.Lottie.LottieRuntime;
+using Google.FlatBuffers;
+using Windows.UI.Composition;
+using Xunit;
+using Fb = CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema;
+
+namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Tests
+{
+    /// <summary>
+    /// Verifies that the managed interpreter builds the composition that the buffer
+    /// describes.
+    /// </summary>
+    /// <remarks>
+    /// The interpreter goes straight from bytes to composition objects, so unlike the
+    /// deserializer it cannot be checked by comparing WinCompData graphs. Instead the
+    /// tree it builds is dumped in the same canonical text as the graph that the
+    /// buffer was written from, and the two are compared. Equal text means the
+    /// interpreter created the same objects, gave them the same values, and shared
+    /// them in the same way, which is the whole of what an interpreter has to get
+    /// right.
+    /// <para/>
+    /// The composition APIs that the interpreter calls only exist on Windows, so this
+    /// runs against the stand-ins in CompositionApiStandIns.cs. That means these tests
+    /// verify the calls that the interpreter makes rather than the pixels that Windows
+    /// draws; the pixels are the same as the deserializer's precisely because the
+    /// calls are.
+    /// </remarks>
+    public class InterpreterTests
+    {
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void InterpretedTreeMatchesTheGraph(string fileName)
+        {
+            var translated = Corpus.Translate(fileName);
+
+            var expected = CompositionTreeDumper.Dump(translated.RootVisual);
+            var actual = InterpretedTreeDumper.Dump(Interpret(translated.Serialize()));
+
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void InterpretationIsRepeatable(string fileName)
+        {
+            var buffer = Corpus.Translate(fileName).Serialize();
+
+            // Interpreting the same buffer twice must produce the same tree. A buffer
+            // is read in place, so this also shows that reading it does not modify it.
+            Assert.Equal(
+                InterpretedTreeDumper.Dump(Interpret(buffer)),
+                InterpretedTreeDumper.Dump(Interpret(buffer)));
+        }
+
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void ProgressPropertySetHoldsTheProgressProperty(string fileName)
+        {
+            var root = Interpret(Corpus.Translate(fileName).Serialize());
+
+            // Every translated animation is driven by a single Progress property on the
+            // root visual's property set. A host that cannot find it cannot play the
+            // animation, so this is checked separately from the dump.
+            Assert.Contains(
+                "Progress",
+                CompositionInterpreter.ProgressPropertySet(root).Names.Keys,
+                StringComparer.Ordinal);
+        }
+
+        [Fact]
+        public void EmptyBufferIsRejected()
+            => Assert.Throws<FlatBufferFormatException>(() => Interpret(Array.Empty<byte>()));
+
+        [Fact]
+        public void GarbageIsRejected()
+        {
+            var garbage = new byte[512];
+            new Random(0).NextBytes(garbage);
+
+            Assert.Throws<FlatBufferFormatException>(() => Interpret(garbage));
+        }
+
+        [Fact]
+        public void BufferWithTheWrongFileIdentifierIsRejected()
+        {
+            var buffer = Corpus.Translate("LightBulb.json").Serialize();
+
+            // The file identifier sits at offset 4, immediately after the root offset.
+            buffer[4] = (byte)'X';
+
+            Assert.Throws<FlatBufferFormatException>(() => Interpret(buffer));
+        }
+
+        [Fact]
+        public void BufferWithNoRootVisualIsRejected()
+            => Assert.Throws<FlatBufferFormatException>(
+                () => Interpret(CreateComposition(Format.Version, 0, withRootVisual: false)));
+
+        [Fact]
+        public void NewerSchemaVersionIsRejected()
+        {
+            // A buffer written by a newer serializer may use fields that this build
+            // does not know about, so loading it would silently lose part of the
+            // animation. It is refused instead.
+            var exception = Assert.Throws<NotSupportedException>(
+                () => Interpret(CreateComposition((ushort)(Format.Version + 1), 0)));
+
+            Assert.Contains($"{Format.Version + 1}", exception.Message, StringComparison.Ordinal);
+        }
+
+        [Fact]
+        public void CurrentSchemaVersionIsAccepted()
+            => Assert.NotNull(Interpret(CreateComposition(Format.Version, 0)));
+
+        [Fact]
+        public void UnavailableApiContractIsRejected()
+        {
+            // An animation that needs composition APIs that this version of Windows
+            // does not have is refused rather than built into a tree that cannot run.
+            var exception = Assert.Throws<NotSupportedException>(
+                () => Interpret(CreateComposition(Format.Version, ushort.MaxValue)));
+
+            Assert.Contains("UniversalApiContract", exception.Message, StringComparison.Ordinal);
+        }
+
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void TruncatedBuffersAreRejected(string fileName)
+        {
+            var buffer = Corpus.Translate(fileName).Serialize();
+
+            // Truncation is checked at a spread of lengths rather than at every length,
+            // which would make the test run for minutes without finding anything more.
+            for (var length = 0; length < buffer.Length; length += Math.Max(1, buffer.Length / 64))
+            {
+                var truncated = new byte[length];
+                Array.Copy(buffer, truncated, length);
+
+                Assert.Throws<FlatBufferFormatException>(() => Interpret(truncated));
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
+        public void CorruptedBuffersDoNotCrash(string fileName)
+        {
+            var original = Corpus.Translate(fileName).Serialize();
+            var random = new Random(fileName.GetHashCode(StringComparison.Ordinal));
+
+            // Unlike truncation, a flipped bit may leave a buffer that is still valid,
+            // just describing a different animation. So the requirement here is weaker:
+            // the interpreter either succeeds or reports a format error, but never
+            // throws something else and never reads outside the buffer.
+            for (var i = 0; i < 200; i++)
+            {
+                var corrupted = (byte[])original.Clone();
+                corrupted[random.Next(corrupted.Length)] ^= (byte)(1 << random.Next(8));
+
+                try
+                {
+                    Interpret(corrupted);
+                }
+                catch (FlatBufferFormatException)
+                {
+                }
+                catch (NotSupportedException)
+                {
+                    // A flipped bit can also land in the schema version or the required
+                    // API contract version.
+                }
+            }
+        }
+
+        static Visual Interpret(byte[] buffer)
+            => CompositionInterpreter.LoadComposition(new Compositor(), buffer);
+
+        // Builds the smallest possible composition: one empty container visual. Used by
+        // the tests of the header, which have nothing to do with the contents.
+        static byte[] CreateComposition(ushort schemaVersion, ushort requiredUapVersion, bool withRootVisual = true)
+        {
+            var builder = new FlatBufferBuilder(256);
+
+            Fb.Visual.StartVisual(builder);
+            Fb.Visual.AddKind(builder, Fb.VisualKind.Container);
+            var visual = Fb.Visual.EndVisual(builder);
+
+            var visuals = Fb.LottieComposition.CreateVisualsVector(builder, new[] { visual });
+
+            Fb.LottieComposition.StartLottieComposition(builder);
+            Fb.LottieComposition.AddSchemaVersion(builder, schemaVersion);
+            Fb.LottieComposition.AddRequiredUapVersion(builder, requiredUapVersion);
+
+            if (withRootVisual)
+            {
+                Fb.LottieComposition.AddRootVisual(builder, 0);
+            }
+
+            Fb.LottieComposition.AddVisuals(builder, visuals);
+            var composition = Fb.LottieComposition.EndLottieComposition(builder);
+
+            Fb.LottieComposition.FinishLottieCompositionBuffer(builder, composition);
+
+            return builder.SizedByteArray();
+        }
+    }
+}

From 44b3258001269791979ac89983f6f4df0e2573d8 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 2 Sep 2026 16:20:52 +0000
Subject: [PATCH 28/39] Simplify property set name enumeration in the
 interpreted tree dumper

Co-authored-by: jonwis <18537118+jonwis@users.noreply.github.com>
---
 tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs b/tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs
index c323243d..82035b07 100644
--- a/tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs
+++ b/tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs
@@ -653,7 +653,7 @@ void WriteCompositionObject(CompositionObject value)
 
             void WritePropertySetContents(CompositionPropertySet value)
             {
-                foreach (var (name, _) in value.Names.Select(n => (n.Key, n.Value)))
+                foreach (var name in value.Names.Keys)
                 {
                     WriteLine($"{name}: {Text(value.GetValue(name))}");
                 }

From 731b12c8f9cb948e54c8464c02b32b5511ffff66 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Wed, 2 Sep 2026 12:40:35 -0700
Subject: [PATCH 29/39] Improve managed runtime Native AOT integration

Split runtime schema dependencies from tool-side serialization, avoid copying byte-array buffers, and process keyframes in one pass.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 408cb9b9-d2b1-4a7a-bc3e-f6ab25b8793f
---
 .../CompDataFlatbuffer.projitems              |  11 +-
 .../CompDataFlatbufferRuntime.projitems       |  18 +++
 .../LottieRuntime/CompositionInterpreter.cs   | 134 +++++++++++-------
 source/LottieRuntime/LottieRuntime.projitems  |   4 +
 source/LottieRuntime/README.md                |   6 +-
 5 files changed, 111 insertions(+), 62 deletions(-)
 create mode 100644 source/CompDataFlatbuffer/CompDataFlatbufferRuntime.projitems

diff --git a/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems b/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
index 90d3537b..69bfe016 100644
--- a/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
+++ b/source/CompDataFlatbuffer/CompDataFlatbuffer.projitems
@@ -8,16 +8,13 @@
   <PropertyGroup Label="Configuration">
     <Import_RootNamespace>CompDataFlatbuffer</Import_RootNamespace>
   </PropertyGroup>
+  <Import
+    Project="$(MSBuildThisFileDirectory)CompDataFlatbufferRuntime.projitems"
+    Condition="'$(CompDataFlatbufferRuntimeImported)' != 'true'"
+    Label="Shared" />
   <ItemGroup>
-    <Compile Include="$(MSBuildThisFileDirectory)FlatBufferFormatException.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Format.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)GraphIndexer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CompositionDeserializer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CompositionSerializer.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <!-- Generated by build/RegenerateFlatbuffers.ps1 from source/LottieFlatbuffer/lottie_comp.fbs.
-         Checked in so that contributors do not need flatc installed. -->
-    <Compile Include="$(MSBuildThisFileDirectory)Generated\lottie_comp_generated.cs" />
-  </ItemGroup>
 </Project>
diff --git a/source/CompDataFlatbuffer/CompDataFlatbufferRuntime.projitems b/source/CompDataFlatbuffer/CompDataFlatbufferRuntime.projitems
new file mode 100644
index 00000000..01949a2a
--- /dev/null
+++ b/source/CompDataFlatbuffer/CompDataFlatbufferRuntime.projitems
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <CompDataFlatbufferRuntimeImported>true</CompDataFlatbufferRuntimeImported>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration">
+    <Import_RootNamespace>CompDataFlatbuffer</Import_RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)FlatBufferFormatException.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Format.cs" />
+    <!-- Generated by build/RegenerateFlatbuffers.ps1 from source/LottieFlatbuffer/lottie_comp.fbs.
+         Checked in so that contributors do not need flatc installed. -->
+    <Compile Include="$(MSBuildThisFileDirectory)Generated\lottie_comp_generated.cs" />
+  </ItemGroup>
+</Project>
diff --git a/source/LottieRuntime/CompositionInterpreter.cs b/source/LottieRuntime/CompositionInterpreter.cs
index 123061a1..b7071b40 100644
--- a/source/LottieRuntime/CompositionInterpreter.cs
+++ b/source/LottieRuntime/CompositionInterpreter.cs
@@ -125,6 +125,24 @@ enum CanvasGeometryState
             Realized,
         }
 
+        /// <summary>
+        /// Builds the visual tree described by a serialized composition.
+        /// </summary>
+        /// <param name="compositor">The compositor that creates the objects.</param>
+        /// <param name="bytes">A buffer produced by <c>CompositionSerializer</c>.</param>
+        /// <returns>The root of the visual tree.</returns>
+        /// <exception cref="FlatBufferFormatException">The buffer is not a well formed composition.</exception>
+        /// <exception cref="NotSupportedException">The composition needs a newer schema or a newer version of Windows.</exception>
+        public static Wc.Visual LoadComposition(Wc.Compositor compositor, byte[] bytes)
+        {
+            if (bytes is null)
+            {
+                throw new ArgumentNullException(nameof(bytes));
+            }
+
+            return LoadComposition(compositor, new ByteBuffer(bytes), bytes.Length);
+        }
+
         /// <summary>
         /// Builds the visual tree described by a serialized composition.
         /// </summary>
@@ -134,6 +152,9 @@ enum CanvasGeometryState
         /// <exception cref="FlatBufferFormatException">The buffer is not a well formed composition.</exception>
         /// <exception cref="NotSupportedException">The composition needs a newer schema or a newer version of Windows.</exception>
         public static Wc.Visual LoadComposition(Wc.Compositor compositor, ReadOnlySpan<byte> bytes)
+            => LoadComposition(compositor, new ByteBuffer(bytes.ToArray()), bytes.Length);
+
+        static Wc.Visual LoadComposition(Wc.Compositor compositor, ByteBuffer buffer, int length)
         {
             if (compositor is null)
             {
@@ -142,9 +163,7 @@ public static Wc.Visual LoadComposition(Wc.Compositor compositor, ReadOnlySpan<b
 
             // The buffer is untrusted, so nothing is read out of it until the verifier
             // has agreed that every offset in it is inside it.
-            var buffer = new ByteBuffer(bytes.ToArray());
-
-            if (bytes.Length < MinimumBufferLength ||
+            if (length < MinimumBufferLength ||
                 !Fb.LottieComposition.LottieCompositionBufferHasIdentifier(buffer))
             {
                 throw new FlatBufferFormatException("The buffer is not a composition.");
@@ -208,7 +227,7 @@ public static Wc.Visual LoadComposition(Wc.Compositor compositor, ReadOnlySpan<b
         /// <summary>
         /// Returns the property set that drives an interpreted composition.
         /// </summary>
-        /// <param name="root">A root returned by <see cref="LoadComposition"/>.</param>
+        /// <param name="root">A root returned by <c>LoadComposition</c>.</param>
         /// <returns>The property set that holds the animation's Progress property.</returns>
         public static Wc.CompositionPropertySet ProgressPropertySet(Wc.Visual root)
         {
@@ -1507,35 +1526,34 @@ void ApplyGradientBrushProperties(Wc.CompositionGradientBrush target, Fb.Brush t
         Wc.CompositionAnimation CreateKeyFrameAnimation(Fb.Animation table)
         {
             Wc.KeyFrameAnimation result;
+            Wc.ScalarKeyFrameAnimation? scalar = null;
+            Wc.Vector2KeyFrameAnimation? vector2 = null;
+            Wc.Vector3KeyFrameAnimation? vector3 = null;
+            Wc.Vector4KeyFrameAnimation? vector4 = null;
+            Wc.ColorKeyFrameAnimation? color = null;
+            Wc.BooleanKeyFrameAnimation? boolean = null;
+            Wc.PathKeyFrameAnimation? path = null;
 
             switch (table.Kind)
             {
                 case Fb.AnimationKind.Scalar:
-                    var scalar = _compositor.CreateScalarKeyFrameAnimation();
-                    ForEachValueKeyFrame(table, frame =>
-                        scalar.InsertKeyFrame(frame.Progress, frame.Scalar, GetEasing(frame.Easing)));
+                    scalar = _compositor.CreateScalarKeyFrameAnimation();
                     result = scalar;
                     break;
                 case Fb.AnimationKind.Vector2:
-                    var vector2 = _compositor.CreateVector2KeyFrameAnimation();
-                    ForEachValueKeyFrame(table, frame =>
-                        vector2.InsertKeyFrame(frame.Progress, ToVector2(frame.Vector), GetEasing(frame.Easing)));
+                    vector2 = _compositor.CreateVector2KeyFrameAnimation();
                     result = vector2;
                     break;
                 case Fb.AnimationKind.Vector3:
-                    var vector3 = _compositor.CreateVector3KeyFrameAnimation();
-                    ForEachValueKeyFrame(table, frame =>
-                        vector3.InsertKeyFrame(frame.Progress, ToVector3(frame.Vector), GetEasing(frame.Easing)));
+                    vector3 = _compositor.CreateVector3KeyFrameAnimation();
                     result = vector3;
                     break;
                 case Fb.AnimationKind.Vector4:
-                    var vector4 = _compositor.CreateVector4KeyFrameAnimation();
-                    ForEachValueKeyFrame(table, frame =>
-                        vector4.InsertKeyFrame(frame.Progress, ToVector4(frame.Vector), GetEasing(frame.Easing)));
+                    vector4 = _compositor.CreateVector4KeyFrameAnimation();
                     result = vector4;
                     break;
                 case Fb.AnimationKind.Color:
-                    var color = _compositor.CreateColorKeyFrameAnimation();
+                    color = _compositor.CreateColorKeyFrameAnimation();
 
                     if (table.InterpolationColorSpace.HasValue)
                     {
@@ -1543,40 +1561,20 @@ Wc.CompositionAnimation CreateKeyFrameAnimation(Fb.Animation table)
                             (Wc.CompositionColorSpace)table.InterpolationColorSpace.Value;
                     }
 
-                    ForEachValueKeyFrame(table, frame =>
-                        color.InsertKeyFrame(
-                            frame.Progress,
-                            ToColor(Require(frame.Color, "color")),
-                            GetEasing(frame.Easing)));
                     result = color;
                     break;
                 case Fb.AnimationKind.Boolean:
-                    var boolean = _compositor.CreateBooleanKeyFrameAnimation();
-
-                    // A boolean cannot be interpolated, so it has no easing.
-                    ForEachValueKeyFrame(table, frame =>
-                        boolean.InsertKeyFrame(frame.Progress, frame.Scalar != 0));
+                    boolean = _compositor.CreateBooleanKeyFrameAnimation();
                     result = boolean;
                     break;
                 case Fb.AnimationKind.Path:
-                    var path = _compositor.CreatePathKeyFrameAnimation();
-                    ForEachValueKeyFrame(table, frame =>
-                        path.InsertKeyFrame(
-                            frame.Progress,
-                            new Wc.CompositionPath(
-                                GetCanvasGeometry(frame.Path)
-                                ?? throw new FlatBufferFormatException("A path key frame has no path.")),
-                            GetEasing(frame.Easing)));
+                    path = _compositor.CreatePathKeyFrameAnimation();
                     result = path;
                     break;
                 default:
                     throw new FlatBufferFormatException($"Unsupported animation kind {table.Kind}.");
             }
 
-            // Expression key frames are inserted through the base type, so they do not
-            // have to be repeated in every branch above. They are inserted after the
-            // value key frames, which is safe because a key frame animation is a map
-            // keyed on progress rather than a list.
             for (var i = 0; i < table.KeyFramesLength; i++)
             {
                 var frame = Require(table.KeyFrames(i), "key frame");
@@ -1588,6 +1586,51 @@ Wc.CompositionAnimation CreateKeyFrameAnimation(Fb.Animation table)
                         GetRequiredString(frame.Expression),
                         GetEasing(frame.Easing));
                 }
+                else if (frame.Kind == Fb.KeyFrameKind.Value)
+                {
+                    switch (table.Kind)
+                    {
+                        case Fb.AnimationKind.Scalar:
+                            scalar!.InsertKeyFrame(frame.Progress, frame.Scalar, GetEasing(frame.Easing));
+                            break;
+                        case Fb.AnimationKind.Vector2:
+                            vector2!.InsertKeyFrame(
+                                frame.Progress,
+                                ToVector2(frame.Vector),
+                                GetEasing(frame.Easing));
+                            break;
+                        case Fb.AnimationKind.Vector3:
+                            vector3!.InsertKeyFrame(
+                                frame.Progress,
+                                ToVector3(frame.Vector),
+                                GetEasing(frame.Easing));
+                            break;
+                        case Fb.AnimationKind.Vector4:
+                            vector4!.InsertKeyFrame(
+                                frame.Progress,
+                                ToVector4(frame.Vector),
+                                GetEasing(frame.Easing));
+                            break;
+                        case Fb.AnimationKind.Color:
+                            color!.InsertKeyFrame(
+                                frame.Progress,
+                                ToColor(Require(frame.Color, "color")),
+                                GetEasing(frame.Easing));
+                            break;
+                        case Fb.AnimationKind.Boolean:
+                            // A boolean cannot be interpolated, so it has no easing.
+                            boolean!.InsertKeyFrame(frame.Progress, frame.Scalar != 0);
+                            break;
+                        case Fb.AnimationKind.Path:
+                            path!.InsertKeyFrame(
+                                frame.Progress,
+                                new Wc.CompositionPath(
+                                    GetCanvasGeometry(frame.Path)
+                                    ?? throw new FlatBufferFormatException("A path key frame has no path.")),
+                                GetEasing(frame.Easing));
+                            break;
+                    }
+                }
             }
 
             result.Duration = TimeSpan.FromTicks(table.DurationTicks);
@@ -1595,19 +1638,6 @@ Wc.CompositionAnimation CreateKeyFrameAnimation(Fb.Animation table)
             return result;
         }
 
-        void ForEachValueKeyFrame(Fb.Animation table, Action<Fb.KeyFrame> apply)
-        {
-            for (var i = 0; i < table.KeyFramesLength; i++)
-            {
-                var frame = Require(table.KeyFrames(i), "key frame");
-
-                if (frame.Kind == Fb.KeyFrameKind.Value)
-                {
-                    apply(frame);
-                }
-            }
-        }
-
         // ---------------------------------------------------------------------
         // Paths.
         //
diff --git a/source/LottieRuntime/LottieRuntime.projitems b/source/LottieRuntime/LottieRuntime.projitems
index bfd579d4..403fb1e2 100644
--- a/source/LottieRuntime/LottieRuntime.projitems
+++ b/source/LottieRuntime/LottieRuntime.projitems
@@ -8,6 +8,10 @@
   <PropertyGroup Label="Configuration">
     <Import_RootNamespace>LottieRuntime</Import_RootNamespace>
   </PropertyGroup>
+  <Import
+    Project="$(MSBuildThisFileDirectory)..\CompDataFlatbuffer\CompDataFlatbufferRuntime.projitems"
+    Condition="'$(CompDataFlatbufferRuntimeImported)' != 'true'"
+    Label="Shared" />
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)CompositionInterpreter.cs" />
   </ItemGroup>
diff --git a/source/LottieRuntime/README.md b/source/LottieRuntime/README.md
index 23d6015f..3b94437e 100644
--- a/source/LottieRuntime/README.md
+++ b/source/LottieRuntime/README.md
@@ -89,9 +89,9 @@ takes the Win2D dependency, exactly as a consumer of `Instantiator` or of
 ## Incorporate it in a build
 
 `LottieRuntime.projitems` is a shared project. Import it into the application
-project alongside `CompDataFlatbuffer.projitems`, which contains the generated schema
-binding and the format constants, and add a package reference to
-`Google.FlatBuffers`.
+project and add a package reference to `Google.FlatBuffers`. The runtime imports
+the generated schema binding and format constants without bringing in the
+tool-side serializer, deserializer, or `WinCompData` model.
 
 Define `WINAPPSDK` when building for the Windows App SDK, which switches the
 interpreter from `Windows.UI.Composition` to `Microsoft.UI.Composition`. Define

From 9ebcc9e42118491cd312b56f6677e44e90f09138 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Tue, 29 Sep 2026 23:31:56 -0700
Subject: [PATCH 30/39] Remove ineffective Visual Studio setup step

---
 .github/workflows/dotnet-build.yml | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/.github/workflows/dotnet-build.yml b/.github/workflows/dotnet-build.yml
index 8c787688..ee79e8db 100644
--- a/.github/workflows/dotnet-build.yml
+++ b/.github/workflows/dotnet-build.yml
@@ -31,12 +31,6 @@ jobs:
         with:
           fetch-depth: 0
 
-      # Set up a VS build environment.
-      - name: Setup Environment Variables
-        run: |
-          "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\VsDevCmd.bat" -no_logo
-        shell: cmd
-
       # Install NuGet tools.  
       - name: Setup NuGet
         uses: NuGet/setup-nuget@v2
@@ -169,4 +163,4 @@ jobs:
           **/*.nupkg
           --source https://api.nuget.org/v3/index.json
           --api-key ${{ secrets.NUGET_PACKAGE_PUSH_TOKEN }}
-          --skip-duplicate
\ No newline at end of file
+          --skip-duplicate

From 247865119de7fe141e1d6a18159c116f26180c85 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Mon, 12 Oct 2026 16:39:40 -0700
Subject: [PATCH 31/39] Refactor native Lottie runtime integration

Remove the managed and COM loader implementations, add projection-selectable native source, emit multi-UAP FlatBuffer variants, and consolidate the validation tool under source/LottieRuntime.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: adcabe6f-aa5c-4e06-948d-b49e5adae80c
---
 Lottie-Windows.sln                            |   24 +
 LottieGen/DotnetTool/LottieGen.csproj         |   13 +-
 README.md                                     |    2 +-
 build/RegenerateFlatbuffers.ps1               |    2 +-
 dlls/LottieRuntime/LottieRuntime.def          |    6 -
 dlls/LottieRuntime/LottieRuntime.manifest     |   14 -
 dlls/LottieRuntime/LottieRuntime.vcxproj      |   99 -
 dlls/LottieRuntime/LottieRuntimeCom.cpp       |  138 --
 dlls/LottieRuntime/LottieRuntimeCom.h         |   25 -
 dlls/LottieRuntime/README.md                  |  180 --
 dlls/LottieRuntimeTool/README.md              |   54 -
 dlls/README.md                                |    8 -
 source/LottieFlatbuffer/README.md             |    7 +-
 source/LottieGen/LottieJsonFileProcessor.cs   |   79 +-
 source/LottieGenExe/Main.cs                   |   14 +-
 .../LottieRuntime/CompositionInterpreter.cs   | 1828 -----------------
 .../Generated/lottie_comp_generated.h         |    0
 .../LottieRuntime/LottieRuntime.cpp           |   64 +-
 .../LottieRuntime/LottieRuntime.h             |   27 +-
 source/LottieRuntime/LottieRuntime.projitems  |   18 -
 source/LottieRuntime/LottieRuntime.shproj     |   13 -
 .../LottieRuntime/LottieRuntimeTool.cpp       |   48 +-
 .../LottieRuntime/LottieRuntimeTool.vcxproj   |   31 +-
 source/LottieRuntime/README.md                |  174 +-
 .../CompDataFlatbuffer.Tests.csproj           |    1 -
 .../CompositionApiStandIns.cs                 | 1112 ----------
 .../CompDataFlatbuffer.Tests/CoverageTests.cs |   17 -
 .../InterpretedTreeDumper.cs                  |  805 --------
 .../InterpreterTests.cs                       |  214 --
 29 files changed, 284 insertions(+), 4733 deletions(-)
 delete mode 100644 dlls/LottieRuntime/LottieRuntime.def
 delete mode 100644 dlls/LottieRuntime/LottieRuntime.manifest
 delete mode 100644 dlls/LottieRuntime/LottieRuntime.vcxproj
 delete mode 100644 dlls/LottieRuntime/LottieRuntimeCom.cpp
 delete mode 100644 dlls/LottieRuntime/LottieRuntimeCom.h
 delete mode 100644 dlls/LottieRuntime/README.md
 delete mode 100644 dlls/LottieRuntimeTool/README.md
 delete mode 100644 source/LottieRuntime/CompositionInterpreter.cs
 rename {dlls => source}/LottieRuntime/Generated/lottie_comp_generated.h (100%)
 rename {dlls => source}/LottieRuntime/LottieRuntime.cpp (97%)
 rename {dlls => source}/LottieRuntime/LottieRuntime.h (69%)
 delete mode 100644 source/LottieRuntime/LottieRuntime.projitems
 delete mode 100644 source/LottieRuntime/LottieRuntime.shproj
 rename dlls/LottieRuntimeTool/LottieRuntime.cpp => source/LottieRuntime/LottieRuntimeTool.cpp (84%)
 rename dlls/LottieRuntimeTool/LottieRuntime.vcxproj => source/LottieRuntime/LottieRuntimeTool.vcxproj (69%)
 delete mode 100644 tests/CompDataFlatbuffer.Tests/CompositionApiStandIns.cs
 delete mode 100644 tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs
 delete mode 100644 tests/CompDataFlatbuffer.Tests/InterpreterTests.cs

diff --git a/Lottie-Windows.sln b/Lottie-Windows.sln
index a1b9997f..e7b0b362 100644
--- a/Lottie-Windows.sln
+++ b/Lottie-Windows.sln
@@ -173,6 +173,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LottieSamples", "LottieSamp
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Lottie-Windows-UwpNET", "Lottie-Windows\Lottie-Windows-UwpNET\Lottie-Windows-UwpNET.csproj", "{FA1977D8-5C6F-DF3A-0926-C12A1A415024}"
 EndProject
+Project("{BC8A1FFA-BEE3-4634-8014-F334798102B3}") = "LottieRuntimeTool", "source\LottieRuntime\LottieRuntimeTool.vcxproj", "{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		BETA|Any CPU = BETA|Any CPU
@@ -192,6 +194,27 @@ Global
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.BETA|Any CPU.ActiveCfg = Release|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.BETA|ARM.ActiveCfg = Release|ARM64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.BETA|ARM64.ActiveCfg = Release|ARM64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.BETA|ARM64.Build.0 = Release|ARM64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.BETA|x64.ActiveCfg = Release|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.BETA|x64.Build.0 = Release|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.BETA|x86.ActiveCfg = Release|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Debug|ARM.ActiveCfg = Debug|ARM64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Debug|ARM64.Build.0 = Debug|ARM64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Debug|x64.ActiveCfg = Debug|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Debug|x64.Build.0 = Debug|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Debug|x86.ActiveCfg = Debug|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Release|Any CPU.ActiveCfg = Release|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Release|ARM.ActiveCfg = Release|ARM64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Release|ARM64.ActiveCfg = Release|ARM64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Release|ARM64.Build.0 = Release|ARM64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Release|x64.ActiveCfg = Release|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Release|x64.Build.0 = Release|x64
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48}.Release|x86.ActiveCfg = Release|x64
 		{5120EFD7-A556-46BF-8D56-F65F1EF9A305}.BETA|Any CPU.ActiveCfg = BETA|x86
 		{5120EFD7-A556-46BF-8D56-F65F1EF9A305}.BETA|ARM.ActiveCfg = BETA|ARM
 		{5120EFD7-A556-46BF-8D56-F65F1EF9A305}.BETA|ARM.Build.0 = BETA|ARM
@@ -685,6 +708,7 @@ Global
 		{FC89273A-B2DA-4625-8A73-EF02A658D65E} = {AB232F35-AAF7-4AE2-B1D2-45DD9BC2F7D7}
 		{7654A857-9A99-4185-9F8E-DD0CE662AF23} = {AB232F35-AAF7-4AE2-B1D2-45DD9BC2F7D7}
 		{DC7F7A39-B7A7-40B4-937A-601460CAE38C} = {AB232F35-AAF7-4AE2-B1D2-45DD9BC2F7D7}
+		{9A7B4C2E-1F3D-4B7A-9C3E-2D5A8F0B2E48} = {AB232F35-AAF7-4AE2-B1D2-45DD9BC2F7D7}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {51B9BB4C-5196-41CF-950C-12B04AD8A61C}
diff --git a/LottieGen/DotnetTool/LottieGen.csproj b/LottieGen/DotnetTool/LottieGen.csproj
index 79e61622..00f3dfc4 100644
--- a/LottieGen/DotnetTool/LottieGen.csproj
+++ b/LottieGen/DotnetTool/LottieGen.csproj
@@ -39,15 +39,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <None Include="..\..\dlls\LottieRuntime\LottieRuntime.cpp" Pack="true" PackagePath="LottieRuntime\" />
-    <None Include="..\..\dlls\LottieRuntime\LottieRuntime.h" Pack="true" PackagePath="LottieRuntime\" />
-    <None Include="..\..\dlls\LottieRuntime\LottieRuntimeCom.cpp" Pack="true" PackagePath="LottieRuntime\" />
-    <None Include="..\..\dlls\LottieRuntime\LottieRuntimeCom.h" Pack="true" PackagePath="LottieRuntime\" />
-    <None Include="..\..\dlls\LottieRuntime\LottieRuntime.def" Pack="true" PackagePath="LottieRuntime\" />
-    <None Include="..\..\dlls\LottieRuntime\LottieRuntime.manifest" Pack="true" PackagePath="LottieRuntime\" />
-    <None Include="..\..\dlls\LottieRuntime\LottieRuntime.vcxproj" Pack="true" PackagePath="LottieRuntime\" />
-    <None Include="..\..\dlls\LottieRuntime\README.md" Pack="true" PackagePath="LottieRuntime\" />
-    <None Include="..\..\dlls\LottieRuntime\Generated\lottie_comp_generated.h" Pack="true" PackagePath="LottieRuntime\Generated\" />
+    <None Include="..\..\source\LottieRuntime\LottieRuntime.h" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\source\LottieRuntime\LottieRuntime.cpp" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\source\LottieRuntime\README.md" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\source\LottieRuntime\Generated\lottie_comp_generated.h" Pack="true" PackagePath="LottieRuntime\Generated\" />
     <None Include="..\..\external\flatbuffers\include\**\*" Pack="true" PackagePath="LottieRuntime\flatbuffers\include\" />
     <None Include="..\..\external\flatbuffers\LICENSE" Pack="true" PackagePath="LottieRuntime\flatbuffers\" />
     <None Include="..\..\LICENSE.md" Pack="true" PackagePath="LottieRuntime\" />
diff --git a/README.md b/README.md
index 15b643b5..1efd23a3 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@ Lottie-Windows consists of 3 related products:
 
 This repo also contains source code for **[samples](/LottieViewer)**.
 
-It also contains **[LottieRuntime](/dlls/LottieRuntime)**, a native C++/WinRT interpreter that
+It also contains **[LottieRuntime](/source/LottieRuntime)**, native C++/WinRT source that
 builds the composition tree at runtime from a serialized animation produced by
 `LottieGen -Language flatbuffer`. It keeps the animation as data, like the JSON path does, but
 without shipping a JSON parser or the translator. See
diff --git a/build/RegenerateFlatbuffers.ps1 b/build/RegenerateFlatbuffers.ps1
index 1a2e0efc..0de938e3 100644
--- a/build/RegenerateFlatbuffers.ps1
+++ b/build/RegenerateFlatbuffers.ps1
@@ -25,7 +25,7 @@ $expectedCppVersion = "25.12.19"
 $repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..")
 $schema = Join-Path $repoRoot "source/LottieFlatbuffer/lottie_comp.fbs"
 $csharpOut = Join-Path $repoRoot "source/CompDataFlatbuffer/Generated"
-$cppOut = Join-Path $repoRoot "dlls/LottieRuntime/Generated"
+$cppOut = Join-Path $repoRoot "source/LottieRuntime/Generated"
 
 $actualCSharpVersion = (& $CSharpFlatc --version) -replace '^flatc version ', ''
 if ($actualCSharpVersion.Trim() -ne $expectedCSharpVersion) {
diff --git a/dlls/LottieRuntime/LottieRuntime.def b/dlls/LottieRuntime/LottieRuntime.def
deleted file mode 100644
index 7c435ed5..00000000
--- a/dlls/LottieRuntime/LottieRuntime.def
+++ /dev/null
@@ -1,6 +0,0 @@
-; Classic COM entry points must have undecorated names for CoCreateInstance's
-; loader (and for the test's GetProcAddress-based activation) to find them.
-LIBRARY LottieRuntime
-EXPORTS
-    DllGetClassObject   PRIVATE
-    DllCanUnloadNow     PRIVATE
diff --git a/dlls/LottieRuntime/LottieRuntime.manifest b/dlls/LottieRuntime/LottieRuntime.manifest
deleted file mode 100644
index d93a09f5..00000000
--- a/dlls/LottieRuntime/LottieRuntime.manifest
+++ /dev/null
@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
-  <!-- Private assembly identity for registration-free COM activation. -->
-  <assemblyIdentity
-      type="win32"
-      name="LottieRuntime"
-      version="1.0.0.0"
-      processorArchitecture="*" />
-  <file name="LottieRuntime.dll">
-    <comClass
-        clsid="{9F7B7089-F512-4BBC-81FE-4FF12B4DA159}"
-        threadingModel="Both" />
-  </file>
-</assembly>
diff --git a/dlls/LottieRuntime/LottieRuntime.vcxproj b/dlls/LottieRuntime/LottieRuntime.vcxproj
deleted file mode 100644
index 5cad979f..00000000
--- a/dlls/LottieRuntime/LottieRuntime.vcxproj
+++ /dev/null
@@ -1,99 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|ARM64">
-      <Configuration>Debug</Configuration>
-      <Platform>ARM64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|ARM64">
-      <Configuration>Release</Configuration>
-      <Platform>ARM64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{6E0A5B4C-2F1D-4B7A-9C3E-1D5A8F0B2E47}</ProjectGuid>
-    <RootNamespace>LottieRuntime</RootNamespace>
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-    <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
-
-    <!-- The DLL loads on the Lottie-Windows minimum. Each buffer declares and
-         validates the UniversalApiContract version needed by its graph. -->
-    <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
-    <FlatBuffersIncludeDirectory
-        Condition="'$(FlatBuffersIncludeDirectory)'=='' and Exists('$(MSBuildThisFileDirectory)..\..\external\flatbuffers\include')">$(MSBuildThisFileDirectory)..\..\external\flatbuffers\include</FlatBuffersIncludeDirectory>
-    <FlatBuffersIncludeDirectory
-        Condition="'$(FlatBuffersIncludeDirectory)'==''">$(MSBuildThisFileDirectory)flatbuffers\include</FlatBuffersIncludeDirectory>
-  </PropertyGroup>
-
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-
-  <PropertyGroup>
-    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
-    <UseDebugLibraries Condition="'$(Configuration)'=='Release'">false</UseDebugLibraries>
-    <WholeProgramOptimization Condition="'$(Configuration)'=='Release'">true</WholeProgramOptimization>
-  </PropertyGroup>
-
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <LanguageStandard>stdcpp20</LanguageStandard>
-      <PreprocessorDefinitions>WIN32_LEAN_AND_MEAN;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory);$(FlatBuffersIncludeDirectory);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <WarningLevel>Level4</WarningLevel>
-      <TreatWarningAsError>true</TreatWarningAsError>
-
-      <!-- Exceptions are the error channel, and every interop entry point is
-           noexcept, so there is nothing to unwind across an ABI boundary. -->
-      <ExceptionHandling>Sync</ExceptionHandling>
-
-      <!-- Size is the first thing this component optimizes for. -->
-      <Optimization Condition="'$(Configuration)'=='Release'">MinSpace</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <StringPooling>true</StringPooling>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>d2d1.lib;dxguid.lib;shcore.lib;shlwapi.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <ModuleDefinitionFile>LottieRuntime.def</ModuleDefinitionFile>
-
-      <!-- Discards the code for any node type the application never reaches. -->
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-    </Link>
-  </ItemDefinitionGroup>
-
-  <ItemGroup>
-    <ClInclude Include="LottieRuntime.h" />
-    <ClInclude Include="LottieRuntimeCom.h" />
-    <ClInclude Include="Generated\lottie_comp_generated.h" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ClCompile Include="LottieRuntime.cpp" />
-    <ClCompile Include="LottieRuntimeCom.cpp" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <!-- Consumers activate this private assembly manifest instead of registering
-         the class in HKEY_CLASSES_ROOT. -->
-    <None Include="LottieRuntime.manifest" />
-  </ItemGroup>
-
-  <ItemDefinitionGroup>
-    <Link>
-      <GenerateManifest>false</GenerateManifest>
-    </Link>
-  </ItemDefinitionGroup>
-
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-</Project>
diff --git a/dlls/LottieRuntime/LottieRuntimeCom.cpp b/dlls/LottieRuntime/LottieRuntimeCom.cpp
deleted file mode 100644
index b82fef6c..00000000
--- a/dlls/LottieRuntime/LottieRuntimeCom.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-// The classic COM entry point declared in LottieRuntimeCom.h. This is the only
-// translation unit that needs to know both LoadComposition and classic COM, so it
-// stays out of LottieRuntime.cpp.
-
-#include <unknwn.h>
-
-#include "LottieRuntimeCom.h"
-#include "LottieRuntime.h"
-
-#include <winrt/Windows.Foundation.h>
-#include <winrt/Windows.System.h>
-#include <winrt/Windows.UI.Composition.h>
-
-using namespace winrt::Windows::UI::Composition;
-
-
-namespace
-{
-    // The caller owns the thread's DispatcherQueue. It must outlive every Visual
-    // returned by this loader.
-    struct LottieCompositionLoader : winrt::implements<LottieCompositionLoader, ILottieCompositionLoader>
-    {
-        STDMETHODIMP LoadComposition(UINT32 length, BYTE const* buffer, REFIID riid, void** result) noexcept override
-        {
-            if (result == nullptr)
-            {
-                return E_POINTER;
-            }
-
-            *result = nullptr;
-
-            if (buffer == nullptr && length != 0)
-            {
-                return E_INVALIDARG;
-            }
-
-            try
-            {
-                if (!m_compositor)
-                {
-                    if (!winrt::Windows::System::DispatcherQueue::GetForCurrentThread())
-                    {
-                        return E_ILLEGAL_METHOD_CALL;
-                    }
-
-                    m_compositor = Compositor();
-                }
-
-                auto const span = std::span(reinterpret_cast<std::byte const*>(buffer), length);
-                auto const visual = CommunityToolkit::WinUI::Lottie::LoadComposition(m_compositor, span);
-                return visual.as<::IUnknown>()->QueryInterface(riid, result);
-            }
-            catch (...)
-            {
-                return winrt::to_hresult();
-            }
-        }
-
-    private:
-        Compositor m_compositor{ nullptr };
-    };
-
-    // A minimal class factory: this DLL only ever creates LottieCompositionLoader,
-    // so there is no per-CLSID dispatch to do.
-    struct ClassFactory : winrt::implements<ClassFactory, IClassFactory>
-    {
-        STDMETHODIMP CreateInstance(::IUnknown* outer, REFIID riid, void** result) noexcept override
-        {
-            if (result == nullptr)
-            {
-                return E_POINTER;
-            }
-
-            *result = nullptr;
-
-            if (outer != nullptr)
-            {
-                return CLASS_E_NOAGGREGATION;
-            }
-
-            try
-            {
-                return winrt::make<LottieCompositionLoader>()->QueryInterface(riid, result);
-            }
-            catch (...)
-            {
-                return winrt::to_hresult();
-            }
-        }
-
-        STDMETHODIMP LockServer(BOOL lock) noexcept override
-        {
-            if (lock)
-            {
-                ++winrt::get_module_lock();
-            }
-            else
-            {
-                --winrt::get_module_lock();
-            }
-
-            return S_OK;
-        }
-    };
-}
-
-extern "C" HRESULT __stdcall DllGetClassObject(REFCLSID rclsid, REFIID riid, void** result)
-{
-    if (result == nullptr)
-    {
-        return E_POINTER;
-    }
-
-    *result = nullptr;
-
-    if (rclsid != CLSID_LottieCompositionLoader)
-    {
-        return CLASS_E_CLASSNOTAVAILABLE;
-    }
-
-    try
-    {
-        return winrt::make<ClassFactory>()->QueryInterface(riid, result);
-    }
-    catch (...)
-    {
-        return winrt::to_hresult();
-    }
-}
-
-extern "C" HRESULT __stdcall DllCanUnloadNow()
-{
-    return winrt::get_module_lock() == 0 ? S_OK : S_FALSE;
-}
diff --git a/dlls/LottieRuntime/LottieRuntimeCom.h b/dlls/LottieRuntime/LottieRuntimeCom.h
deleted file mode 100644
index d4997a9d..00000000
--- a/dlls/LottieRuntime/LottieRuntimeCom.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#pragma once
-
-#include <unknwn.h>
-#include <Windows.h>
-
-// COM interface for DLL activation. LottieRuntime.manifest declares the class for
-// registration-free COM activation.
-//
-// riid selects the interface returned for the root Visual.
-MIDL_INTERFACE("3874B71B-05E6-42A9-B838-1AE7F0BA4E1C")
-ILottieCompositionLoader : public IUnknown
-{
-public:
-    // buffer contains LottieGen -Language flatbuffer output. Validation precedes
-    // every read; malformed data returns E_INVALIDARG.
-    STDMETHOD(LoadComposition)(UINT32 length, BYTE const* buffer, REFIID riid, void** result) = 0;
-};
-
-// Registration-free clients do not link an import library.
-constexpr CLSID CLSID_LottieCompositionLoader = {
-    0x9f7b7089, 0xf512, 0x4bbc, { 0x81, 0xfe, 0x4f, 0xf1, 0x2b, 0x4d, 0xa1, 0x59 } };
diff --git a/dlls/LottieRuntime/README.md b/dlls/LottieRuntime/README.md
deleted file mode 100644
index ac9a5d20..00000000
--- a/dlls/LottieRuntime/README.md
+++ /dev/null
@@ -1,180 +0,0 @@
-# LottieRuntime
-
-A native runtime interpreter for Lottie animations.
-
-`LottieRuntime` builds a `Windows.UI.Composition` visual tree from a serialized
-composition. The DLL consumes FlatBuffer data through a classic COM interface.
-Applications can also link the implementation directly.
-
-## How it fits in
-
-Lottie-Windows already turns a Lottie file into a `WinCompData` graph, which is a
-description of a composition tree. Three consumers use that graph:
-
-| Consumer | When it runs | Cost |
-| --- | --- | --- |
-| `Instantiator` | Runtime, in the app | Ships the whole JSON reader and translator |
-| `LottieGen` code generators | Build time | No runtime cost, but one class per animation |
-| `LottieRuntime` | Runtime, in the app | One interpreter shared by every animation |
-
-`CompositionSerializer` writes the `WinCompData` graph into a
-FlatBuffer at build time, and `LottieRuntime` reads that buffer at runtime. The
-animation stays data, so it can be swapped, downloaded or themed without a rebuild,
-and the code that reads it is the same size no matter how many animations an
-application has.
-
-```
-Lottie JSON --> LottieCompositionReader --> LottieData
-                                              |
-                                              v
-                                       LottieToWinComp
-                                              |
-                                              v
-                                        WinCompData graph
-                                        /      |        \
-                                       /       |         \
-                              Instantiator  UIDataCodeGen  CompositionSerializer
-                              (runtime C#)   (C#/C++/CX)          |
-                                                                  v
-                                                            .lcomp buffer
-                                                                  |
-                                                                  v
-                                                            LottieRuntime
-                                                            (runtime C++)
-```
-
-Because the FlatBuffer is written from the same graph the other two consume, all
-three produce the same visual tree. The round trip tests in
-`tests/CompDataFlatbuffer.Tests` assert exactly that.
-
-## Producing a buffer
-
-```
-LottieGen -InputFile animation.json -Language flatbuffer -OutputFolder .
-```
-
-This writes `Animation.lcomp`. The format is described by
-[`source/LottieFlatbuffer/lottie_comp.fbs`](../../source/LottieFlatbuffer/lottie_comp.fbs).
-
-## Using the DLL
-
-```cpp
-#include <LottieRuntimeCom.h>
-
-auto bytes = ReadFileBytes(L"Animation.lcomp");
-winrt::com_ptr<ILottieCompositionLoader> loader;
-winrt::check_hresult(CoCreateInstance(
-    CLSID_LottieCompositionLoader,
-    nullptr,
-    CLSCTX_INPROC_SERVER,
-    __uuidof(ILottieCompositionLoader),
-    loader.put_void()));
-
-winrt::Windows::UI::Composition::Visual root{ nullptr };
-winrt::check_hresult(loader->LoadComposition(
-    static_cast<UINT32>(bytes.size()),
-    reinterpret_cast<BYTE const*>(bytes.data()),
-    winrt::guid_of<decltype(root)>(),
-    winrt::put_abi(root)));
-```
-
-`LottieRuntime.manifest` declares the private COM assembly. Activate that manifest
-before `CoCreateInstance`; `LottieRuntime.exe` contains the complete activation
-sequence. No system registration is required. The calling thread must own a
-`DispatcherQueue` that outlives the returned visual tree.
-
-`LottieRuntime.h` is the C++ API for applications linking the implementation
-directly. It is not exported by `LottieRuntime.dll`.
-
-## Design
-
-**Least derived interfaces.** A node's concrete type is known only inside the
-function that creates it. The realization caches hold `Visual`,
-`CompositionShape`, `CompositionBrush`, `CompositionGeometry` and so on, and every
-call the interpreter makes afterwards is declared on those types. There is no point
-at which the interpreter asks what a node actually is, because the buffer already
-said, and the answer was consumed at the moment of creation. The one exception is
-`ObjectCategory::Surface` in an object reference, where the buffer permits an image
-surface that is not a `CompositionObject`; that is a validation check, not a
-downcast in the normal path.
-
-**Size first.** There is one function per node *category*, not per node type, and
-the state shared by every node is applied by a single function that takes
-`CompositionObject`. Everything is in one translation unit, so `/OPT:REF` discards
-the code for whatever an application never reaches.
-
-**Runtime cost second.** Each node and string is realized at most once. Lookups use
-O(1) bounds-checked array indexing into the FlatBuffer's node vectors. The buffer
-is read in place; no intermediate object model is built.
-
-**Transient memory third.** Realization caches are dense vectors matching the
-FlatBuffer's node vectors. D2D geometries are cached while the graph is built so
-shared geometry remains shared and cycles are rejected.
-
-**Untrusted input.** A buffer may have come from a file or a download. It is checked
-for the `LCMP` identifier, run through the FlatBuffers verifier, and every index
-read out of it is range checked. A malformed buffer throws
-`winrt::hresult_invalid_argument`; it never reads outside the buffer. The declared
-Universal API contract is checked before graph hydration.
-
-## Dependencies
-
-Direct2D, for path geometry, and the composition effect interop interface, for the
-two effects the translator emits. There is no dependency on Win2D: the interpreter
-implements `IGeometrySource2DInterop` and `IGraphicsEffectD2D1Interop` itself, which
-is a few dozen lines and avoids pulling a large component into every application.
-
-The FlatBuffers C++ headers come from the pinned `external/flatbuffers` submodule.
-The checked-in C++ binding is generated by `flatc` from that commit. The checked-in
-C# binding remains on `Google.FlatBuffers` 25.2.10 from Microsoft's configured
-NuGet source. `build/RegenerateFlatbuffers.ps1` validates both generator versions.
-
-## Incorporate it in a build
-
-`LottieGen.nupkg` contains the complete native source set under
-`LottieRuntime/`.
-
-### C++/WinRT
-
-Add `LottieRuntime.cpp` to the consuming native project. Add `LottieRuntime/`
-and `LottieRuntime/flatbuffers/include/` to its include paths. Build as C++20
-and link:
-
-```text
-d2d1.lib
-dxguid.lib
-shcore.lib
-shlwapi.lib
-windowsapp.lib
-```
-
-Include `LottieRuntime.h` and call `LoadComposition` with the application's
-`Compositor`. This direct-link path does not use COM activation.
-
-### Managed applications
-
-A managed application can also use the C# interpreter in
-[`source/LottieRuntime`](../../source/LottieRuntime/README.md), which reads the same
-buffer and performs the same validation, and needs no COM activation. Use the DLL
-instead when the application should not take a Win2D dependency, or when the same
-animation is loaded from both native and managed code.
-
-Add the packaged `LottieRuntime.vcxproj` to the solution. The project builds
-`LottieRuntime.dll`, including the `ILottieCompositionLoader` implementation.
-Copy both files into every managed application output directory:
-
-```text
-LottieRuntime.dll
-LottieRuntime.manifest
-```
-
-The managed application activates `LottieRuntime.manifest`, calls
-`CoCreateInstance(CLSID_LottieCompositionLoader)`, and invokes
-`ILottieCompositionLoader::LoadComposition`. The calling thread owns the
-`DispatcherQueue` for the lifetime of the returned visual tree.
-
-## Status
-
-Debug and Release x64 builds are supported. `LottieRuntime.exe` validates, dumps,
-or displays a composition through registration-free activation.
-`tests/CompDataFlatbuffer.Tests` verifies serializer round trips.
diff --git a/dlls/LottieRuntimeTool/README.md b/dlls/LottieRuntimeTool/README.md
deleted file mode 100644
index 289bbf05..00000000
--- a/dlls/LottieRuntimeTool/README.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# LottieRuntime tool
-
-`LottieRuntime.exe` loads FlatBuffer compositions through the registration-free
-`ILottieCompositionLoader` COM interface.
-
-## Build
-
-```powershell
-& "C:\Program Files\Microsoft Visual Studio\18\Professional\Common7\Tools\Launch-VsDevShell.ps1" -SkipAutomaticLocation
-msbuild .\dlls\LottieRuntimeTool\LottieRuntime.vcxproj /p:Platform=x64 /p:Configuration=Release
-```
-
-The executable is written to:
-
-```text
-dlls\LottieRuntimeTool\x64\Release\LottieRuntime.exe
-```
-
-## Convert Lottie JSON
-
-```powershell
-$output = Join-Path $env:TEMP "lottie-runtime"
-New-Item -ItemType Directory -Force $output | Out-Null
-
-dotnet run --project .\LottieGen\DotnetTool\LottieGen.csproj -- `
-    -InputFile .\LottieSamples\Assets\LottieLogo1.json `
-    -Language flatbuffer `
-    -OutputFolder $output
-```
-
-The command writes `$output\LottieLogo1.lcomp`.
-
-## Load, inspect, or display
-
-Validate the composition:
-
-```powershell
-.\dlls\LottieRuntimeTool\x64\Release\LottieRuntime.exe `
-    "$output\LottieLogo1.lcomp"
-```
-
-Print the interpreted Composition object hierarchy:
-
-```powershell
-.\dlls\LottieRuntimeTool\x64\Release\LottieRuntime.exe `
-    "$output\LottieLogo1.lcomp" --dump
-```
-
-Display and animate the interpreted visual:
-
-```powershell
-.\dlls\LottieRuntimeTool\x64\Release\LottieRuntime.exe `
-    "$output\LottieLogo1.lcomp" --show
-```
diff --git a/dlls/README.md b/dlls/README.md
index 6e09e866..e795c3ae 100644
--- a/dlls/README.md
+++ b/dlls/README.md
@@ -25,11 +25,3 @@ But we don't actually use the DLLs in any of the other projects; instead, we mus
 ### Summary
 * Shared projects give us the equivalent of C++ static libs.
 * The dlls directory enforces modularity.
-
-## LottieRuntime
-
-`LottieRuntime` is the exception to everything above. It is a real C++ DLL that an
-application is meant to consume, rather than a modularity check, and it is not part
-of `Lottie-Windows.sln` because it needs the C++ toolset and the FlatBuffers headers.
-It reads the serialized form of a `WinCompData` graph and builds the composition
-tree at runtime. See [LottieRuntime/README.md](LottieRuntime/README.md).
diff --git a/source/LottieFlatbuffer/README.md b/source/LottieFlatbuffer/README.md
index d5547614..c07d70e3 100644
--- a/source/LottieFlatbuffer/README.md
+++ b/source/LottieFlatbuffer/README.md
@@ -70,6 +70,11 @@ package. Both are currently 25.2.10.
 | --- | --- |
 | `source/CompDataFlatbuffer/CompositionSerializer.cs` | Writes a graph |
 | `source/CompDataFlatbuffer/CompositionDeserializer.cs` | Reads one back, in C# |
-| `dlls/LottieRuntime` | Reads one back, in C++/WinRT |
+| `source/LottieRuntime` | Reads one back using statically compiled WinUI 2 or WinUI 3 C++/WinRT source |
 | `LottieGen -Language flatbuffer` | Produces a `.lcomp` file |
 | `tests/CompDataFlatbuffer.Tests` | Asserts a graph survives the round trip unchanged |
+
+When the requested UAP range needs different translated graphs, LottieGen writes
+one `.lcomp` file per range. The file names contain the supported range, such as
+`.uap12-plus.lcomp` or `.uap7-11.lcomp`; the consumer selects the appropriate
+variant before calling the native reader.
diff --git a/source/LottieGen/LottieJsonFileProcessor.cs b/source/LottieGen/LottieJsonFileProcessor.cs
index e778c86c..d21b5726 100644
--- a/source/LottieGen/LottieJsonFileProcessor.cs
+++ b/source/LottieGen/LottieJsonFileProcessor.cs
@@ -438,31 +438,68 @@ bool TryGenerateFlatbuffer(LottieComposition lottieComposition, string outputFil
                 return false;
             }
 
-            // NOTE: this only writes the latest version of a multi-version translation.
-            var translationResult = _translationResults[0];
-            var sourceMetadata = new SourceMetadata(translationResult.SourceMetadata);
-            var result = TryWriteBinaryFile(
-                outputFilePath,
-                CompositionSerializer.Serialize(
-                    translationResult.RootVisual!,
-                    checked((ushort)translationResult.MinimumRequiredUapVersion),
-                    sourceMetadata.LottieMetadata,
-                    sourceMetadata.PropertyBindings,
-                    (float)lottieComposition.Width,
-                    (float)lottieComposition.Height));
+            var result = true;
+            var maximumUapVersion = _options.TargetUapVersion ?? uint.MaxValue;
+
+            for (var i = 0; i < _translationResults.Count; i++)
+            {
+                var translationResult = _translationResults[i];
+                var sourceMetadata = new SourceMetadata(translationResult.SourceMetadata);
+                var minimumUapVersion = translationResult.MinimumRequiredUapVersion;
+                var maximumVariantUapVersion = i == 0
+                    ? maximumUapVersion
+                    : _translationResults[i - 1].MinimumRequiredUapVersion - 1;
+                var variantPath = _translationResults.Count == 1
+                    ? outputFilePath
+                    : GetFlatbufferVariantPath(
+                        outputFilePath,
+                        minimumUapVersion,
+                        maximumVariantUapVersion);
+
+                if (!TryWriteBinaryFile(
+                    variantPath,
+                    CompositionSerializer.Serialize(
+                        translationResult.RootVisual!,
+                        checked((ushort)minimumUapVersion),
+                        sourceMetadata.LottieMetadata,
+                        sourceMetadata.PropertyBindings,
+                        (float)lottieComposition.Width,
+                        (float)lottieComposition.Height)))
+                {
+                    result = false;
+                    continue;
+                }
 
-            if (result)
-            {
                 using (_reporter.InfoStream.Lock())
                 {
-                    _reporter.WriteInfo($"Flatbuffer data for class {_className} written to:");
-                    _reporter.WriteInfo(InfoType.FilePath, $" {outputFilePath}");
+                    _reporter.WriteInfo(
+                        $"Flatbuffer data for class {_className}, UAP versions " +
+                        (maximumVariantUapVersion == uint.MaxValue
+                            ? $"{minimumUapVersion} and later"
+                            : $"{minimumUapVersion} through {maximumVariantUapVersion}") +
+                        ", written to:");
+                    _reporter.WriteInfo(InfoType.FilePath, $" {variantPath}");
                 }
             }
 
             return result;
         }
 
+        static string GetFlatbufferVariantPath(
+            string outputFilePath,
+            uint minimumUapVersion,
+            uint maximumUapVersion)
+        {
+            var directory = System.IO.Path.GetDirectoryName(outputFilePath);
+            var fileName = System.IO.Path.GetFileNameWithoutExtension(outputFilePath);
+            var extension = System.IO.Path.GetExtension(outputFilePath);
+            var range = maximumUapVersion == uint.MaxValue
+                ? $"uap{minimumUapVersion}-plus"
+                : $"uap{minimumUapVersion}-{maximumUapVersion}";
+
+            return System.IO.Path.Combine(directory ?? string.Empty, $"{fileName}.{range}{extension}");
+        }
+
         bool TryGenerateWincompDgml(
             LottieComposition lottieComposition,
             string outputFilePath)
@@ -861,7 +898,15 @@ bool TryEnsureTranslated(LottieComposition lottieComposition)
             var translationResult = LottieToMultiVersionWinCompTranslator.TryTranslateLottieComposition(
                 lottieComposition: lottieComposition,
                 configuration: configuration,
-                minimumUapVersion: _options.WinUIVersion.Major >= 3 ? uint.MaxValue : _minimumUapVersion);
+                minimumUapVersion:
+                    _options.WinUIVersion.Major < 3 ||
+                    !_options.Languages.Any(
+                        language =>
+                            language == Language.CSharp ||
+                            language == Language.Cx ||
+                            language == Language.Cppwinrt)
+                        ? _minimumUapVersion
+                        : uint.MaxValue);
 
             _translationResults = translationResult.TranslationResults;
             _translationIssues = translationResult.Issues;
diff --git a/source/LottieGenExe/Main.cs b/source/LottieGenExe/Main.cs
index 4fe843e2..7b2cfe5e 100644
--- a/source/LottieGenExe/Main.cs
+++ b/source/LottieGenExe/Main.cs
@@ -75,10 +75,18 @@ RunResult Run()
                 _reporter.ErrorStream.WriteLine(_options.ErrorDescription);
                 return RunResult.InvalidUsage;
             }
-            else if (_options.WinUIVersion.Major >= 3 && (_options.MinimumUapVersion.HasValue || _options.TargetUapVersion.HasValue))
+            else if (
+                _options.WinUIVersion.Major >= 3 &&
+                _options.Languages.Any(
+                    language =>
+                        language == Language.CSharp ||
+                        language == Language.Cx ||
+                        language == Language.Cppwinrt) &&
+                (_options.MinimumUapVersion.HasValue || _options.TargetUapVersion.HasValue))
             {
-                // WinUI3 does not permit setting a minimum or target version because WinUI3 implies
-                // the latest version only.
+                // WinUI3 source code implies the latest version only. FlatBuffer output is
+                // projection-neutral, so it can still request a UAP range for consumers
+                // that select the matching data variant.
                 _reporter.WriteError($"WinUI versions of 3 and above cannot be used with {nameof(_options.MinimumUapVersion)} or {nameof(_options.TargetUapVersion)}.");
                 return RunResult.InvalidUsage;
             }
diff --git a/source/LottieRuntime/CompositionInterpreter.cs b/source/LottieRuntime/CompositionInterpreter.cs
deleted file mode 100644
index b7071b40..00000000
--- a/source/LottieRuntime/CompositionInterpreter.cs
+++ /dev/null
@@ -1,1828 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#nullable enable
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Numerics;
-using System.Runtime.InteropServices.WindowsRuntime;
-using CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer;
-using Google.FlatBuffers;
-using Microsoft.Graphics.Canvas.Geometry;
-using Windows.Foundation.Metadata;
-using Windows.Graphics.Effects;
-using Fb = CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema;
-using Mgc = Microsoft.Graphics.Canvas;
-using Mgce = Microsoft.Graphics.Canvas.Effects;
-#if WINAPPSDK
-using Wc = Microsoft.UI.Composition;
-using Wm = Microsoft.UI.Xaml.Media;
-#else
-using Wc = Windows.UI.Composition;
-using Wm = Windows.UI.Xaml.Media;
-#endif
-using Wui = Windows.UI;
-
-namespace CommunityToolkit.WinUI.Lottie.LottieRuntime
-{
-    /// <summary>
-    /// Builds a <see cref="Wc.Visual"/> tree directly from a serialized composition.
-    /// </summary>
-    /// <remarks>
-    /// This is the managed counterpart of the native interpreter in
-    /// <c>dlls/LottieRuntime</c>. Both read the same FlatBuffer and build the same
-    /// visual tree, and both are structured the same way, so that a change to the
-    /// format only ever has to be made twice rather than in a different shape each
-    /// time.
-    /// <para/>
-    /// It differs from <c>Instantiator</c> in that it never builds a WinCompData
-    /// graph: the buffer is read in place and the composition objects are created as
-    /// the walk reaches them. That makes an animation data rather than code, so it can
-    /// be downloaded, themed or swapped without a rebuild, and the amount of code in
-    /// the application does not grow with the number of animations.
-    /// <para/>
-    /// A buffer is untrusted input. It is checked for the <c>LCMP</c> identifier, run
-    /// through the FlatBuffers verifier, and every index read out of it is range
-    /// checked. A malformed buffer is reported as a
-    /// <see cref="FlatBufferFormatException"/>; a buffer that needs something this
-    /// build cannot provide is reported as a <see cref="NotSupportedException"/>.
-    /// Neither reads outside the buffer.
-    /// </remarks>
-#if PUBLIC_LottieRuntime
-    public
-#endif
-    sealed class CompositionInterpreter
-    {
-        // The smallest buffer that could possibly be a composition: a root offset
-        // followed by the four byte file identifier. Checked before the identifier is
-        // read so that a short buffer is reported as a format error.
-        const int MinimumBufferLength = 8;
-
-        readonly Wc.Compositor _compositor;
-        readonly Fb.LottieComposition _root;
-        readonly string[] _strings;
-
-        // Realization caches. These are indexed identically to the node vectors in the
-        // buffer, so looking up an already realized node is an array index rather than
-        // a hash lookup, and a node that is reached by more than one path is realized
-        // exactly once. Each holds the least derived type that a reference to that
-        // category needs, which is what keeps the interpreter free of downcasts.
-        readonly Wc.Visual?[] _visuals;
-        readonly Wc.CompositionShape?[] _shapes;
-        readonly Wc.CompositionGeometry?[] _geometries;
-        readonly CanvasGeometry?[] _canvasGeometries;
-        readonly CanvasGeometryState[] _canvasGeometryStates;
-        readonly Wc.CompositionBrush?[] _brushes;
-        readonly Wc.CompositionColorGradientStop?[] _gradientStops;
-        readonly Wc.CompositionViewBox?[] _viewBoxes;
-        readonly Wc.CompositionClip?[] _clips;
-        readonly Wc.CompositionShadow?[] _shadows;
-        readonly Wc.ICompositionSurface?[] _surfaces;
-        readonly IGraphicsEffect?[] _effects;
-        readonly Wc.CompositionEasingFunction?[] _easings;
-        readonly Wc.CompositionAnimation?[] _animations;
-        readonly Wc.CompositionPropertySet?[] _propertySets;
-        readonly Wc.AnimationController?[] _controllers;
-
-        CompositionInterpreter(Wc.Compositor compositor, Fb.LottieComposition root)
-        {
-            _compositor = compositor;
-            _root = root;
-
-            _strings = new string[root.StringsLength];
-            for (var i = 0; i < _strings.Length; i++)
-            {
-                _strings[i] = root.Strings(i) ?? string.Empty;
-            }
-
-            _visuals = new Wc.Visual?[root.VisualsLength];
-            _shapes = new Wc.CompositionShape?[root.ShapesLength];
-            _geometries = new Wc.CompositionGeometry?[root.GeometriesLength];
-            _canvasGeometries = new CanvasGeometry?[root.CanvasGeometriesLength];
-            _canvasGeometryStates = new CanvasGeometryState[root.CanvasGeometriesLength];
-            _brushes = new Wc.CompositionBrush?[root.BrushesLength];
-            _gradientStops = new Wc.CompositionColorGradientStop?[root.GradientStopsLength];
-            _viewBoxes = new Wc.CompositionViewBox?[root.ViewBoxesLength];
-            _clips = new Wc.CompositionClip?[root.ClipsLength];
-            _shadows = new Wc.CompositionShadow?[root.ShadowsLength];
-            _surfaces = new Wc.ICompositionSurface?[root.SurfacesLength];
-            _effects = new IGraphicsEffect?[root.EffectsLength];
-            _easings = new Wc.CompositionEasingFunction?[root.EasingsLength];
-            _animations = new Wc.CompositionAnimation?[root.AnimationsLength];
-            _propertySets = new Wc.CompositionPropertySet?[root.PropertySetsLength];
-            _controllers = new Wc.AnimationController?[root.ControllersLength];
-        }
-
-        // A canvas geometry is built from other canvas geometries, so the walk has to
-        // be able to tell a shared geometry from a cycle.
-        enum CanvasGeometryState
-        {
-            Unrealized,
-            Realizing,
-            Realized,
-        }
-
-        /// <summary>
-        /// Builds the visual tree described by a serialized composition.
-        /// </summary>
-        /// <param name="compositor">The compositor that creates the objects.</param>
-        /// <param name="bytes">A buffer produced by <c>CompositionSerializer</c>.</param>
-        /// <returns>The root of the visual tree.</returns>
-        /// <exception cref="FlatBufferFormatException">The buffer is not a well formed composition.</exception>
-        /// <exception cref="NotSupportedException">The composition needs a newer schema or a newer version of Windows.</exception>
-        public static Wc.Visual LoadComposition(Wc.Compositor compositor, byte[] bytes)
-        {
-            if (bytes is null)
-            {
-                throw new ArgumentNullException(nameof(bytes));
-            }
-
-            return LoadComposition(compositor, new ByteBuffer(bytes), bytes.Length);
-        }
-
-        /// <summary>
-        /// Builds the visual tree described by a serialized composition.
-        /// </summary>
-        /// <param name="compositor">The compositor that creates the objects.</param>
-        /// <param name="bytes">A buffer produced by <c>CompositionSerializer</c>.</param>
-        /// <returns>The root of the visual tree.</returns>
-        /// <exception cref="FlatBufferFormatException">The buffer is not a well formed composition.</exception>
-        /// <exception cref="NotSupportedException">The composition needs a newer schema or a newer version of Windows.</exception>
-        public static Wc.Visual LoadComposition(Wc.Compositor compositor, ReadOnlySpan<byte> bytes)
-            => LoadComposition(compositor, new ByteBuffer(bytes.ToArray()), bytes.Length);
-
-        static Wc.Visual LoadComposition(Wc.Compositor compositor, ByteBuffer buffer, int length)
-        {
-            if (compositor is null)
-            {
-                throw new ArgumentNullException(nameof(compositor));
-            }
-
-            // The buffer is untrusted, so nothing is read out of it until the verifier
-            // has agreed that every offset in it is inside it.
-            if (length < MinimumBufferLength ||
-                !Fb.LottieComposition.LottieCompositionBufferHasIdentifier(buffer))
-            {
-                throw new FlatBufferFormatException("The buffer is not a composition.");
-            }
-
-            Fb.LottieComposition root;
-
-            // Verification proves that the buffer is structurally sound, but it cannot
-            // prove that the indices stored in it point at the right things. Neither
-            // the verifier nor the reader reports a malformed buffer purely by
-            // returning false; both also throw. Everything that reads the buffer is
-            // therefore done inside a handler, so that a corrupt buffer always surfaces
-            // as a format error and never as an exception that a caller could not have
-            // anticipated.
-            try
-            {
-                if (!Fb.LottieComposition.VerifyLottieComposition(buffer))
-                {
-                    throw new FlatBufferFormatException("The buffer is not a valid composition.");
-                }
-
-                root = Fb.LottieComposition.GetRootAsLottieComposition(buffer);
-            }
-            catch (Exception e) when (IsBufferFailure(e))
-            {
-                throw new FlatBufferFormatException("The buffer is malformed.", e);
-            }
-
-            // A newer schema may store things in fields this build does not read, so a
-            // buffer that declares one is refused rather than silently misinterpreted.
-            if (root.SchemaVersion > Format.Version)
-            {
-                throw new NotSupportedException(
-                    $"Schema version {root.SchemaVersion} is newer than the supported version {Format.Version}.");
-            }
-
-            // The translator records the API contract that the graph needs. Checking it
-            // before anything is created means that an animation which cannot run on
-            // this version of Windows is refused rather than half built.
-            var requiredUapVersion = root.RequiredUapVersion;
-            if (requiredUapVersion != 0 &&
-                !ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", requiredUapVersion))
-            {
-                throw new NotSupportedException(
-                    $"The composition requires UniversalApiContract {requiredUapVersion}.");
-            }
-
-            try
-            {
-                var interpreter = new CompositionInterpreter(compositor, root);
-
-                return interpreter.GetVisual(root.RootVisual)
-                    ?? throw new FlatBufferFormatException("The composition has no root visual.");
-            }
-            catch (Exception e) when (IsBufferFailure(e))
-            {
-                throw new FlatBufferFormatException("The buffer is malformed.", e);
-            }
-        }
-
-        /// <summary>
-        /// Returns the property set that drives an interpreted composition.
-        /// </summary>
-        /// <param name="root">A root returned by <c>LoadComposition</c>.</param>
-        /// <returns>The property set that holds the animation's Progress property.</returns>
-        public static Wc.CompositionPropertySet ProgressPropertySet(Wc.Visual root)
-        {
-            if (root is null)
-            {
-                throw new ArgumentNullException(nameof(root));
-            }
-
-            return root.Properties;
-        }
-
-        // The failures that reading a structurally valid but semantically wrong buffer
-        // can produce. Reading past the end of the buffer is not a safety problem
-        // because ByteBuffer is bounds checked; the only thing being corrected here is
-        // the type of the exception.
-        static bool IsBufferFailure(Exception e)
-            => e is ArgumentException or IndexOutOfRangeException or
-                    InvalidOperationException or OverflowException or
-                    FormatException or NullReferenceException;
-
-        // ---------------------------------------------------------------------
-        // Table accessors. Every index is bounds checked, because a buffer that
-        // passes verification can still contain an out of range index.
-        // ---------------------------------------------------------------------
-        static T Require<T>(T? value, string what)
-            where T : struct
-            => value ?? throw new FlatBufferFormatException($"A {what} is missing.");
-
-        static uint RequireIndex(uint index, string what)
-            => index != Format.NullIndex
-                ? index
-                : throw new FlatBufferFormatException($"A required {what} is missing.");
-
-        string? GetString(uint index)
-            => index == Format.NullIndex
-                ? null
-                : index < (uint)_strings.Length
-                    ? _strings[index]
-                    : throw new FlatBufferFormatException($"String index {index} is out of range.");
-
-        string GetRequiredString(uint index)
-            => GetString(index) ?? throw new FlatBufferFormatException("A required string is missing.");
-
-        // ---------------------------------------------------------------------
-        // Shared state.
-        // ---------------------------------------------------------------------
-        // Applies the state that every CompositionObject has. Called after the object
-        // has been placed in its realization cache, so that a cycle terminates.
-        void InitializeCompositionObject(Wc.CompositionObject target, Fb.CompObj? source)
-        {
-            if (source is null)
-            {
-                return;
-            }
-
-            var value = source.Value;
-
-            if (GetString(value.Comment) is string comment)
-            {
-                target.Comment = comment;
-            }
-
-            // The property set is realized through the object that owns it, so that the
-            // owner and its property set can never both create it.
-            if (value.Properties != Format.NullIndex)
-            {
-                RealizePropertySet(value.Properties, target.Properties);
-            }
-
-            // Animations are started last, because setting a property stops any
-            // animation that is running on it.
-            for (var i = 0; i < value.AnimatorsLength; i++)
-            {
-                var animator = Require(value.Animators(i), "animator");
-                var property = GetRequiredString(animator.Property);
-                var animation = GetAnimation(animator.Animation)
-                    ?? throw new FlatBufferFormatException($"Animator '{property}' has no animation.");
-
-                // A non custom controller comes into existence when the animation is
-                // started, so only a custom one is passed in. Either way the resulting
-                // controller is cached under the index that the buffer gave it.
-                var controllerIndex = animator.Controller;
-                var customController = controllerIndex != Format.NullIndex && IsCustomController(controllerIndex)
-                    ? GetController(controllerIndex)
-                    : null;
-
-                // An expression animation is driven by its inputs and so cannot have a
-                // controller. This is checked here in order to reject the buffer rather
-                // than build an unusable tree.
-                if (customController is not null && animation is Wc.ExpressionAnimation)
-                {
-                    throw new FlatBufferFormatException(
-                        $"Animator '{property}' gives a controller to an expression animation.");
-                }
-
-                if (customController is null)
-                {
-                    target.StartAnimation(property, animation);
-                }
-                else
-                {
-                    target.StartAnimation(property, animation, customController);
-                }
-
-                if (controllerIndex != Format.NullIndex && customController is null)
-                {
-                    RealizeController(
-                        controllerIndex,
-                        target.TryGetAnimationController(property)
-                        ?? throw new FlatBufferFormatException($"Animator '{property}' has no controller."));
-                }
-            }
-        }
-
-        bool IsCustomController(uint index)
-            => GetControllerTable(index).IsCustom;
-
-        Fb.Controller GetControllerTable(uint index)
-            => index < (uint)_controllers.Length
-                ? Require(_root.Controllers((int)index), "controller")
-                : throw new FlatBufferFormatException($"Controller index {index} is out of range.");
-
-        void RealizeController(uint index, Wc.AnimationController controller)
-        {
-            if (_controllers[index] is not null)
-            {
-                return;
-            }
-
-            _controllers[index] = controller;
-
-            var table = GetControllerTable(index);
-
-            if (table.IsPaused)
-            {
-                controller.Pause();
-            }
-
-            InitializeCompositionObject(controller, table.Base);
-        }
-
-        Wc.AnimationController? GetController(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            var table = GetControllerTable(index);
-
-            if (_controllers[index] is null)
-            {
-                if (table.IsCustom)
-                {
-                    RealizeController(index, _compositor.CreateAnimationController());
-                }
-                else
-                {
-                    // A non custom controller comes into existence when its target
-                    // object starts the animation, so realizing the target realizes the
-                    // controller.
-                    GetObjectReference(table.TargetObject);
-                }
-            }
-
-            return _controllers[index]
-                ?? throw new FlatBufferFormatException($"Controller {index} could not be realized.");
-        }
-
-        // ---------------------------------------------------------------------
-        // Property sets.
-        // ---------------------------------------------------------------------
-        void RealizePropertySet(uint index, Wc.CompositionPropertySet propertySet)
-        {
-            if (index >= (uint)_propertySets.Length)
-            {
-                throw new FlatBufferFormatException($"Property set index {index} is out of range.");
-            }
-
-            if (_propertySets[index] is not null)
-            {
-                return;
-            }
-
-            // Cached before the values are applied, because a value may be an
-            // expression that refers back to this property set.
-            _propertySets[index] = propertySet;
-
-            var table = Require(_root.PropertySets((int)index), "property set");
-
-            for (var i = 0; i < table.ValuesLength; i++)
-            {
-                var value = Require(table.Values(i), "property value");
-                var name = GetRequiredString(value.Name);
-
-                switch (value.Type)
-                {
-                    case Fb.PropertyValueType.Color:
-                        propertySet.InsertColor(name, ToColor(Require(value.Color, "color")));
-                        break;
-                    case Fb.PropertyValueType.Scalar:
-                        propertySet.InsertScalar(name, value.Scalar);
-                        break;
-                    case Fb.PropertyValueType.Vector2:
-                        propertySet.InsertVector2(name, ToVector2(value.Vector));
-                        break;
-                    case Fb.PropertyValueType.Vector3:
-                        propertySet.InsertVector3(name, ToVector3(value.Vector));
-                        break;
-                    case Fb.PropertyValueType.Vector4:
-                        propertySet.InsertVector4(name, ToVector4(value.Vector));
-                        break;
-                    case Fb.PropertyValueType.None:
-                        break;
-                    default:
-                        throw new FlatBufferFormatException($"Unsupported property value type {value.Type}.");
-                }
-            }
-
-            InitializeCompositionObject(propertySet, table.Base);
-        }
-
-        Wc.CompositionPropertySet? GetPropertySet(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_propertySets.Length)
-            {
-                throw new FlatBufferFormatException($"Property set index {index} is out of range.");
-            }
-
-            if (_propertySets[index] is null)
-            {
-                var table = Require(_root.PropertySets((int)index), "property set");
-
-                if (table.Owner == Format.NullIndex)
-                {
-                    // A property set with no owner is a standalone one, which is how the
-                    // translator exposes theming properties.
-                    RealizePropertySet(index, _compositor.CreatePropertySet());
-                }
-                else
-                {
-                    // Realizing the owner realizes its property set as a side effect.
-                    GetObjectReference(table.Owner);
-                }
-            }
-
-            return _propertySets[index]
-                ?? throw new FlatBufferFormatException($"Property set {index} could not be realized.");
-        }
-
-        // Resolves a packed (category, index) reference. Only used by the fields that
-        // can point at an object of any category.
-        Wc.CompositionObject? GetObjectReference(uint reference)
-        {
-            if (reference == Format.NullIndex)
-            {
-                return null;
-            }
-
-            var category = Format.UnpackCategory(reference);
-            var index = (uint)Format.UnpackIndex(reference);
-
-            return category switch
-            {
-                Fb.ObjectCategory.Visual => GetVisual(index),
-                Fb.ObjectCategory.Shape => GetShape(index),
-                Fb.ObjectCategory.Geometry => GetGeometry(index),
-                Fb.ObjectCategory.Brush => GetBrush(index),
-                Fb.ObjectCategory.Animation => GetAnimation(index),
-                Fb.ObjectCategory.Easing => GetEasing(index),
-                Fb.ObjectCategory.PropertySet => GetPropertySet(index),
-
-                // Only a visual surface is a CompositionObject; an image surface is not,
-                // and nothing can legitimately reference one this way.
-                Fb.ObjectCategory.Surface => GetSurface(index) as Wc.CompositionObject
-                    ?? throw new FlatBufferFormatException("An image surface cannot be referenced."),
-                Fb.ObjectCategory.Clip => GetClip(index),
-                Fb.ObjectCategory.Controller => GetController(index),
-                Fb.ObjectCategory.Shadow => GetShadow(index),
-                Fb.ObjectCategory.GradientStop => GetGradientStop(index),
-                Fb.ObjectCategory.ViewBox => GetViewBox(index),
-                _ => throw new FlatBufferFormatException($"Unsupported object category {category}."),
-            };
-        }
-
-        // ---------------------------------------------------------------------
-        // Visuals.
-        // ---------------------------------------------------------------------
-        Wc.Visual? GetVisual(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_visuals.Length)
-            {
-                throw new FlatBufferFormatException($"Visual index {index} is out of range.");
-            }
-
-            if (_visuals[index] is Wc.Visual cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.Visuals((int)index), "visual");
-
-            // The concrete type is known only here. Everything below this point,
-            // including the recursive walk into the children, uses a base type.
-            Wc.ContainerVisual result = table.Kind switch
-            {
-                Fb.VisualKind.Shape => _compositor.CreateShapeVisual(),
-                Fb.VisualKind.Sprite => _compositor.CreateSpriteVisual(),
-                Fb.VisualKind.Layer => _compositor.CreateLayerVisual(),
-                Fb.VisualKind.Container => _compositor.CreateContainerVisual(),
-                _ => throw new FlatBufferFormatException($"Unsupported visual kind {table.Kind}."),
-            };
-
-            // Cached before anything it refers to is realized, so that a cycle
-            // terminates.
-            _visuals[index] = result;
-
-            if (table.BorderMode.HasValue)
-            {
-                result.BorderMode = (Wc.CompositionBorderMode)table.BorderMode.Value;
-            }
-
-            if (ToVector3(table.CenterPoint) is Vector3 centerPoint)
-            {
-                result.CenterPoint = centerPoint;
-            }
-
-            if (table.Clip != Format.NullIndex)
-            {
-                result.Clip = GetClip(table.Clip);
-            }
-
-            if (table.IsVisible.HasValue)
-            {
-                result.IsVisible = table.IsVisible.Value;
-            }
-
-            if (ToVector3(table.Offset) is Vector3 offset)
-            {
-                result.Offset = offset;
-            }
-
-            if (table.Opacity.HasValue)
-            {
-                result.Opacity = table.Opacity.Value;
-            }
-
-            if (table.RotationAngleInDegrees.HasValue)
-            {
-                result.RotationAngleInDegrees = table.RotationAngleInDegrees.Value;
-            }
-
-            if (ToVector3(table.RotationAxis) is Vector3 rotationAxis)
-            {
-                result.RotationAxis = rotationAxis;
-            }
-
-            if (ToVector3(table.Scale) is Vector3 scale)
-            {
-                result.Scale = scale;
-            }
-
-            if (ToVector2(table.Size) is Vector2 size)
-            {
-                result.Size = size;
-            }
-
-            if (ToMatrix4x4(table.TransformMatrix) is Matrix4x4 transformMatrix)
-            {
-                result.TransformMatrix = transformMatrix;
-            }
-
-            switch (result)
-            {
-                case Wc.ShapeVisual shapeVisual:
-                    for (var i = 0; i < table.ShapesLength; i++)
-                    {
-                        shapeVisual.Shapes.Add(
-                            GetShape(table.Shapes(i))
-                            ?? throw new FlatBufferFormatException("A shape is missing."));
-                    }
-
-                    if (table.ViewBox != Format.NullIndex)
-                    {
-                        shapeVisual.ViewBox = GetViewBox(table.ViewBox);
-                    }
-
-                    break;
-                case Wc.SpriteVisual spriteVisual:
-                    if (table.Brush != Format.NullIndex)
-                    {
-                        spriteVisual.Brush = GetBrush(table.Brush);
-                    }
-
-                    if (table.Shadow != Format.NullIndex)
-                    {
-                        spriteVisual.Shadow = GetShadow(table.Shadow);
-                    }
-
-                    break;
-                case Wc.LayerVisual layerVisual:
-                    if (table.Shadow != Format.NullIndex)
-                    {
-                        layerVisual.Shadow = GetShadow(table.Shadow);
-                    }
-
-                    break;
-            }
-
-            for (var i = 0; i < table.ChildrenLength; i++)
-            {
-                result.Children.InsertAtTop(
-                    GetVisual(table.Children(i))
-                    ?? throw new FlatBufferFormatException("A visual child is missing."));
-            }
-
-            InitializeCompositionObject(result, table.Base);
-            return result;
-        }
-
-        // ---------------------------------------------------------------------
-        // Shapes.
-        // ---------------------------------------------------------------------
-        Wc.CompositionShape? GetShape(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_shapes.Length)
-            {
-                throw new FlatBufferFormatException($"Shape index {index} is out of range.");
-            }
-
-            if (_shapes[index] is Wc.CompositionShape cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.Shapes((int)index), "shape");
-
-            Wc.CompositionShape result = table.Kind switch
-            {
-                Fb.ShapeKind.Sprite => _compositor.CreateSpriteShape(),
-                Fb.ShapeKind.Container => _compositor.CreateContainerShape(),
-                _ => throw new FlatBufferFormatException($"Unsupported shape kind {table.Kind}."),
-            };
-
-            _shapes[index] = result;
-
-            if (ToVector2(table.CenterPoint) is Vector2 centerPoint)
-            {
-                result.CenterPoint = centerPoint;
-            }
-
-            if (ToVector2(table.Offset) is Vector2 offset)
-            {
-                result.Offset = offset;
-            }
-
-            if (table.RotationAngleInDegrees.HasValue)
-            {
-                result.RotationAngleInDegrees = table.RotationAngleInDegrees.Value;
-            }
-
-            if (ToVector2(table.Scale) is Vector2 scale)
-            {
-                result.Scale = scale;
-            }
-
-            if (ToMatrix3x2(table.TransformMatrix) is Matrix3x2 transformMatrix)
-            {
-                result.TransformMatrix = transformMatrix;
-            }
-
-            switch (result)
-            {
-                case Wc.CompositionContainerShape containerShape:
-                    for (var i = 0; i < table.ShapesLength; i++)
-                    {
-                        containerShape.Shapes.Add(
-                            GetShape(table.Shapes(i))
-                            ?? throw new FlatBufferFormatException("A shape is missing."));
-                    }
-
-                    break;
-                case Wc.CompositionSpriteShape spriteShape:
-                    ApplySpriteShapeProperties(spriteShape, table);
-                    break;
-            }
-
-            InitializeCompositionObject(result, table.Base);
-            return result;
-        }
-
-        void ApplySpriteShapeProperties(Wc.CompositionSpriteShape target, Fb.Shape table)
-        {
-            if (table.FillBrush != Format.NullIndex)
-            {
-                target.FillBrush = GetBrush(table.FillBrush);
-            }
-
-            if (table.StrokeBrush != Format.NullIndex)
-            {
-                target.StrokeBrush = GetBrush(table.StrokeBrush);
-            }
-
-            if (table.Geometry != Format.NullIndex)
-            {
-                target.Geometry = GetGeometry(table.Geometry);
-            }
-
-            if (table.IsStrokeNonScaling.HasValue)
-            {
-                target.IsStrokeNonScaling = table.IsStrokeNonScaling.Value;
-            }
-
-            if (table.StrokeDashOffset.HasValue)
-            {
-                target.StrokeDashOffset = table.StrokeDashOffset.Value;
-            }
-
-            for (var i = 0; i < table.StrokeDashArrayLength; i++)
-            {
-                target.StrokeDashArray.Add(table.StrokeDashArray(i));
-            }
-
-            if (table.StrokeDashCap.HasValue)
-            {
-                target.StrokeDashCap = (Wc.CompositionStrokeCap)table.StrokeDashCap.Value;
-            }
-
-            if (table.StrokeStartCap.HasValue)
-            {
-                target.StrokeStartCap = (Wc.CompositionStrokeCap)table.StrokeStartCap.Value;
-            }
-
-            if (table.StrokeEndCap.HasValue)
-            {
-                target.StrokeEndCap = (Wc.CompositionStrokeCap)table.StrokeEndCap.Value;
-            }
-
-            if (table.StrokeLineJoin.HasValue)
-            {
-                target.StrokeLineJoin = (Wc.CompositionStrokeLineJoin)table.StrokeLineJoin.Value;
-            }
-
-            if (table.StrokeMiterLimit.HasValue)
-            {
-                target.StrokeMiterLimit = table.StrokeMiterLimit.Value;
-            }
-
-            if (table.StrokeThickness.HasValue)
-            {
-                target.StrokeThickness = table.StrokeThickness.Value;
-            }
-        }
-
-        // ---------------------------------------------------------------------
-        // Geometries.
-        // ---------------------------------------------------------------------
-        Wc.CompositionGeometry? GetGeometry(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_geometries.Length)
-            {
-                throw new FlatBufferFormatException($"Geometry index {index} is out of range.");
-            }
-
-            if (_geometries[index] is Wc.CompositionGeometry cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.Geometries((int)index), "geometry");
-
-            Wc.CompositionGeometry result = table.Kind switch
-            {
-                Fb.GeometryKind.Rectangle => _compositor.CreateRectangleGeometry(),
-                Fb.GeometryKind.RoundedRectangle => _compositor.CreateRoundedRectangleGeometry(),
-                Fb.GeometryKind.Ellipse => _compositor.CreateEllipseGeometry(),
-                Fb.GeometryKind.Path => _compositor.CreatePathGeometry(),
-                _ => throw new FlatBufferFormatException($"Unsupported geometry kind {table.Kind}."),
-            };
-
-            _geometries[index] = result;
-
-            if (table.TrimStart.HasValue)
-            {
-                result.TrimStart = table.TrimStart.Value;
-            }
-
-            if (table.TrimEnd.HasValue)
-            {
-                result.TrimEnd = table.TrimEnd.Value;
-            }
-
-            if (table.TrimOffset.HasValue)
-            {
-                result.TrimOffset = table.TrimOffset.Value;
-            }
-
-            switch (result)
-            {
-                case Wc.CompositionPathGeometry pathGeometry:
-                    var path = GetCanvasGeometry(table.Path);
-                    pathGeometry.Path = path is null ? null : new Wc.CompositionPath(path);
-                    break;
-                case Wc.CompositionRoundedRectangleGeometry roundedRectangle:
-                    if (ToVector2(table.Offset) is Vector2 roundedOffset)
-                    {
-                        roundedRectangle.Offset = roundedOffset;
-                    }
-
-                    if (ToVector2(table.Size) is Vector2 roundedSize)
-                    {
-                        roundedRectangle.Size = roundedSize;
-                    }
-
-                    roundedRectangle.CornerRadius = ToVector2(table.CornerRadius) ?? Vector2.Zero;
-                    break;
-                case Wc.CompositionRectangleGeometry rectangle:
-                    if (ToVector2(table.Offset) is Vector2 rectangleOffset)
-                    {
-                        rectangle.Offset = rectangleOffset;
-                    }
-
-                    if (ToVector2(table.Size) is Vector2 rectangleSize)
-                    {
-                        rectangle.Size = rectangleSize;
-                    }
-
-                    break;
-                case Wc.CompositionEllipseGeometry ellipse:
-                    ellipse.Center = ToVector2(table.Center) ?? Vector2.Zero;
-                    ellipse.Radius = ToVector2(table.Radius) ?? Vector2.Zero;
-                    break;
-            }
-
-            InitializeCompositionObject(result, table.Base);
-            return result;
-        }
-
-        // ---------------------------------------------------------------------
-        // Brushes.
-        // ---------------------------------------------------------------------
-        Wc.CompositionBrush? GetBrush(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_brushes.Length)
-            {
-                throw new FlatBufferFormatException($"Brush index {index} is out of range.");
-            }
-
-            if (_brushes[index] is Wc.CompositionBrush cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.Brushes((int)index), "brush");
-
-            Wc.CompositionBrush result;
-            switch (table.Kind)
-            {
-                case Fb.BrushKind.Color:
-                    result = _compositor.CreateColorBrush();
-                    break;
-                case Fb.BrushKind.LinearGradient:
-                    result = _compositor.CreateLinearGradientBrush();
-                    break;
-                case Fb.BrushKind.RadialGradient:
-                    result = _compositor.CreateRadialGradientBrush();
-                    break;
-                case Fb.BrushKind.Mask:
-                    result = _compositor.CreateMaskBrush();
-                    break;
-                case Fb.BrushKind.Surface:
-                    // The surface is needed in order to construct the brush, so it is
-                    // realized before the brush is placed in the cache.
-                    result = _compositor.CreateSurfaceBrush(
-                        GetSurface(RequireIndex(table.Surface, "surface"))
-                        ?? throw new FlatBufferFormatException("A surface brush has no surface."));
-                    break;
-                case Fb.BrushKind.Effect:
-                    var effect = GetEffect(RequireIndex(table.Effect, "effect"))
-                        ?? throw new FlatBufferFormatException("An effect brush has no effect.");
-                    result = _compositor.CreateEffectFactory(effect).CreateBrush();
-                    break;
-                default:
-                    throw new FlatBufferFormatException($"Unsupported brush kind {table.Kind}.");
-            }
-
-            _brushes[index] = result;
-
-            switch (result)
-            {
-                case Wc.CompositionColorBrush colorBrush:
-                    if (table.Color.HasValue)
-                    {
-                        colorBrush.Color = ToColor(table.Color.Value);
-                    }
-
-                    break;
-                case Wc.CompositionMaskBrush maskBrush:
-                    if (table.Source != Format.NullIndex)
-                    {
-                        maskBrush.Source = GetBrush(table.Source);
-                    }
-
-                    if (table.Mask != Format.NullIndex)
-                    {
-                        maskBrush.Mask = GetBrush(table.Mask);
-                    }
-
-                    break;
-                case Wc.CompositionEffectBrush effectBrush:
-                    for (var i = 0; i < table.SourceParametersLength; i++)
-                    {
-                        var parameter = Require(table.SourceParameters(i), "source parameter");
-                        effectBrush.SetSourceParameter(
-                            GetRequiredString(parameter.Name),
-                            GetBrush(parameter.Brush)
-                            ?? throw new FlatBufferFormatException("An effect source has no brush."));
-                    }
-
-                    break;
-            }
-
-            if (result is Wc.CompositionGradientBrush gradientBrush)
-            {
-                ApplyGradientBrushProperties(gradientBrush, table);
-            }
-
-            InitializeCompositionObject(result, table.Base);
-            return result;
-        }
-
-        void ApplyGradientBrushProperties(Wc.CompositionGradientBrush target, Fb.Brush table)
-        {
-            if (ToVector2(table.AnchorPoint) is Vector2 anchorPoint)
-            {
-                target.AnchorPoint = anchorPoint;
-            }
-
-            if (ToVector2(table.CenterPoint) is Vector2 centerPoint)
-            {
-                target.CenterPoint = centerPoint;
-            }
-
-            for (var i = 0; i < table.ColorStopsLength; i++)
-            {
-                target.ColorStops.Add(
-                    GetGradientStop(table.ColorStops(i))
-                    ?? throw new FlatBufferFormatException("A gradient stop is missing."));
-            }
-
-            if (table.ExtendMode.HasValue)
-            {
-                target.ExtendMode = (Wc.CompositionGradientExtendMode)table.ExtendMode.Value;
-            }
-
-            if (table.InterpolationSpace.HasValue)
-            {
-                target.InterpolationSpace = (Wc.CompositionColorSpace)table.InterpolationSpace.Value;
-            }
-
-            if (table.MappingMode.HasValue)
-            {
-                target.MappingMode = (Wc.CompositionMappingMode)table.MappingMode.Value;
-            }
-
-            if (ToVector2(table.Offset) is Vector2 offset)
-            {
-                target.Offset = offset;
-            }
-
-            if (table.RotationAngleInDegrees.HasValue)
-            {
-                target.RotationAngleInDegrees = table.RotationAngleInDegrees.Value;
-            }
-
-            if (ToVector2(table.Scale) is Vector2 scale)
-            {
-                target.Scale = scale;
-            }
-
-            if (ToMatrix3x2(table.TransformMatrix) is Matrix3x2 transformMatrix)
-            {
-                target.TransformMatrix = transformMatrix;
-            }
-
-            switch (target)
-            {
-                case Wc.CompositionLinearGradientBrush linear:
-                    if (ToVector2(table.StartPoint) is Vector2 startPoint)
-                    {
-                        linear.StartPoint = startPoint;
-                    }
-
-                    if (ToVector2(table.EndPoint) is Vector2 endPoint)
-                    {
-                        linear.EndPoint = endPoint;
-                    }
-
-                    break;
-                case Wc.CompositionRadialGradientBrush radial:
-                    if (ToVector2(table.EllipseCenter) is Vector2 ellipseCenter)
-                    {
-                        radial.EllipseCenter = ellipseCenter;
-                    }
-
-                    if (ToVector2(table.EllipseRadius) is Vector2 ellipseRadius)
-                    {
-                        radial.EllipseRadius = ellipseRadius;
-                    }
-
-                    if (ToVector2(table.GradientOriginOffset) is Vector2 gradientOriginOffset)
-                    {
-                        radial.GradientOriginOffset = gradientOriginOffset;
-                    }
-
-                    break;
-            }
-        }
-
-        Wc.CompositionColorGradientStop? GetGradientStop(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_gradientStops.Length)
-            {
-                throw new FlatBufferFormatException($"Gradient stop index {index} is out of range.");
-            }
-
-            if (_gradientStops[index] is Wc.CompositionColorGradientStop cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.GradientStops((int)index), "gradient stop");
-            var result = _compositor.CreateColorGradientStop();
-            _gradientStops[index] = result;
-
-            result.Color = ToColor(Require(table.Color, "color"));
-            result.Offset = table.Offset;
-
-            InitializeCompositionObject(result, table.Base);
-            return result;
-        }
-
-        // ---------------------------------------------------------------------
-        // Clips, view boxes, shadows and surfaces.
-        // ---------------------------------------------------------------------
-        Wc.CompositionViewBox? GetViewBox(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_viewBoxes.Length)
-            {
-                throw new FlatBufferFormatException($"View box index {index} is out of range.");
-            }
-
-            if (_viewBoxes[index] is Wc.CompositionViewBox cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.ViewBoxes((int)index), "view box");
-            var result = _compositor.CreateViewBox();
-            _viewBoxes[index] = result;
-
-            result.Size = ToVector2(table.Size) ?? Vector2.Zero;
-
-            InitializeCompositionObject(result, table.Base);
-            return result;
-        }
-
-        Wc.CompositionClip? GetClip(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_clips.Length)
-            {
-                throw new FlatBufferFormatException($"Clip index {index} is out of range.");
-            }
-
-            if (_clips[index] is Wc.CompositionClip cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.Clips((int)index), "clip");
-
-            Wc.CompositionClip result = table.Kind switch
-            {
-                Fb.ClipKind.Geometric => _compositor.CreateGeometricClip(),
-                Fb.ClipKind.Inset => _compositor.CreateInsetClip(),
-                _ => throw new FlatBufferFormatException($"Unsupported clip kind {table.Kind}."),
-            };
-
-            _clips[index] = result;
-
-            if (ToVector2(table.CenterPoint) is Vector2 centerPoint)
-            {
-                result.CenterPoint = centerPoint;
-            }
-
-            if (ToVector2(table.Scale) is Vector2 scale)
-            {
-                result.Scale = scale;
-            }
-
-            switch (result)
-            {
-                case Wc.InsetClip inset:
-                    if (table.LeftInset.HasValue)
-                    {
-                        inset.LeftInset = table.LeftInset.Value;
-                    }
-
-                    if (table.RightInset.HasValue)
-                    {
-                        inset.RightInset = table.RightInset.Value;
-                    }
-
-                    if (table.TopInset.HasValue)
-                    {
-                        inset.TopInset = table.TopInset.Value;
-                    }
-
-                    if (table.BottomInset.HasValue)
-                    {
-                        inset.BottomInset = table.BottomInset.Value;
-                    }
-
-                    break;
-                case Wc.CompositionGeometricClip geometric:
-                    if (table.Geometry != Format.NullIndex)
-                    {
-                        geometric.Geometry = GetGeometry(table.Geometry);
-                    }
-
-                    break;
-            }
-
-            InitializeCompositionObject(result, table.Base);
-            return result;
-        }
-
-        Wc.CompositionShadow? GetShadow(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_shadows.Length)
-            {
-                throw new FlatBufferFormatException($"Shadow index {index} is out of range.");
-            }
-
-            if (_shadows[index] is Wc.CompositionShadow cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.Shadows((int)index), "shadow");
-
-            Wc.CompositionShadow result = table.Kind switch
-            {
-                Fb.ShadowKind.Drop => _compositor.CreateDropShadow(),
-                _ => throw new FlatBufferFormatException($"Unsupported shadow kind {table.Kind}."),
-            };
-
-            _shadows[index] = result;
-
-            if (result is Wc.DropShadow dropShadow)
-            {
-                if (table.BlurRadius.HasValue)
-                {
-                    dropShadow.BlurRadius = table.BlurRadius.Value;
-                }
-
-                if (table.Color.HasValue)
-                {
-                    dropShadow.Color = ToColor(table.Color.Value);
-                }
-
-                if (table.Mask != Format.NullIndex)
-                {
-                    dropShadow.Mask = GetBrush(table.Mask);
-                }
-
-                if (ToVector3(table.Offset) is Vector3 offset)
-                {
-                    dropShadow.Offset = offset;
-                }
-
-                if (table.Opacity.HasValue)
-                {
-                    dropShadow.Opacity = table.Opacity.Value;
-                }
-
-                if (table.SourcePolicy.HasValue)
-                {
-                    dropShadow.SourcePolicy = (Wc.CompositionDropShadowSourcePolicy)table.SourcePolicy.Value;
-                }
-            }
-
-            InitializeCompositionObject(result, table.Base);
-            return result;
-        }
-
-        Wc.ICompositionSurface? GetSurface(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_surfaces.Length)
-            {
-                throw new FlatBufferFormatException($"Surface index {index} is out of range.");
-            }
-
-            if (_surfaces[index] is Wc.ICompositionSurface cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.Surfaces((int)index), "surface");
-
-            switch (table.Kind)
-            {
-                case Fb.SurfaceKind.VisualSurface:
-                    var visualSurface = _compositor.CreateVisualSurface();
-                    _surfaces[index] = visualSurface;
-
-                    if (table.SourceVisual != Format.NullIndex)
-                    {
-                        visualSurface.SourceVisual = GetVisual(table.SourceVisual);
-                    }
-
-                    if (ToVector2(table.SourceSize) is Vector2 sourceSize)
-                    {
-                        visualSurface.SourceSize = sourceSize;
-                    }
-
-                    if (ToVector2(table.SourceOffset) is Vector2 sourceOffset)
-                    {
-                        visualSurface.SourceOffset = sourceOffset;
-                    }
-
-                    InitializeCompositionObject(visualSurface, table.Base);
-                    return visualSurface;
-
-                case Fb.SurfaceKind.LoadedImageFromUri:
-                    var uri = GetRequiredString(table.Uri);
-                    var fromUri = Wm.LoadedImageSurface.StartLoadFromUri(new Uri(uri, UriKind.RelativeOrAbsolute));
-                    _surfaces[index] = fromUri;
-                    return fromUri;
-
-                case Fb.SurfaceKind.LoadedImageFromStream:
-                    var bytes = new byte[table.BytesLength];
-                    for (var i = 0; i < bytes.Length; i++)
-                    {
-                        bytes[i] = table.Bytes(i);
-                    }
-
-                    var fromStream = Wm.LoadedImageSurface.StartLoadFromStream(
-                        bytes.AsBuffer().AsStream().AsRandomAccessStream());
-                    _surfaces[index] = fromStream;
-                    return fromStream;
-
-                default:
-                    throw new FlatBufferFormatException($"Unsupported surface kind {table.Kind}.");
-            }
-        }
-
-        // ---------------------------------------------------------------------
-        // Effects.
-        // ---------------------------------------------------------------------
-        IGraphicsEffect? GetEffect(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_effects.Length)
-            {
-                throw new FlatBufferFormatException($"Effect index {index} is out of range.");
-            }
-
-            if (_effects[index] is IGraphicsEffect cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.Effects((int)index), "effect");
-
-            // The sources are the names that the brush later binds real brushes to. The
-            // composition engine matches them up by name.
-            var sources = new List<Wc.CompositionEffectSourceParameter>(table.SourcesLength);
-            for (var i = 0; i < table.SourcesLength; i++)
-            {
-                sources.Add(new Wc.CompositionEffectSourceParameter(GetRequiredString(table.Sources(i))));
-            }
-
-            IGraphicsEffect result;
-            switch (table.Kind)
-            {
-                case Fb.EffectKind.Composite:
-                    var composite = new Mgce.CompositeEffect
-                    {
-                        Mode = (Mgc.CanvasComposite)table.Mode,
-                    };
-
-                    foreach (var source in sources)
-                    {
-                        composite.Sources.Add(source);
-                    }
-
-                    result = composite;
-                    break;
-                case Fb.EffectKind.GaussianBlur:
-                    if (sources.Count != 1)
-                    {
-                        throw new FlatBufferFormatException("A blur effect must have exactly one source.");
-                    }
-
-                    result = new Mgce.GaussianBlurEffect
-                    {
-                        BlurAmount = table.BlurAmount,
-                        Source = sources[0],
-                    };
-                    break;
-                default:
-                    throw new FlatBufferFormatException($"Unsupported effect kind {table.Kind}.");
-            }
-
-            _effects[index] = result;
-            return result;
-        }
-
-        // ---------------------------------------------------------------------
-        // Easings.
-        // ---------------------------------------------------------------------
-        Wc.CompositionEasingFunction? GetEasing(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_easings.Length)
-            {
-                throw new FlatBufferFormatException($"Easing index {index} is out of range.");
-            }
-
-            if (_easings[index] is Wc.CompositionEasingFunction cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.Easings((int)index), "easing");
-
-            Wc.CompositionEasingFunction result;
-            switch (table.Kind)
-            {
-                case Fb.EasingKind.Linear:
-                    result = _compositor.CreateLinearEasingFunction();
-                    break;
-                case Fb.EasingKind.CubicBezier:
-                    result = _compositor.CreateCubicBezierEasingFunction(
-                        ToVector2(table.ControlPoint1) ?? Vector2.Zero,
-                        ToVector2(table.ControlPoint2) ?? Vector2.Zero);
-                    break;
-                case Fb.EasingKind.Step:
-                    var step = _compositor.CreateStepEasingFunction();
-
-                    if (table.StepCount.HasValue)
-                    {
-                        step.StepCount = table.StepCount.Value;
-                    }
-
-                    if (table.InitialStep.HasValue)
-                    {
-                        step.InitialStep = table.InitialStep.Value;
-                    }
-
-                    if (table.FinalStep.HasValue)
-                    {
-                        step.FinalStep = table.FinalStep.Value;
-                    }
-
-                    if (table.IsInitialStepSingleFrame.HasValue)
-                    {
-                        step.IsInitialStepSingleFrame = table.IsInitialStepSingleFrame.Value;
-                    }
-
-                    if (table.IsFinalStepSingleFrame.HasValue)
-                    {
-                        step.IsFinalStepSingleFrame = table.IsFinalStepSingleFrame.Value;
-                    }
-
-                    result = step;
-                    break;
-                default:
-                    throw new FlatBufferFormatException($"Unsupported easing kind {table.Kind}.");
-            }
-
-            _easings[index] = result;
-
-            InitializeCompositionObject(result, table.Base);
-            return result;
-        }
-
-        // ---------------------------------------------------------------------
-        // Animations.
-        // ---------------------------------------------------------------------
-        Wc.CompositionAnimation? GetAnimation(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_animations.Length)
-            {
-                throw new FlatBufferFormatException($"Animation index {index} is out of range.");
-            }
-
-            if (_animations[index] is Wc.CompositionAnimation cached)
-            {
-                return cached;
-            }
-
-            var table = Require(_root.Animations((int)index), "animation");
-
-            Wc.CompositionAnimation result = table.Kind == Fb.AnimationKind.Expression
-                ? _compositor.CreateExpressionAnimation(GetRequiredString(table.Expression))
-                : CreateKeyFrameAnimation(table);
-
-            _animations[index] = result;
-
-            if (GetString(table.Target) is string target)
-            {
-                result.Target = target;
-            }
-
-            for (var i = 0; i < table.ReferenceParametersLength; i++)
-            {
-                var parameter = Require(table.ReferenceParameters(i), "reference parameter");
-                result.SetReferenceParameter(
-                    GetRequiredString(parameter.Name),
-                    GetObjectReference(parameter.Target)
-                    ?? throw new FlatBufferFormatException("A reference parameter has no target."));
-            }
-
-            InitializeCompositionObject(result, table.Base);
-            return result;
-        }
-
-        // Creates the animation and inserts its key frames in one place, because the
-        // concrete type is only needed in order to insert a value key frame and would
-        // otherwise have to be recovered with a cast.
-        Wc.CompositionAnimation CreateKeyFrameAnimation(Fb.Animation table)
-        {
-            Wc.KeyFrameAnimation result;
-            Wc.ScalarKeyFrameAnimation? scalar = null;
-            Wc.Vector2KeyFrameAnimation? vector2 = null;
-            Wc.Vector3KeyFrameAnimation? vector3 = null;
-            Wc.Vector4KeyFrameAnimation? vector4 = null;
-            Wc.ColorKeyFrameAnimation? color = null;
-            Wc.BooleanKeyFrameAnimation? boolean = null;
-            Wc.PathKeyFrameAnimation? path = null;
-
-            switch (table.Kind)
-            {
-                case Fb.AnimationKind.Scalar:
-                    scalar = _compositor.CreateScalarKeyFrameAnimation();
-                    result = scalar;
-                    break;
-                case Fb.AnimationKind.Vector2:
-                    vector2 = _compositor.CreateVector2KeyFrameAnimation();
-                    result = vector2;
-                    break;
-                case Fb.AnimationKind.Vector3:
-                    vector3 = _compositor.CreateVector3KeyFrameAnimation();
-                    result = vector3;
-                    break;
-                case Fb.AnimationKind.Vector4:
-                    vector4 = _compositor.CreateVector4KeyFrameAnimation();
-                    result = vector4;
-                    break;
-                case Fb.AnimationKind.Color:
-                    color = _compositor.CreateColorKeyFrameAnimation();
-
-                    if (table.InterpolationColorSpace.HasValue)
-                    {
-                        color.InterpolationColorSpace =
-                            (Wc.CompositionColorSpace)table.InterpolationColorSpace.Value;
-                    }
-
-                    result = color;
-                    break;
-                case Fb.AnimationKind.Boolean:
-                    boolean = _compositor.CreateBooleanKeyFrameAnimation();
-                    result = boolean;
-                    break;
-                case Fb.AnimationKind.Path:
-                    path = _compositor.CreatePathKeyFrameAnimation();
-                    result = path;
-                    break;
-                default:
-                    throw new FlatBufferFormatException($"Unsupported animation kind {table.Kind}.");
-            }
-
-            for (var i = 0; i < table.KeyFramesLength; i++)
-            {
-                var frame = Require(table.KeyFrames(i), "key frame");
-
-                if (frame.Kind == Fb.KeyFrameKind.Expression)
-                {
-                    result.InsertExpressionKeyFrame(
-                        frame.Progress,
-                        GetRequiredString(frame.Expression),
-                        GetEasing(frame.Easing));
-                }
-                else if (frame.Kind == Fb.KeyFrameKind.Value)
-                {
-                    switch (table.Kind)
-                    {
-                        case Fb.AnimationKind.Scalar:
-                            scalar!.InsertKeyFrame(frame.Progress, frame.Scalar, GetEasing(frame.Easing));
-                            break;
-                        case Fb.AnimationKind.Vector2:
-                            vector2!.InsertKeyFrame(
-                                frame.Progress,
-                                ToVector2(frame.Vector),
-                                GetEasing(frame.Easing));
-                            break;
-                        case Fb.AnimationKind.Vector3:
-                            vector3!.InsertKeyFrame(
-                                frame.Progress,
-                                ToVector3(frame.Vector),
-                                GetEasing(frame.Easing));
-                            break;
-                        case Fb.AnimationKind.Vector4:
-                            vector4!.InsertKeyFrame(
-                                frame.Progress,
-                                ToVector4(frame.Vector),
-                                GetEasing(frame.Easing));
-                            break;
-                        case Fb.AnimationKind.Color:
-                            color!.InsertKeyFrame(
-                                frame.Progress,
-                                ToColor(Require(frame.Color, "color")),
-                                GetEasing(frame.Easing));
-                            break;
-                        case Fb.AnimationKind.Boolean:
-                            // A boolean cannot be interpolated, so it has no easing.
-                            boolean!.InsertKeyFrame(frame.Progress, frame.Scalar != 0);
-                            break;
-                        case Fb.AnimationKind.Path:
-                            path!.InsertKeyFrame(
-                                frame.Progress,
-                                new Wc.CompositionPath(
-                                    GetCanvasGeometry(frame.Path)
-                                    ?? throw new FlatBufferFormatException("A path key frame has no path.")),
-                                GetEasing(frame.Easing));
-                            break;
-                    }
-                }
-            }
-
-            result.Duration = TimeSpan.FromTicks(table.DurationTicks);
-
-            return result;
-        }
-
-        // ---------------------------------------------------------------------
-        // Paths.
-        //
-        // A canvas geometry is not a CompositionObject, so it has no shared state and
-        // no animators; it is only ever a value.
-        // ---------------------------------------------------------------------
-        CanvasGeometry? GetCanvasGeometry(uint index)
-        {
-            if (index == Format.NullIndex)
-            {
-                return null;
-            }
-
-            if (index >= (uint)_canvasGeometries.Length)
-            {
-                throw new FlatBufferFormatException($"Canvas geometry index {index} is out of range.");
-            }
-
-            switch (_canvasGeometryStates[index])
-            {
-                case CanvasGeometryState.Realized:
-                    return _canvasGeometries[index];
-                case CanvasGeometryState.Realizing:
-                    // A geometry that is built from itself would never finish.
-                    throw new FlatBufferFormatException($"Canvas geometry {index} is cyclic.");
-            }
-
-            _canvasGeometryStates[index] = CanvasGeometryState.Realizing;
-
-            var table = Require(_root.CanvasGeometries((int)index), "canvas geometry");
-
-            CanvasGeometry result;
-            switch (table.Kind)
-            {
-                case Fb.CanvasGeometryKind.Combination:
-                    var a = GetCanvasGeometry(RequireIndex(table.A, "geometry"))
-                        ?? throw new FlatBufferFormatException("A combination has no first geometry.");
-                    var b = GetCanvasGeometry(RequireIndex(table.B, "geometry"))
-                        ?? throw new FlatBufferFormatException("A combination has no second geometry.");
-                    result = a.CombineWith(
-                        b,
-                        ToMatrix3x2(table.Matrix) ?? Matrix3x2.Identity,
-                        (CanvasGeometryCombine)table.CombineMode);
-                    break;
-
-                case Fb.CanvasGeometryKind.TransformedGeometry:
-                    var source = GetCanvasGeometry(RequireIndex(table.Source, "geometry"))
-                        ?? throw new FlatBufferFormatException("A transformed geometry has no source.");
-                    result = source.Transform(ToMatrix3x2(table.Matrix) ?? Matrix3x2.Identity);
-                    break;
-
-                case Fb.CanvasGeometryKind.Group:
-                    var geometries = new CanvasGeometry[table.GeometriesLength];
-                    for (var i = 0; i < geometries.Length; i++)
-                    {
-                        geometries[i] = GetCanvasGeometry(table.Geometries(i))
-                            ?? throw new FlatBufferFormatException("A grouped geometry is missing.");
-                    }
-
-                    result = CanvasGeometry.CreateGroup(
-                        null,
-                        geometries,
-                        (CanvasFilledRegionDetermination)table.FillRule);
-                    break;
-
-                case Fb.CanvasGeometryKind.Path:
-                    result = CreatePath(table);
-                    break;
-
-                case Fb.CanvasGeometryKind.Ellipse:
-                    result = CanvasGeometry.CreateEllipse(null, table.X, table.Y, table.RadiusX, table.RadiusY);
-                    break;
-
-                case Fb.CanvasGeometryKind.RoundedRectangle:
-                    result = CanvasGeometry.CreateRoundedRectangle(
-                        null, table.X, table.Y, table.W, table.H, table.RadiusX, table.RadiusY);
-                    break;
-
-                default:
-                    throw new FlatBufferFormatException($"Unsupported canvas geometry kind {table.Kind}.");
-            }
-
-            _canvasGeometries[index] = result;
-            _canvasGeometryStates[index] = CanvasGeometryState.Realized;
-            return result;
-        }
-
-        // Replays the flattened opcode and operand streams of a path. The operands of
-        // every command are consecutive in one array, which is why there is no table
-        // per command.
-        static CanvasGeometry CreatePath(Fb.CanvasGeometry table)
-        {
-            using var builder = new CanvasPathBuilder(null);
-            builder.SetFilledRegionDetermination((CanvasFilledRegionDetermination)table.FillRule);
-
-            var operand = 0;
-            var inFigure = false;
-
-            float Next()
-                => operand < table.OperandsLength
-                    ? table.Operands(operand++)
-                    : throw new FlatBufferFormatException("A path ran out of operands.");
-
-            void RequireFigure(bool expected)
-            {
-                if (inFigure != expected)
-                {
-                    throw new FlatBufferFormatException("A path has a figure that does not begin and end.");
-                }
-            }
-
-            for (var i = 0; i < table.OpsLength; i++)
-            {
-                switch ((Fb.PathOp)table.Ops(i))
-                {
-                    case Fb.PathOp.BeginFigure:
-                        RequireFigure(false);
-                        builder.BeginFigure(new Vector2(Next(), Next()));
-                        inFigure = true;
-                        break;
-                    case Fb.PathOp.EndFigure:
-                        RequireFigure(true);
-                        builder.EndFigure((CanvasFigureLoop)Next());
-                        inFigure = false;
-                        break;
-                    case Fb.PathOp.AddLine:
-                        RequireFigure(true);
-                        builder.AddLine(new Vector2(Next(), Next()));
-                        break;
-                    case Fb.PathOp.AddCubicBezier:
-                        RequireFigure(true);
-                        builder.AddCubicBezier(
-                            new Vector2(Next(), Next()),
-                            new Vector2(Next(), Next()),
-                            new Vector2(Next(), Next()));
-                        break;
-                    default:
-                        throw new FlatBufferFormatException($"Unsupported path opcode {table.Ops(i)}.");
-                }
-            }
-
-            RequireFigure(false);
-
-            return CanvasGeometry.CreatePath(builder);
-        }
-
-        // ---------------------------------------------------------------------
-        // Value helpers. An absent struct field means the property was never set,
-        // so these return null rather than a default value.
-        // ---------------------------------------------------------------------
-        static Wui.Color ToColor(Fb.Color value)
-            => Wui.Color.FromArgb(value.A, value.R, value.G, value.B);
-
-        static Vector2? ToVector2(Fb.Vec2? value)
-            => value.HasValue ? new Vector2(value.Value.X, value.Value.Y) : null;
-
-        static Vector3? ToVector3(Fb.Vec3? value)
-            => value.HasValue ? new Vector3(value.Value.X, value.Value.Y, value.Value.Z) : null;
-
-        static Vector2 ToVector2(Fb.Vec4? value)
-            => value.HasValue ? new Vector2(value.Value.X, value.Value.Y) : Vector2.Zero;
-
-        static Vector3 ToVector3(Fb.Vec4? value)
-            => value.HasValue ? new Vector3(value.Value.X, value.Value.Y, value.Value.Z) : Vector3.Zero;
-
-        static Vector4 ToVector4(Fb.Vec4? value)
-            => value.HasValue
-                ? new Vector4(value.Value.X, value.Value.Y, value.Value.Z, value.Value.W)
-                : Vector4.Zero;
-
-        static Matrix3x2? ToMatrix3x2(Fb.Mat3x2? value)
-            => value.HasValue
-                ? new Matrix3x2(
-                    value.Value.M11, value.Value.M12,
-                    value.Value.M21, value.Value.M22,
-                    value.Value.M31, value.Value.M32)
-                : null;
-
-        static Matrix4x4? ToMatrix4x4(Fb.Mat4x4? value)
-            => value.HasValue
-                ? new Matrix4x4(
-                    value.Value.M11, value.Value.M12, value.Value.M13, value.Value.M14,
-                    value.Value.M21, value.Value.M22, value.Value.M23, value.Value.M24,
-                    value.Value.M31, value.Value.M32, value.Value.M33, value.Value.M34,
-                    value.Value.M41, value.Value.M42, value.Value.M43, value.Value.M44)
-                : null;
-    }
-}
diff --git a/dlls/LottieRuntime/Generated/lottie_comp_generated.h b/source/LottieRuntime/Generated/lottie_comp_generated.h
similarity index 100%
rename from dlls/LottieRuntime/Generated/lottie_comp_generated.h
rename to source/LottieRuntime/Generated/lottie_comp_generated.h
diff --git a/dlls/LottieRuntime/LottieRuntime.cpp b/source/LottieRuntime/LottieRuntime.cpp
similarity index 97%
rename from dlls/LottieRuntime/LottieRuntime.cpp
rename to source/LottieRuntime/LottieRuntime.cpp
index 209b9655..c0f097b7 100644
--- a/dlls/LottieRuntime/LottieRuntime.cpp
+++ b/source/LottieRuntime/LottieRuntime.cpp
@@ -32,6 +32,10 @@
 // C++/WinRT requires <unknwn.h> before projected headers.
 #include <unknwn.h>
 
+#if defined(LOTTIE_RUNTIME_WINUI2) == defined(LOTTIE_RUNTIME_WINUI3)
+#error Define exactly one of LOTTIE_RUNTIME_WINUI2 or LOTTIE_RUNTIME_WINUI3.
+#endif
+
 #include "LottieRuntime.h"
 
 #include <cstdint>
@@ -53,17 +57,28 @@
 #include <winrt/Windows.Graphics.Effects.h>
 #include <winrt/Windows.Storage.Streams.h>
 #include <winrt/Windows.UI.h>
-#include <winrt/Windows.UI.Composition.h>
 
 #undef GetCurrentTime
+#if defined(LOTTIE_RUNTIME_WINUI3)
+#include <winrt/Microsoft.UI.Composition.h>
+#include <winrt/Microsoft.UI.Xaml.Media.h>
+#else
+#include <winrt/Windows.UI.Composition.h>
 #include <winrt/Windows.UI.Xaml.Media.h>
+#endif
 
 #include "Generated/lottie_comp_generated.h"
 
 namespace Fb = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema;
 
 using namespace winrt::Windows::Foundation::Numerics;
+#if defined(LOTTIE_RUNTIME_WINUI3)
+using namespace winrt::Microsoft::UI::Composition;
+namespace XamlMedia = winrt::Microsoft::UI::Xaml::Media;
+#else
 using namespace winrt::Windows::UI::Composition;
+namespace XamlMedia = winrt::Windows::UI::Xaml::Media;
+#endif
 
 namespace
 {
@@ -75,6 +90,10 @@ namespace
     // version is rejected, because it may use fields that are not read here.
     constexpr uint16_t SupportedSchemaVersion = 1;
 
+    // Recursive composition graphs are invalid. Limit nesting even for acyclic
+    // graphs so a small malicious buffer cannot exhaust the native stack.
+    constexpr uint32_t MaximumTraversalDepth = 128;
+
     // Object references that can point at more than one category pack the category
     // into the top four bits.
     constexpr uint32_t CategoryShift = 28;
@@ -354,6 +373,28 @@ namespace
         }
 
     private:
+        class TraversalGuard
+        {
+        public:
+            explicit TraversalGuard(Interpreter& owner) :
+                m_owner(owner)
+            {
+                Check(m_owner.m_traversalDepth < MaximumTraversalDepth);
+                ++m_owner.m_traversalDepth;
+            }
+
+            ~TraversalGuard()
+            {
+                --m_owner.m_traversalDepth;
+            }
+
+            TraversalGuard(TraversalGuard const&) = delete;
+            TraversalGuard& operator=(TraversalGuard const&) = delete;
+
+        private:
+            Interpreter& m_owner;
+        };
+
         template<typename T>
         static size_t Count(T const* vector)
         {
@@ -686,6 +727,7 @@ namespace
                 return m_visuals[index];
             }
 
+            TraversalGuard const traversalGuard(*this);
             auto const* source = At(m_root.visuals(), index);
 
             // The concrete type is known only here. Everything below this point,
@@ -856,6 +898,7 @@ namespace
                 return m_shapes[index];
             }
 
+            TraversalGuard const traversalGuard(*this);
             auto const* source = At(m_root.shapes(), index);
 
             CompositionShape result{ nullptr };
@@ -1140,6 +1183,7 @@ namespace
                 break;
             }
 
+            TraversalGuard const traversalGuard(*this);
             m_canvasGeometryStates[index] = CanvasGeometryState::Realizing;
             auto result = BuildGeometryCore(index);
             Check(result != nullptr);
@@ -1720,7 +1764,7 @@ namespace
                 auto const uri = source->uri();
                 Check(uri != NullIndex);
                 m_surfaces[index] =
-                    winrt::Windows::UI::Xaml::Media::LoadedImageSurface::StartLoadFromUri(
+                    XamlMedia::LoadedImageSurface::StartLoadFromUri(
                         winrt::Windows::Foundation::Uri(GetString(uri)));
                 break;
             }
@@ -1741,7 +1785,7 @@ namespace
                     winrt::put_abi(stream)));
 
                 m_surfaces[index] =
-                    winrt::Windows::UI::Xaml::Media::LoadedImageSurface::StartLoadFromStream(
+                    XamlMedia::LoadedImageSurface::StartLoadFromStream(
                         stream);
                 break;
             }
@@ -2110,10 +2154,15 @@ namespace
         std::vector<CompositionAnimation> m_animations;
         std::vector<CompositionPropertySet> m_propertySets;
         std::vector<AnimationController> m_controllers;
+        uint32_t m_traversalDepth = 0;
     };
 }
 
-namespace CommunityToolkit::WinUI::Lottie
+#if defined(LOTTIE_RUNTIME_WINUI3)
+namespace CommunityToolkit::WinUI3::Lottie
+#else
+namespace CommunityToolkit::WinUI2::Lottie
+#endif
 {
     Visual LoadComposition(Compositor const& compositor, std::span<std::byte const> buffer)
     {
@@ -2141,6 +2190,7 @@ namespace CommunityToolkit::WinUI::Lottie
         }
 
         auto const requiredUapVersion = root->required_uap_version();
+#if !defined(LOTTIE_RUNTIME_WINUI3)
         if (requiredUapVersion != 0 &&
             !winrt::Windows::Foundation::Metadata::ApiInformation::IsApiContractPresent(
                 L"Windows.Foundation.UniversalApiContract",
@@ -2148,6 +2198,12 @@ namespace CommunityToolkit::WinUI::Lottie
         {
             ThrowUnsupported();
         }
+#else
+        // Windows App SDK carries its Composition implementation with the app rather
+        // than exposing it through the OS UniversalApiContract. The consumer selects
+        // a buffer variant whose required APIs are present in its WASDK version.
+        static_cast<void>(requiredUapVersion);
+#endif
 
         return Interpreter(compositor, *root).Run();
     }
diff --git a/dlls/LottieRuntime/LottieRuntime.h b/source/LottieRuntime/LottieRuntime.h
similarity index 69%
rename from dlls/LottieRuntime/LottieRuntime.h
rename to source/LottieRuntime/LottieRuntime.h
index 76b182cd..4ecf7297 100644
--- a/dlls/LottieRuntime/LottieRuntime.h
+++ b/source/LottieRuntime/LottieRuntime.h
@@ -9,12 +9,24 @@
 #include <cstddef>
 #include <span>
 
-#include <winrt/Windows.UI.Composition.h>
+#if defined(LOTTIE_RUNTIME_WINUI2) == defined(LOTTIE_RUNTIME_WINUI3)
+#error Define exactly one of LOTTIE_RUNTIME_WINUI2 or LOTTIE_RUNTIME_WINUI3.
+#endif
 
-namespace CommunityToolkit::WinUI::Lottie
+#if defined(LOTTIE_RUNTIME_WINUI3)
+#include <winrt/Microsoft.UI.Composition.h>
+namespace CommunityToolkit::WinUI3::Lottie
+{
+    using namespace winrt::Microsoft::UI::Composition;
+#else
+#include <winrt/Windows.UI.Composition.h>
+namespace CommunityToolkit::WinUI2::Lottie
 {
-    // LoadComposition is the direct-link C++ API.
-    // DLL callers use ILottieCompositionLoader from LottieRuntimeCom.h.
+    using namespace winrt::Windows::UI::Composition;
+#endif
+
+    // Define LOTTIE_RUNTIME_WINUI2 for Windows.UI.Composition or
+    // LOTTIE_RUNTIME_WINUI3 for Microsoft.UI.Composition.
     // Builds the composition described by a serialized Lottie composition.
     //
     // The buffer is the output of LottieGen -Language flatbuffer, or equivalently of
@@ -32,14 +44,13 @@ namespace CommunityToolkit::WinUI::Lottie
     //
     // Throws winrt::hresult_error with E_INVALIDARG if the buffer is not a well formed
     // composition, and E_NOTIMPL if it requires a feature this build does not have.
-    winrt::Windows::UI::Composition::Visual LoadComposition(
-        winrt::Windows::UI::Composition::Compositor const& compositor,
+    Visual LoadComposition(
+        Compositor const& compositor,
         std::span<std::byte const> buffer);
 
     // The property set that drives the animation. Animating its "Progress" scalar from
     // 0 to 1 plays the animation once.
     //
     // Returns the root Visual's property set.
-    winrt::Windows::UI::Composition::CompositionPropertySet ProgressPropertySet(
-        winrt::Windows::UI::Composition::Visual const& root);
+    CompositionPropertySet ProgressPropertySet(Visual const& root);
 }
diff --git a/source/LottieRuntime/LottieRuntime.projitems b/source/LottieRuntime/LottieRuntime.projitems
deleted file mode 100644
index 403fb1e2..00000000
--- a/source/LottieRuntime/LottieRuntime.projitems
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
-    <HasSharedItems>true</HasSharedItems>
-    <SharedGUID>7c8b1d02-4e5f-4a76-9c3b-2f0d8e6a41b9</SharedGUID>
-  </PropertyGroup>
-  <PropertyGroup Label="Configuration">
-    <Import_RootNamespace>LottieRuntime</Import_RootNamespace>
-  </PropertyGroup>
-  <Import
-    Project="$(MSBuildThisFileDirectory)..\CompDataFlatbuffer\CompDataFlatbufferRuntime.projitems"
-    Condition="'$(CompDataFlatbufferRuntimeImported)' != 'true'"
-    Label="Shared" />
-  <ItemGroup>
-    <Compile Include="$(MSBuildThisFileDirectory)CompositionInterpreter.cs" />
-  </ItemGroup>
-</Project>
diff --git a/source/LottieRuntime/LottieRuntime.shproj b/source/LottieRuntime/LottieRuntime.shproj
deleted file mode 100644
index fb5026ae..00000000
--- a/source/LottieRuntime/LottieRuntime.shproj
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>7c8b1d02-4e5f-4a76-9c3b-2f0d8e6a41b9</ProjectGuid>
-    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
-  </PropertyGroup>
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.Default.props" />
-  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.props" />
-  <PropertyGroup />
-  <Import Project="LottieRuntime.projitems" Label="Shared" />
-  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.CSharp.targets" />
-</Project>
diff --git a/dlls/LottieRuntimeTool/LottieRuntime.cpp b/source/LottieRuntime/LottieRuntimeTool.cpp
similarity index 84%
rename from dlls/LottieRuntimeTool/LottieRuntime.cpp
rename to source/LottieRuntime/LottieRuntimeTool.cpp
index ad8b8daa..cd63a9bf 100644
--- a/dlls/LottieRuntimeTool/LottieRuntime.cpp
+++ b/source/LottieRuntime/LottieRuntimeTool.cpp
@@ -2,16 +2,15 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-// Loads a serialized Lottie composition through the registration-free COM surface.
+// Loads a serialized Lottie composition through the statically linked WinUI 2 reader.
 
 #include <unknwn.h>
 
 #include <Windows.h>
 #include <DispatcherQueue.h>
-#include <shlwapi.h>
 #include <windows.ui.composition.interop.h>
 
-#include <LottieRuntimeCom.h>
+#include <LottieRuntime.h>
 
 #include <winrt/Windows.Foundation.h>
 #include <winrt/Windows.Foundation.Collections.h>
@@ -47,40 +46,6 @@ namespace
         return controller;
     }
 
-    winrt::com_ptr<ILottieCompositionLoader> CreateLoader()
-    {
-        wchar_t moduleDirectory[MAX_PATH]{};
-        winrt::check_bool(GetModuleFileNameW(nullptr, moduleDirectory, MAX_PATH));
-        winrt::check_bool(PathRemoveFileSpecW(moduleDirectory));
-
-        auto const manifestPath =
-            std::wstring(moduleDirectory) + L"\\LottieRuntime.manifest";
-
-        ACTCTXW context{ sizeof(ACTCTXW) };
-        context.lpSource = manifestPath.c_str();
-        context.lpAssemblyDirectory = moduleDirectory;
-        context.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
-
-        auto const activationContext = CreateActCtxW(&context);
-        winrt::check_bool(activationContext != INVALID_HANDLE_VALUE);
-
-        ULONG_PTR cookie{};
-        winrt::check_bool(ActivateActCtx(activationContext, &cookie));
-
-        winrt::com_ptr<ILottieCompositionLoader> loader;
-        auto const result = CoCreateInstance(
-            CLSID_LottieCompositionLoader,
-            nullptr,
-            CLSCTX_INPROC_SERVER,
-            __uuidof(ILottieCompositionLoader),
-            loader.put_void());
-
-        DeactivateActCtx(0, cookie);
-        ReleaseActCtx(activationContext);
-        winrt::check_hresult(result);
-        return loader;
-    }
-
     std::vector<std::byte> ReadFileBytes(wchar_t const* path)
     {
         std::ifstream file(path, std::ios::binary | std::ios::ate);
@@ -322,13 +287,8 @@ int wmain(int argc, wchar_t* argv[])
         auto dispatcherQueueController = CreateDispatcherQueue();
         auto bytes = ReadFileBytes(argv[1]);
 
-        auto loader = CreateLoader();
-        Visual root{ nullptr };
-        winrt::check_hresult(loader->LoadComposition(
-            static_cast<UINT32>(bytes.size()),
-            reinterpret_cast<BYTE const*>(bytes.data()),
-            winrt::guid_of<Visual>(),
-            winrt::put_abi(root)));
+        Compositor compositor;
+        auto root = CommunityToolkit::WinUI2::Lottie::LoadComposition(compositor, bytes);
 
         switch (mode)
         {
diff --git a/dlls/LottieRuntimeTool/LottieRuntime.vcxproj b/source/LottieRuntime/LottieRuntimeTool.vcxproj
similarity index 69%
rename from dlls/LottieRuntimeTool/LottieRuntime.vcxproj
rename to source/LottieRuntime/LottieRuntimeTool.vcxproj
index ee8b65c3..ac309879 100644
--- a/dlls/LottieRuntimeTool/LottieRuntime.vcxproj
+++ b/source/LottieRuntime/LottieRuntimeTool.vcxproj
@@ -28,6 +28,10 @@
     <CharacterSet>Unicode</CharacterSet>
     <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
     <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
+    <FlatBuffersIncludeDirectory
+        Condition="'$(FlatBuffersIncludeDirectory)'=='' and Exists('$(MSBuildThisFileDirectory)..\..\external\flatbuffers\include')">$(MSBuildThisFileDirectory)..\..\external\flatbuffers\include</FlatBuffersIncludeDirectory>
+    <FlatBuffersIncludeDirectory
+        Condition="'$(FlatBuffersIncludeDirectory)'==''">$(MSBuildThisFileDirectory)flatbuffers\include</FlatBuffersIncludeDirectory>
   </PropertyGroup>
 
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
@@ -43,15 +47,15 @@
   <ItemDefinitionGroup>
     <ClCompile>
       <LanguageStandard>stdcpp20</LanguageStandard>
-      <PreprocessorDefinitions>WIN32_LEAN_AND_MEAN;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory)..\LottieRuntime;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32_LEAN_AND_MEAN;NOMINMAX;LOTTIE_RUNTIME_WINUI2;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory);$(FlatBuffersIncludeDirectory);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <WarningLevel>Level4</WarningLevel>
       <TreatWarningAsError>true</TreatWarningAsError>
       <ExceptionHandling>Sync</ExceptionHandling>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
-      <AdditionalDependencies>CoreMessaging.lib;ole32.lib;shlwapi.lib;user32.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>CoreMessaging.lib;d2d1.lib;dxguid.lib;ole32.lib;shcore.lib;shlwapi.lib;user32.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
 
@@ -70,28 +74,9 @@
   </ItemDefinitionGroup>
 
   <ItemGroup>
+    <ClCompile Include="LottieRuntimeTool.cpp" />
     <ClCompile Include="LottieRuntime.cpp" />
   </ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\LottieRuntime\LottieRuntime.vcxproj">
-      <Project>{6E0A5B4C-2F1D-4B7A-9C3E-1D5A8F0B2E47}</Project>
-      <LinkLibraryDependencies>false</LinkLibraryDependencies>
-    </ProjectReference>
-  </ItemGroup>
-
-  <Target Name="CopyLottieRuntimeFiles" AfterTargets="Build">
-    <MSBuild
-        Projects="..\LottieRuntime\LottieRuntime.vcxproj"
-        Targets="GetTargetPath"
-        Properties="Configuration=$(Configuration);Platform=$(Platform)">
-      <Output TaskParameter="TargetOutputs" ItemName="_LottieRuntimeTarget" />
-    </MSBuild>
-    <ItemGroup>
-      <LottieRuntimeManifest Include="$(MSBuildThisFileDirectory)..\LottieRuntime\LottieRuntime.manifest" />
-    </ItemGroup>
-    <Copy SourceFiles="@(_LottieRuntimeTarget);@(LottieRuntimeManifest)" DestinationFolder="$(OutDir)" SkipUnchangedFiles="true" />
-  </Target>
-
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
 </Project>
diff --git a/source/LottieRuntime/README.md b/source/LottieRuntime/README.md
index 3b94437e..072017e3 100644
--- a/source/LottieRuntime/README.md
+++ b/source/LottieRuntime/README.md
@@ -1,108 +1,102 @@
-# LottieRuntime (managed)
+# LottieRuntime
 
-A managed runtime interpreter for Lottie animations.
+Native C++/WinRT source builders for serialized Lottie animations.
 
-`CompositionInterpreter` builds a `Windows.UI.Composition` visual tree from a
-serialized composition. It is the C# counterpart of the native interpreter in
-[`dlls/LottieRuntime`](../../dlls/LottieRuntime/README.md): both read the same
-`.lcomp` buffer, make the same composition calls, and perform the same validation,
-so an application can choose whichever one suits its language and packaging without
-changing what appears on screen.
+The reader builds a Composition visual tree directly with the caller's
+`Compositor`. There is no COM activation layer and no runtime DLL. The consumer
+compiles `LottieRuntime.cpp` with exactly one projection definition:
 
-## How it fits in
+| Composition API | Preprocessor definition |
+| --- | --- |
+| `Windows.UI.Composition` (WinUI 2/UWP) | `LOTTIE_RUNTIME_WINUI2` |
+| `Microsoft.UI.Composition` (WinUI 3/Windows App SDK) | `LOTTIE_RUNTIME_WINUI3` |
 
-Lottie-Windows turns a Lottie file into a `WinCompData` graph, which is a
-description of a composition tree. Four consumers use that graph:
+The source and header reject builds where neither or both definitions are set.
+This keeps the ABI-incompatible projections separate without duplicating the
+interpreter.
 
-| Consumer | When it runs | Cost |
-| --- | --- | --- |
-| `Instantiator` | Runtime, in the app | Ships the whole JSON reader and translator |
-| `LottieGen` code generators | Build time | No runtime cost, but one class per animation |
-| `LottieRuntime` (C++) | Runtime, in the app | One interpreter shared by every animation |
-| `CompositionInterpreter` (C#) | Runtime, in the app | One interpreter shared by every animation |
+## Producing buffers
 
-`CompositionSerializer` writes the graph into a FlatBuffer at build time and the
-interpreter reads that buffer at runtime. The animation stays data, so it can be
-swapped, downloaded or themed without a rebuild, and the amount of code in the
-application does not grow with the number of animations.
+```powershell
+LottieGen -InputFile animation.json -Language flatbuffer -OutputFolder .
+```
+
+If one translation covers the requested UAP range, this writes
+`Animation.lcomp`. If fallbacks are required, LottieGen writes one file per
+supported range, for example:
+
+```text
+Animation.uap14-plus.lcomp
+Animation.uap10-13.lcomp
+Animation.uap7-9.lcomp
+```
 
-Note the difference from `CompositionDeserializer`, which is also managed and also
-reads the same buffer: the deserializer rebuilds a `WinCompData` graph, which is the
-object model that the translator and the code generators work in, while the
-interpreter creates live composition objects and no intermediate model at all. The
-deserializer is a tool; the interpreter is a player.
+The consumer selects the file matching its Composition API contract. The data is
+not tied to either projection: the same variant can be read by the WinUI 2 or
+WinUI 3 builder when that projection provides the APIs required by the variant.
 
-## Producing a buffer
+## Incorporating the reader
 
+Add `LottieRuntime.cpp` to the native project, define the matching projection
+flag, and add `LottieRuntime/` and `LottieRuntime/flatbuffers/include/` to its
+include paths. Build as C++20 and link:
+
+```text
+d2d1.lib
+dxguid.lib
+shcore.lib
+shlwapi.lib
+windowsapp.lib
 ```
-LottieGen -InputFile animation.json -Language flatbuffer -OutputFolder .
+
+Include `LottieRuntime.h`, create the compositor in the host, and pass it to the
+reader:
+
+```cpp
+#include <LottieRuntime.h>
+
+auto bytes = ReadFileBytes(L"Animation.lcomp");
+auto root = CommunityToolkit::WinUI2::Lottie::LoadComposition(compositor, bytes);
 ```
 
-This writes `Animation.lcomp`. The format is described by
-[`source/LottieFlatbuffer/lottie_comp.fbs`](../LottieFlatbuffer/lottie_comp.fbs).
+The same projection definition must be visible to every file that includes
+`LottieRuntime.h`. WinUI 3 builds use the corresponding
+`CommunityToolkit::WinUI3::Lottie` namespace. The distinct namespaces allow both
+projection-specific objects to be linked into the same binary.
+
+`LoadComposition` returns the root `Visual`. `ProgressPropertySet(root)` returns
+the Composition property set containing the `Progress` scalar. XAML integration
+and `IAnimatedVisual` wrapping remain the caller's responsibility.
+
+## Validation and safety
+
+The reader verifies the FlatBuffer identifier and structure, range-checks every
+node index, rejects unsupported schema or API-contract versions, detects geometry
+cycles, and limits recursive visual, shape, and geometry traversal to 128 levels.
+Malformed input throws `winrt::hresult_invalid_argument`; unsupported content
+throws `winrt::hresult_not_implemented`.
 
-## Using it
+## Validation tool
 
-```csharp
-var bytes = File.ReadAllBytes("Animation.lcomp");
-var root = CompositionInterpreter.LoadComposition(compositor, bytes);
+`LottieRuntimeTool.vcxproj` builds `LottieRuntime.exe`, a WinUI 2 validation and
+inspection harness that compiles the reader directly.
 
-ElementCompositionPreview.SetElementChildVisual(element, root);
+```powershell
+& "C:\Program Files\Microsoft Visual Studio\18\Professional\Common7\Tools\Launch-VsDevShell.ps1" -SkipAutomaticLocation
+msbuild .\source\LottieRuntime\LottieRuntimeTool.vcxproj /p:Platform=x64 /p:Configuration=Release
+```
+
+The executable is written to:
 
-// Drive the animation by setting Progress between 0 and 1.
-CompositionInterpreter.ProgressPropertySet(root).InsertScalar("Progress", 0.5f);
+```text
+source\LottieRuntime\x64\Release\LottieRuntime.exe
 ```
 
-The `Compositor` must belong to the calling thread, which must own a
-`DispatcherQueue` that outlives the returned visual tree.
-
-## Design
-
-**One function per category, not per type.** A node's concrete type is known only
-inside the function that creates it. The realization caches hold `Visual`,
-`CompositionShape`, `CompositionBrush`, `CompositionGeometry` and so on, and
-everything the interpreter does afterwards is declared on those types, so there is
-no point at which it has to ask what a node actually is. The state that every
-`CompositionObject` has is applied by one function that takes `CompositionObject`.
-
-**Runtime cost second.** Each node and string is realized at most once. Lookups are
-bounds-checked array indexing into the buffer's node vectors, because the caches are
-indexed identically to those vectors. The buffer is read in place.
-
-**Untrusted input.** A buffer may have come from a file or a download. It is checked
-for the `LCMP` identifier, run through the FlatBuffers verifier, and every index read
-out of it is range checked. Canvas geometries are checked for cycles and paths for
-figures that do not begin and end. A malformed buffer is reported as a
-`FlatBufferFormatException` and never reads outside the buffer. A buffer that needs a
-newer schema, or a Universal API contract that this version of Windows does not have,
-is reported as a `NotSupportedException` before any object is created.
-
-## Dependencies
-
-`Windows.UI.Composition`, Win2D for path geometry and the two effects that the
-translator emits, and `Google.FlatBuffers` for the generated schema binding. The
-native interpreter avoids Win2D by implementing the two Direct2D interop interfaces
-itself; that is not available to managed code, so a consumer of this interpreter
-takes the Win2D dependency, exactly as a consumer of `Instantiator` or of
-`LottieGen`'s C# output already does.
-
-## Incorporate it in a build
-
-`LottieRuntime.projitems` is a shared project. Import it into the application
-project and add a package reference to `Google.FlatBuffers`. The runtime imports
-the generated schema binding and format constants without bringing in the
-tool-side serializer, deserializer, or `WinCompData` model.
-
-Define `WINAPPSDK` when building for the Windows App SDK, which switches the
-interpreter from `Windows.UI.Composition` to `Microsoft.UI.Composition`. Define
-`PUBLIC_LottieRuntime` to make the type public.
-
-## Tests
-
-`tests/CompDataFlatbuffer.Tests` dumps the interpreted tree in the same canonical
-text as the `WinCompData` graph that the buffer was written from and asserts that the
-two are equal, for every animation in the sample corpus and for a synthetic graph
-that contains one of every node type. The same tests check that malformed, truncated
-and corrupted buffers are rejected. The composition APIs only exist on Windows, so
-the tests run against stand-ins for them, which is what makes the interpreter
-testable on any platform.
+It validates a buffer by default, prints the interpreted Composition hierarchy
+with `--dump`, or displays and animates it with `--show`:
+
+```powershell
+.\source\LottieRuntime\x64\Release\LottieRuntime.exe Animation.lcomp
+.\source\LottieRuntime\x64\Release\LottieRuntime.exe Animation.lcomp --dump
+.\source\LottieRuntime\x64\Release\LottieRuntime.exe Animation.lcomp --show
+```
diff --git a/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj b/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj
index 03c5c47e..5eaab357 100644
--- a/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj
+++ b/tests/CompDataFlatbuffer.Tests/CompDataFlatbuffer.Tests.csproj
@@ -21,7 +21,6 @@
   <Import Project="$(_SourceDir)GenericData\GenericData.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)LottieData\LottieData.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)LottieMetadata\LottieMetadata.projitems" Label="Shared" />
-  <Import Project="$(_SourceDir)LottieRuntime\LottieRuntime.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)LottieReader\LottieReader.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)LottieToWinComp\LottieToWinComp.projitems" Label="Shared" />
   <Import Project="$(_SourceDir)UIData\UIData.projitems" Label="Shared" />
diff --git a/tests/CompDataFlatbuffer.Tests/CompositionApiStandIns.cs b/tests/CompDataFlatbuffer.Tests/CompositionApiStandIns.cs
deleted file mode 100644
index 59bfc1e1..00000000
--- a/tests/CompDataFlatbuffer.Tests/CompositionApiStandIns.cs
+++ /dev/null
@@ -1,1112 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-// Stand-ins for the Windows.UI.Composition, Windows.UI.Xaml.Media and Win2D APIs
-// that CompositionInterpreter is written against.
-//
-// The interpreter's whole job is to make the right sequence of calls into those
-// APIs, and those APIs are only present on Windows. Rather than testing the
-// interpreter by looking at pixels on a Windows machine, these types stand in for
-// the real ones: they are declared in the real namespaces with the real names and
-// the members that the interpreter uses, and they record what was done to them so
-// that the resulting tree can be dumped and compared against the WinCompData graph
-// that produced the buffer.
-//
-// They are deliberately dumb. They contain no logic beyond recording, so a test
-// failure is always a fault in the interpreter rather than in the stand-ins. The
-// same technique is used by tests/Mocks.cs, which mocks Win2D so that LottieGen's
-// generated code can be compiled off Windows.
-//
-// Two details are modelled rather than merely recorded, because the dump depends
-// on them:
-//
-//  * A property that has never been set is distinguishable from one that has been
-//    set to its default value, which is what makes the dump comparable with the
-//    WinCompData dump. That is why the properties are nullable.
-//  * StartAnimation creates an AnimationController for every animation that is not
-//    an ExpressionAnimation, which is what Windows.UI.Composition does and what
-//    WinCompData models.
-#nullable enable
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Numerics;
-using Windows.Graphics.Effects;
-using Windows.Storage.Streams;
-using Windows.UI.Composition;
-using Mgc = Microsoft.Graphics.Canvas;
-using Mgcg = Microsoft.Graphics.Canvas.Geometry;
-
-namespace Windows.UI
-{
-    struct Color
-    {
-        public byte A { get; private set; }
-
-        public byte R { get; private set; }
-
-        public byte G { get; private set; }
-
-        public byte B { get; private set; }
-
-        public static Color FromArgb(byte a, byte r, byte g, byte b)
-            => new Color { A = a, R = r, G = g, B = b };
-    }
-}
-
-namespace Windows.Foundation.Metadata
-{
-    static class ApiInformation
-    {
-        // The version of the API contract that the stand-ins pretend to implement.
-        // It is well beyond any version that the translator asks for, so that a
-        // composition from the corpus always loads, and a test that wants the check
-        // to fail asks for a version that no version of Windows will ever have.
-        public const ushort UniversalApiContractVersion = 20;
-
-        public static bool IsApiContractPresent(string contractName, ushort majorVersion)
-            => contractName == "Windows.Foundation.UniversalApiContract" &&
-               majorVersion <= UniversalApiContractVersion;
-    }
-}
-
-namespace Windows.Graphics.Effects
-{
-    interface IGraphicsEffectSource
-    {
-    }
-
-    interface IGraphicsEffect : IGraphicsEffectSource
-    {
-    }
-}
-
-namespace Windows.Storage.Streams
-{
-    interface IBuffer
-    {
-        byte[] Bytes { get; }
-    }
-
-    interface IRandomAccessStream
-    {
-        byte[] Bytes { get; }
-    }
-
-    sealed class ByteArrayBuffer : IBuffer
-    {
-        internal ByteArrayBuffer(byte[] bytes) => Bytes = bytes;
-
-        public byte[] Bytes { get; }
-    }
-
-    sealed class RandomAccessStream : IRandomAccessStream
-    {
-        internal RandomAccessStream(byte[] bytes) => Bytes = bytes;
-
-        public byte[] Bytes { get; }
-    }
-
-    // Stands in for the stream that a byte array is wrapped in on the way to
-    // LoadedImageSurface. The bytes are carried through unchanged so that the dump
-    // can show what the surface was given.
-    sealed class ByteArrayStream : MemoryStream
-    {
-        internal ByteArrayStream(byte[] bytes)
-            : base(bytes, writable: false)
-        {
-            Bytes = bytes;
-        }
-
-        public byte[] Bytes { get; }
-    }
-}
-
-namespace System.Runtime.InteropServices.WindowsRuntime
-{
-    static class WindowsRuntimeBufferExtensions
-    {
-        public static IBuffer AsBuffer(this byte[] source) => new ByteArrayBuffer(source);
-
-        public static Stream AsStream(this IBuffer source) => new ByteArrayStream(source.Bytes);
-    }
-}
-
-namespace System.IO
-{
-    static class WindowsRuntimeStreamExtensions
-    {
-        public static IRandomAccessStream AsRandomAccessStream(this Stream source)
-            => new RandomAccessStream(((ByteArrayStream)source).Bytes);
-    }
-}
-
-namespace Microsoft.Graphics.Canvas
-{
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.Mgc.CanvasComposite.
-    enum CanvasComposite
-    {
-        SourceOver,
-        DestinationOver,
-        SourceIn,
-        DestinationIn,
-        SourceOut,
-        DestinationOut,
-        SourceAtop,
-        DestinationAtop,
-        Xor,
-        Add,
-        Copy,
-        BoundedCopy,
-        MaskInvert,
-    }
-}
-
-namespace Microsoft.Graphics.Canvas.Effects
-{
-    sealed class CompositeEffect : IGraphicsEffect
-    {
-        public Mgc.CanvasComposite Mode { get; set; }
-
-        public IList<IGraphicsEffectSource> Sources { get; } = new List<IGraphicsEffectSource>();
-    }
-
-    sealed class GaussianBlurEffect : IGraphicsEffect
-    {
-        public float BlurAmount { get; set; }
-
-        public IGraphicsEffectSource? Source { get; set; }
-    }
-}
-
-namespace Microsoft.Graphics.Canvas.Geometry
-{
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg.CanvasFigureLoop.
-    enum CanvasFigureLoop
-    {
-        Open,
-        Closed,
-    }
-
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg.CanvasFilledRegionDetermination.
-    enum CanvasFilledRegionDetermination
-    {
-        Alternate,
-        Winding,
-    }
-
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.Mgcg.CanvasGeometryCombine.
-    enum CanvasGeometryCombine
-    {
-        Union,
-        Exclude,
-        Intersect,
-        Xor,
-    }
-
-    // The shape of a geometry is recorded rather than rasterized. The nested types
-    // mirror the ones in WinCompData.Mgcg.CanvasGeometry so that the two can be
-    // compared.
-    abstract class CanvasGeometry
-    {
-        public static CanvasGeometry CreateEllipse(object? device, float x, float y, float radiusX, float radiusY)
-            => new Ellipse(x, y, radiusX, radiusY);
-
-        public static CanvasGeometry CreateRoundedRectangle(
-            object? device, float x, float y, float w, float h, float radiusX, float radiusY)
-            => new RoundedRectangle(x, y, w, h, radiusX, radiusY);
-
-        public static CanvasGeometry CreateGroup(
-            object? device, CanvasGeometry[] geometries, CanvasFilledRegionDetermination filledRegionDetermination)
-            => new Group(geometries, filledRegionDetermination);
-
-        public static CanvasGeometry CreatePath(CanvasPathBuilder builder)
-            => new Path(builder.Commands, builder.FilledRegionDetermination);
-
-        public CanvasGeometry CombineWith(
-            CanvasGeometry other, Matrix3x2 matrix, CanvasGeometryCombine combineMode)
-            => new Combination(this, other, matrix, combineMode);
-
-        public CanvasGeometry Transform(Matrix3x2 transformMatrix)
-            => new TransformedGeometry(this, transformMatrix);
-
-        public sealed class Combination : CanvasGeometry
-        {
-            internal Combination(CanvasGeometry a, CanvasGeometry b, Matrix3x2 matrix, CanvasGeometryCombine combineMode)
-                => (A, B, Matrix, CombineMode) = (a, b, matrix, combineMode);
-
-            public CanvasGeometry A { get; }
-
-            public CanvasGeometry B { get; }
-
-            public Matrix3x2 Matrix { get; }
-
-            public CanvasGeometryCombine CombineMode { get; }
-        }
-
-        public sealed class TransformedGeometry : CanvasGeometry
-        {
-            internal TransformedGeometry(CanvasGeometry sourceGeometry, Matrix3x2 transformMatrix)
-                => (SourceGeometry, TransformMatrix) = (sourceGeometry, transformMatrix);
-
-            public CanvasGeometry SourceGeometry { get; }
-
-            public Matrix3x2 TransformMatrix { get; }
-        }
-
-        public sealed class Group : CanvasGeometry
-        {
-            internal Group(CanvasGeometry[] geometries, CanvasFilledRegionDetermination filledRegionDetermination)
-                => (Geometries, FilledRegionDetermination) = (geometries, filledRegionDetermination);
-
-            public CanvasGeometry[] Geometries { get; }
-
-            public CanvasFilledRegionDetermination FilledRegionDetermination { get; }
-        }
-
-        public sealed class Path : CanvasGeometry
-        {
-            internal Path(
-                IReadOnlyList<CanvasPathBuilder.Command> commands,
-                CanvasFilledRegionDetermination filledRegionDetermination)
-                => (Commands, FilledRegionDetermination) = (commands, filledRegionDetermination);
-
-            public IReadOnlyList<CanvasPathBuilder.Command> Commands { get; }
-
-            public CanvasFilledRegionDetermination FilledRegionDetermination { get; }
-        }
-
-        public sealed class Ellipse : CanvasGeometry
-        {
-            internal Ellipse(float x, float y, float radiusX, float radiusY)
-                => (X, Y, RadiusX, RadiusY) = (x, y, radiusX, radiusY);
-
-            public float X { get; }
-
-            public float Y { get; }
-
-            public float RadiusX { get; }
-
-            public float RadiusY { get; }
-        }
-
-        public sealed class RoundedRectangle : CanvasGeometry
-        {
-            internal RoundedRectangle(float x, float y, float w, float h, float radiusX, float radiusY)
-                => (X, Y, W, H, RadiusX, RadiusY) = (x, y, w, h, radiusX, radiusY);
-
-            public float X { get; }
-
-            public float Y { get; }
-
-            public float W { get; }
-
-            public float H { get; }
-
-            public float RadiusX { get; }
-
-            public float RadiusY { get; }
-        }
-    }
-
-    sealed class CanvasPathBuilder : IDisposable
-    {
-        readonly List<Command> _commands = new List<Command>();
-
-        public CanvasPathBuilder(object? device)
-        {
-        }
-
-        internal IReadOnlyList<Command> Commands => _commands;
-
-        internal CanvasFilledRegionDetermination FilledRegionDetermination { get; private set; }
-
-        public void SetFilledRegionDetermination(CanvasFilledRegionDetermination value)
-            => FilledRegionDetermination = value;
-
-        public void BeginFigure(Vector2 startPoint) => _commands.Add(new Command.BeginFigure(startPoint));
-
-        public void EndFigure(CanvasFigureLoop figureLoop) => _commands.Add(new Command.EndFigure(figureLoop));
-
-        public void AddLine(Vector2 endPoint) => _commands.Add(new Command.AddLine(endPoint));
-
-        public void AddCubicBezier(Vector2 controlPoint1, Vector2 controlPoint2, Vector2 endPoint)
-            => _commands.Add(new Command.AddCubicBezier(controlPoint1, controlPoint2, endPoint));
-
-        public void Dispose()
-        {
-        }
-
-        internal abstract class Command
-        {
-            internal sealed class BeginFigure : Command
-            {
-                internal BeginFigure(Vector2 startPoint) => StartPoint = startPoint;
-
-                public Vector2 StartPoint { get; }
-            }
-
-            internal sealed class EndFigure : Command
-            {
-                internal EndFigure(CanvasFigureLoop figureLoop) => FigureLoop = figureLoop;
-
-                public CanvasFigureLoop FigureLoop { get; }
-            }
-
-            internal sealed class AddLine : Command
-            {
-                internal AddLine(Vector2 endPoint) => EndPoint = endPoint;
-
-                public Vector2 EndPoint { get; }
-            }
-
-            internal sealed class AddCubicBezier : Command
-            {
-                internal AddCubicBezier(Vector2 controlPoint1, Vector2 controlPoint2, Vector2 endPoint)
-                    => (ControlPoint1, ControlPoint2, EndPoint) = (controlPoint1, controlPoint2, endPoint);
-
-                public Vector2 ControlPoint1 { get; }
-
-                public Vector2 ControlPoint2 { get; }
-
-                public Vector2 EndPoint { get; }
-            }
-        }
-    }
-}
-
-namespace Windows.UI.Xaml.Media
-{
-    // The two loaded image surfaces are separate types here, unlike in the real API
-    // where one type is returned by both factories, so that the dump can tell them
-    // apart in the same way that the WinCompData dump does.
-    abstract class LoadedImageSurface : ICompositionSurface
-    {
-        public static LoadedImageSurface StartLoadFromUri(Uri uri) => new LoadedImageSurfaceFromUri(uri);
-
-        public static LoadedImageSurface StartLoadFromStream(IRandomAccessStream stream)
-            => new LoadedImageSurfaceFromStream(stream.Bytes);
-    }
-
-    sealed class LoadedImageSurfaceFromUri : LoadedImageSurface
-    {
-        internal LoadedImageSurfaceFromUri(Uri uri) => Uri = uri;
-
-        public Uri Uri { get; }
-    }
-
-    sealed class LoadedImageSurfaceFromStream : LoadedImageSurface
-    {
-        internal LoadedImageSurfaceFromStream(byte[] bytes) => Bytes = bytes;
-
-        public byte[] Bytes { get; }
-    }
-}
-
-namespace Windows.UI.Composition
-{
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionBorderMode.
-    enum CompositionBorderMode
-    {
-        Inherit = 0,
-        Soft = 1,
-        Hard = 2,
-    }
-
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionStrokeCap.
-    enum CompositionStrokeCap
-    {
-        Flat,
-        Square,
-        Round,
-        Triangle,
-    }
-
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionStrokeLineJoin.
-    enum CompositionStrokeLineJoin
-    {
-        Miter,
-        Bevel,
-        Round,
-        MiterOrBevel,
-    }
-
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionGradientExtendMode.
-    enum CompositionGradientExtendMode
-    {
-        Clamp = 0,
-        Wrap = 1,
-        Mirror = 2,
-    }
-
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionColorSpace.
-    enum CompositionColorSpace
-    {
-        Auto = 0,
-        Hsl = 1,
-        Rgb = 2,
-        HslLinear = 3,
-        RgbLinear = 4,
-    }
-
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionMappingMode.
-    enum CompositionMappingMode
-    {
-        Absolute = 0,
-        Relative = 1,
-    }
-
-    // Values match CommunityToolkit.WinUI.Lottie.WinCompData.CompositionDropShadowSourcePolicy.
-    enum CompositionDropShadowSourcePolicy
-    {
-        Default = 0,
-        InheritFromVisualContent = 1,
-    }
-
-    interface ICompositionSurface
-    {
-    }
-
-    abstract class CompositionObject
-    {
-        readonly List<Animator> _animators = new List<Animator>();
-
-        private protected CompositionObject()
-            => Properties = this as CompositionPropertySet ?? new CompositionPropertySet(this);
-
-        public string? Comment { get; set; }
-
-        public CompositionPropertySet Properties { get; }
-
-        internal IReadOnlyList<Animator> Animators => _animators;
-
-        public void StartAnimation(string propertyName, CompositionAnimation animation)
-            => StartAnimation(propertyName, animation, null);
-
-        public void StartAnimation(
-            string propertyName, CompositionAnimation animation, AnimationController? animationController)
-        {
-            // A controller comes into existence with the animation, unless the
-            // animation is an expression, which is driven by its inputs rather than by
-            // a clock and so has nothing to control.
-            var controller = animationController ??
-                (animation is ExpressionAnimation ? null : new AnimationController(this, propertyName));
-
-            _animators.Add(new Animator(propertyName, animation, controller));
-        }
-
-        public AnimationController? TryGetAnimationController(string propertyName)
-        {
-            foreach (var animator in _animators)
-            {
-                if (animator.AnimatedProperty == propertyName)
-                {
-                    return animator.Controller;
-                }
-            }
-
-            return null;
-        }
-
-        internal sealed class Animator
-        {
-            internal Animator(string animatedProperty, CompositionAnimation animation, AnimationController? controller)
-                => (AnimatedProperty, Animation, Controller) = (animatedProperty, animation, controller);
-
-            public string AnimatedProperty { get; }
-
-            public CompositionAnimation Animation { get; }
-
-            public AnimationController? Controller { get; }
-        }
-    }
-
-    sealed class AnimationController : CompositionObject
-    {
-        internal AnimationController(CompositionObject targetObject, string targetProperty)
-            => (TargetObject, TargetProperty) = (targetObject, targetProperty);
-
-        internal AnimationController()
-        {
-        }
-
-        public bool IsCustom => TargetObject is null;
-
-        public CompositionObject? TargetObject { get; }
-
-        public string? TargetProperty { get; }
-
-        public bool IsPaused { get; private set; }
-
-        public void Pause() => IsPaused = true;
-    }
-
-    enum PropertySetValueType
-    {
-        Color,
-        Scalar,
-        Vector2,
-        Vector3,
-        Vector4,
-    }
-
-    sealed class CompositionPropertySet : CompositionObject
-    {
-        // A SortedDictionary with the default comparer, exactly as WinCompData uses,
-        // so that the dump of a property set is in the same order on both sides.
-        readonly SortedDictionary<string, PropertySetValueType> _names =
-            new SortedDictionary<string, PropertySetValueType>();
-
-        readonly Dictionary<string, object> _values = new Dictionary<string, object>();
-
-        internal CompositionPropertySet(CompositionObject? owner) => Owner = owner;
-
-        public CompositionObject? Owner { get; }
-
-        internal IReadOnlyDictionary<string, PropertySetValueType> Names => _names;
-
-        public void InsertColor(string propertyName, UI.Color value)
-            => Insert(propertyName, PropertySetValueType.Color, value);
-
-        public void InsertScalar(string propertyName, float value)
-            => Insert(propertyName, PropertySetValueType.Scalar, value);
-
-        public void InsertVector2(string propertyName, Vector2 value)
-            => Insert(propertyName, PropertySetValueType.Vector2, value);
-
-        public void InsertVector3(string propertyName, Vector3 value)
-            => Insert(propertyName, PropertySetValueType.Vector3, value);
-
-        public void InsertVector4(string propertyName, Vector4 value)
-            => Insert(propertyName, PropertySetValueType.Vector4, value);
-
-        internal object GetValue(string propertyName) => _values[propertyName];
-
-        void Insert(string propertyName, PropertySetValueType type, object value)
-        {
-            _names[propertyName] = type;
-            _values[propertyName] = value;
-        }
-    }
-
-    sealed class CompositionPath
-    {
-        public CompositionPath(Mgcg.CanvasGeometry source) => Source = source;
-
-        public Mgcg.CanvasGeometry Source { get; }
-    }
-
-    sealed class CompositionEffectSourceParameter : IGraphicsEffectSource
-    {
-        public CompositionEffectSourceParameter(string name) => Name = name;
-
-        public string Name { get; }
-    }
-
-    abstract class Visual : CompositionObject
-    {
-        public CompositionBorderMode? BorderMode { get; set; }
-
-        public Vector3? CenterPoint { get; set; }
-
-        public CompositionClip? Clip { get; set; }
-
-        public bool? IsVisible { get; set; }
-
-        public Vector3? Offset { get; set; }
-
-        public float? Opacity { get; set; }
-
-        public float? RotationAngleInDegrees { get; set; }
-
-        public Vector3? RotationAxis { get; set; }
-
-        public Vector3? Scale { get; set; }
-
-        public Vector2? Size { get; set; }
-
-        public Matrix4x4? TransformMatrix { get; set; }
-    }
-
-    sealed class VisualCollection
-    {
-        readonly List<Visual> _visuals = new List<Visual>();
-
-        internal IReadOnlyList<Visual> Visuals => _visuals;
-
-        public void InsertAtTop(Visual visual) => _visuals.Add(visual);
-    }
-
-    class ContainerVisual : Visual
-    {
-        public VisualCollection Children { get; } = new VisualCollection();
-    }
-
-    sealed class ShapeVisual : ContainerVisual
-    {
-        public IList<CompositionShape> Shapes { get; } = new List<CompositionShape>();
-
-        public CompositionViewBox? ViewBox { get; set; }
-    }
-
-    sealed class SpriteVisual : ContainerVisual
-    {
-        public CompositionBrush? Brush { get; set; }
-
-        public CompositionShadow? Shadow { get; set; }
-    }
-
-    sealed class LayerVisual : ContainerVisual
-    {
-        public CompositionShadow? Shadow { get; set; }
-    }
-
-    abstract class CompositionShape : CompositionObject
-    {
-        public Vector2? CenterPoint { get; set; }
-
-        public Vector2? Offset { get; set; }
-
-        public float? RotationAngleInDegrees { get; set; }
-
-        public Vector2? Scale { get; set; }
-
-        public Matrix3x2? TransformMatrix { get; set; }
-    }
-
-    sealed class CompositionContainerShape : CompositionShape
-    {
-        public IList<CompositionShape> Shapes { get; } = new List<CompositionShape>();
-    }
-
-    sealed class CompositionSpriteShape : CompositionShape
-    {
-        public CompositionBrush? FillBrush { get; set; }
-
-        public CompositionBrush? StrokeBrush { get; set; }
-
-        public CompositionGeometry? Geometry { get; set; }
-
-        public bool? IsStrokeNonScaling { get; set; }
-
-        public float? StrokeDashOffset { get; set; }
-
-        public IList<float> StrokeDashArray { get; } = new List<float>();
-
-        public CompositionStrokeCap? StrokeDashCap { get; set; }
-
-        public CompositionStrokeCap? StrokeStartCap { get; set; }
-
-        public CompositionStrokeCap? StrokeEndCap { get; set; }
-
-        public CompositionStrokeLineJoin? StrokeLineJoin { get; set; }
-
-        public float? StrokeMiterLimit { get; set; }
-
-        public float? StrokeThickness { get; set; }
-    }
-
-    abstract class CompositionGeometry : CompositionObject
-    {
-        public float? TrimStart { get; set; }
-
-        public float? TrimEnd { get; set; }
-
-        public float? TrimOffset { get; set; }
-    }
-
-    sealed class CompositionPathGeometry : CompositionGeometry
-    {
-        public CompositionPath? Path { get; set; }
-    }
-
-    sealed class CompositionRectangleGeometry : CompositionGeometry
-    {
-        public Vector2? Offset { get; set; }
-
-        public Vector2? Size { get; set; }
-    }
-
-    sealed class CompositionRoundedRectangleGeometry : CompositionGeometry
-    {
-        public Vector2? Offset { get; set; }
-
-        public Vector2? Size { get; set; }
-
-        public Vector2? CornerRadius { get; set; }
-    }
-
-    sealed class CompositionEllipseGeometry : CompositionGeometry
-    {
-        public Vector2? Center { get; set; }
-
-        public Vector2? Radius { get; set; }
-    }
-
-    abstract class CompositionBrush : CompositionObject
-    {
-    }
-
-    sealed class CompositionColorBrush : CompositionBrush
-    {
-        public UI.Color? Color { get; set; }
-    }
-
-    abstract class CompositionGradientBrush : CompositionBrush
-    {
-        public Vector2? AnchorPoint { get; set; }
-
-        public Vector2? CenterPoint { get; set; }
-
-        public IList<CompositionColorGradientStop> ColorStops { get; } = new List<CompositionColorGradientStop>();
-
-        public CompositionGradientExtendMode? ExtendMode { get; set; }
-
-        public CompositionColorSpace? InterpolationSpace { get; set; }
-
-        public CompositionMappingMode? MappingMode { get; set; }
-
-        public Vector2? Offset { get; set; }
-
-        public float? RotationAngleInDegrees { get; set; }
-
-        public Vector2? Scale { get; set; }
-
-        public Matrix3x2? TransformMatrix { get; set; }
-    }
-
-    sealed class CompositionLinearGradientBrush : CompositionGradientBrush
-    {
-        public Vector2? StartPoint { get; set; }
-
-        public Vector2? EndPoint { get; set; }
-    }
-
-    sealed class CompositionRadialGradientBrush : CompositionGradientBrush
-    {
-        public Vector2? EllipseCenter { get; set; }
-
-        public Vector2? EllipseRadius { get; set; }
-
-        public Vector2? GradientOriginOffset { get; set; }
-    }
-
-    sealed class CompositionMaskBrush : CompositionBrush
-    {
-        public CompositionBrush? Source { get; set; }
-
-        public CompositionBrush? Mask { get; set; }
-    }
-
-    sealed class CompositionSurfaceBrush : CompositionBrush
-    {
-        internal CompositionSurfaceBrush(ICompositionSurface? surface) => Surface = surface;
-
-        public ICompositionSurface? Surface { get; set; }
-    }
-
-    sealed class CompositionEffectBrush : CompositionBrush
-    {
-        readonly Dictionary<string, CompositionBrush> _sources = new Dictionary<string, CompositionBrush>();
-        readonly CompositionEffectFactory _factory;
-
-        internal CompositionEffectBrush(CompositionEffectFactory factory) => _factory = factory;
-
-        public void SetSourceParameter(string name, CompositionBrush source) => _sources[name] = source;
-
-        internal CompositionEffectFactory GetEffectFactory() => _factory;
-
-        internal CompositionBrush? GetSourceParameter(string name)
-            => _sources.TryGetValue(name, out var result) ? result : null;
-    }
-
-    sealed class CompositionEffectFactory : CompositionObject
-    {
-        internal CompositionEffectFactory(IGraphicsEffect effect) => Effect = effect;
-
-        internal IGraphicsEffect Effect { get; }
-
-        public CompositionEffectBrush CreateBrush() => new CompositionEffectBrush(this);
-    }
-
-    sealed class CompositionColorGradientStop : CompositionObject
-    {
-        public UI.Color? Color { get; set; }
-
-        public float? Offset { get; set; }
-    }
-
-    sealed class CompositionViewBox : CompositionObject
-    {
-        public Vector2? Size { get; set; }
-    }
-
-    abstract class CompositionClip : CompositionObject
-    {
-        public Vector2? CenterPoint { get; set; }
-
-        public Vector2? Scale { get; set; }
-    }
-
-    sealed class InsetClip : CompositionClip
-    {
-        public float? LeftInset { get; set; }
-
-        public float? RightInset { get; set; }
-
-        public float? TopInset { get; set; }
-
-        public float? BottomInset { get; set; }
-    }
-
-    sealed class CompositionGeometricClip : CompositionClip
-    {
-        public CompositionGeometry? Geometry { get; set; }
-    }
-
-    abstract class CompositionShadow : CompositionObject
-    {
-    }
-
-    sealed class DropShadow : CompositionShadow
-    {
-        public float? BlurRadius { get; set; }
-
-        public UI.Color? Color { get; set; }
-
-        public CompositionBrush? Mask { get; set; }
-
-        public Vector3? Offset { get; set; }
-
-        public float? Opacity { get; set; }
-
-        public CompositionDropShadowSourcePolicy? SourcePolicy { get; set; }
-    }
-
-    sealed class CompositionVisualSurface : CompositionObject, ICompositionSurface
-    {
-        public Visual? SourceVisual { get; set; }
-
-        public Vector2? SourceSize { get; set; }
-
-        public Vector2? SourceOffset { get; set; }
-    }
-
-    abstract class CompositionEasingFunction : CompositionObject
-    {
-    }
-
-    sealed class LinearEasingFunction : CompositionEasingFunction
-    {
-    }
-
-    sealed class CubicBezierEasingFunction : CompositionEasingFunction
-    {
-        internal CubicBezierEasingFunction(Vector2 controlPoint1, Vector2 controlPoint2)
-            => (ControlPoint1, ControlPoint2) = (controlPoint1, controlPoint2);
-
-        public Vector2 ControlPoint1 { get; }
-
-        public Vector2 ControlPoint2 { get; }
-    }
-
-    sealed class StepEasingFunction : CompositionEasingFunction
-    {
-        public int? StepCount { get; set; }
-
-        public int? InitialStep { get; set; }
-
-        public int? FinalStep { get; set; }
-
-        public bool? IsInitialStepSingleFrame { get; set; }
-
-        public bool? IsFinalStepSingleFrame { get; set; }
-    }
-
-    abstract class CompositionAnimation : CompositionObject
-    {
-        readonly SortedDictionary<string, CompositionObject> _referenceParameters =
-            new SortedDictionary<string, CompositionObject>(StringComparer.Ordinal);
-
-        public string? Target { get; set; }
-
-        internal IReadOnlyDictionary<string, CompositionObject> ReferenceParameters => _referenceParameters;
-
-        public void SetReferenceParameter(string key, CompositionObject compositionObject)
-            => _referenceParameters[key] = compositionObject;
-    }
-
-    sealed class ExpressionAnimation : CompositionAnimation
-    {
-        internal ExpressionAnimation(string expression) => Expression = expression;
-
-        public string Expression { get; }
-    }
-
-    abstract class KeyFrameAnimation : CompositionAnimation
-    {
-        // Key frames are held in progress order and one deep per progress, which is
-        // what Windows.UI.Composition does and what makes the dump canonical.
-        readonly SortedList<float, KeyFrame> _keyFrames = new SortedList<float, KeyFrame>();
-
-        public TimeSpan Duration { get; set; }
-
-        internal IEnumerable<KeyFrame> KeyFrames => _keyFrames.Values;
-
-        public void InsertExpressionKeyFrame(float progress, string expression, CompositionEasingFunction? easing)
-            => Insert(new ExpressionKeyFrame(progress, easing, expression));
-
-        private protected void Insert(KeyFrame keyFrame) => _keyFrames[keyFrame.Progress] = keyFrame;
-
-        internal abstract class KeyFrame
-        {
-            private protected KeyFrame(float progress, CompositionEasingFunction? easing)
-                => (Progress, Easing) = (progress, easing);
-
-            public float Progress { get; }
-
-            public CompositionEasingFunction? Easing { get; }
-        }
-
-        internal sealed class ExpressionKeyFrame : KeyFrame
-        {
-            internal ExpressionKeyFrame(float progress, CompositionEasingFunction? easing, string expression)
-                : base(progress, easing)
-                => Expression = expression;
-
-            public string Expression { get; }
-        }
-
-        internal sealed class ValueKeyFrame : KeyFrame
-        {
-            internal ValueKeyFrame(float progress, CompositionEasingFunction? easing, object value)
-                : base(progress, easing)
-                => Value = value;
-
-            public object Value { get; }
-        }
-    }
-
-    sealed class ScalarKeyFrameAnimation : KeyFrameAnimation
-    {
-        public void InsertKeyFrame(float progress, float value, CompositionEasingFunction? easing)
-            => Insert(new ValueKeyFrame(progress, easing, value));
-    }
-
-    sealed class Vector2KeyFrameAnimation : KeyFrameAnimation
-    {
-        public void InsertKeyFrame(float progress, Vector2 value, CompositionEasingFunction? easing)
-            => Insert(new ValueKeyFrame(progress, easing, value));
-    }
-
-    sealed class Vector3KeyFrameAnimation : KeyFrameAnimation
-    {
-        public void InsertKeyFrame(float progress, Vector3 value, CompositionEasingFunction? easing)
-            => Insert(new ValueKeyFrame(progress, easing, value));
-    }
-
-    sealed class Vector4KeyFrameAnimation : KeyFrameAnimation
-    {
-        public void InsertKeyFrame(float progress, Vector4 value, CompositionEasingFunction? easing)
-            => Insert(new ValueKeyFrame(progress, easing, value));
-    }
-
-    sealed class ColorKeyFrameAnimation : KeyFrameAnimation
-    {
-        public CompositionColorSpace? InterpolationColorSpace { get; set; }
-
-        public void InsertKeyFrame(float progress, UI.Color value, CompositionEasingFunction? easing)
-            => Insert(new ValueKeyFrame(progress, easing, value));
-    }
-
-    sealed class BooleanKeyFrameAnimation : KeyFrameAnimation
-    {
-        public void InsertKeyFrame(float progress, bool value)
-            => Insert(new ValueKeyFrame(progress, null, value));
-    }
-
-    sealed class PathKeyFrameAnimation : KeyFrameAnimation
-    {
-        public void InsertKeyFrame(float progress, CompositionPath value, CompositionEasingFunction? easing)
-            => Insert(new ValueKeyFrame(progress, easing, value));
-    }
-
-    sealed class Compositor
-    {
-        public ContainerVisual CreateContainerVisual() => new ContainerVisual();
-
-        public ShapeVisual CreateShapeVisual() => new ShapeVisual();
-
-        public SpriteVisual CreateSpriteVisual() => new SpriteVisual();
-
-        public LayerVisual CreateLayerVisual() => new LayerVisual();
-
-        public CompositionContainerShape CreateContainerShape() => new CompositionContainerShape();
-
-        public CompositionSpriteShape CreateSpriteShape() => new CompositionSpriteShape();
-
-        public CompositionPathGeometry CreatePathGeometry() => new CompositionPathGeometry();
-
-        public CompositionRectangleGeometry CreateRectangleGeometry() => new CompositionRectangleGeometry();
-
-        public CompositionRoundedRectangleGeometry CreateRoundedRectangleGeometry()
-            => new CompositionRoundedRectangleGeometry();
-
-        public CompositionEllipseGeometry CreateEllipseGeometry() => new CompositionEllipseGeometry();
-
-        public CompositionColorBrush CreateColorBrush() => new CompositionColorBrush();
-
-        public CompositionLinearGradientBrush CreateLinearGradientBrush() => new CompositionLinearGradientBrush();
-
-        public CompositionRadialGradientBrush CreateRadialGradientBrush() => new CompositionRadialGradientBrush();
-
-        public CompositionMaskBrush CreateMaskBrush() => new CompositionMaskBrush();
-
-        public CompositionSurfaceBrush CreateSurfaceBrush(ICompositionSurface? surface)
-            => new CompositionSurfaceBrush(surface);
-
-        public CompositionEffectFactory CreateEffectFactory(IGraphicsEffect effect)
-            => new CompositionEffectFactory(effect);
-
-        public CompositionColorGradientStop CreateColorGradientStop() => new CompositionColorGradientStop();
-
-        public CompositionViewBox CreateViewBox() => new CompositionViewBox();
-
-        public InsetClip CreateInsetClip() => new InsetClip();
-
-        public CompositionGeometricClip CreateGeometricClip() => new CompositionGeometricClip();
-
-        public DropShadow CreateDropShadow() => new DropShadow();
-
-        public CompositionVisualSurface CreateVisualSurface() => new CompositionVisualSurface();
-
-        public CompositionPropertySet CreatePropertySet() => new CompositionPropertySet(null);
-
-        public AnimationController CreateAnimationController() => new AnimationController();
-
-        public LinearEasingFunction CreateLinearEasingFunction() => new LinearEasingFunction();
-
-        public CubicBezierEasingFunction CreateCubicBezierEasingFunction(Vector2 controlPoint1, Vector2 controlPoint2)
-            => new CubicBezierEasingFunction(controlPoint1, controlPoint2);
-
-        public StepEasingFunction CreateStepEasingFunction() => new StepEasingFunction();
-
-        public ExpressionAnimation CreateExpressionAnimation(string expression) => new ExpressionAnimation(expression);
-
-        public ScalarKeyFrameAnimation CreateScalarKeyFrameAnimation() => new ScalarKeyFrameAnimation();
-
-        public Vector2KeyFrameAnimation CreateVector2KeyFrameAnimation() => new Vector2KeyFrameAnimation();
-
-        public Vector3KeyFrameAnimation CreateVector3KeyFrameAnimation() => new Vector3KeyFrameAnimation();
-
-        public Vector4KeyFrameAnimation CreateVector4KeyFrameAnimation() => new Vector4KeyFrameAnimation();
-
-        public ColorKeyFrameAnimation CreateColorKeyFrameAnimation() => new ColorKeyFrameAnimation();
-
-        public BooleanKeyFrameAnimation CreateBooleanKeyFrameAnimation() => new BooleanKeyFrameAnimation();
-
-        public PathKeyFrameAnimation CreatePathKeyFrameAnimation() => new PathKeyFrameAnimation();
-    }
-}
diff --git a/tests/CompDataFlatbuffer.Tests/CoverageTests.cs b/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
index 547b6d54..b06281cf 100644
--- a/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
+++ b/tests/CompDataFlatbuffer.Tests/CoverageTests.cs
@@ -61,23 +61,6 @@ public void EveryNodeTypeSurvivesARoundTrip()
             Assert.Equal(expected, actual);
         }
 
-        [Fact]
-        public void EveryNodeTypeIsInterpreted()
-        {
-            var root = BuildGraph();
-
-            // The interpreter has a branch per node type just as the deserializer does,
-            // so it is held to the same standard: every node type that a graph can
-            // contain must come out of the buffer unchanged.
-            var expected = CompositionTreeDumper.Dump(root);
-            var actual = InterpretedTreeDumper.Dump(
-                LottieRuntime.CompositionInterpreter.LoadComposition(
-                    new Windows.UI.Composition.Compositor(),
-                    CompositionSerializer.Serialize(root, 14, null, null, 100, 100)));
-
-            Assert.Equal(expected, actual);
-        }
-
         // Builds a graph containing one of everything. It is not a sensible animation;
         // its only job is to reach every branch of the serializer and the deserializer.
         static Visual BuildGraph()
diff --git a/tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs b/tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs
deleted file mode 100644
index 82035b07..00000000
--- a/tests/CompDataFlatbuffer.Tests/InterpretedTreeDumper.cs
+++ /dev/null
@@ -1,805 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#nullable enable
-
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Numerics;
-using System.Text;
-using Microsoft.Graphics.Canvas.Geometry;
-using Windows.Graphics.Effects;
-using Windows.UI.Composition;
-using Windows.UI.Xaml.Media;
-using Mgce = Microsoft.Graphics.Canvas.Effects;
-using Wui = Windows.UI;
-
-namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Tests
-{
-    /// <summary>
-    /// Renders a tree of composition objects as canonical text.
-    /// </summary>
-    /// <remarks>
-    /// This is <see cref="CompositionTreeDumper"/> for the tree that
-    /// <c>CompositionInterpreter</c> builds. It writes the same text for the same
-    /// animation, which is what lets the interpreter be compared against the
-    /// WinCompData graph that the buffer was written from: the graph and the
-    /// interpreted tree are different object models, but if the two dumps are equal
-    /// then the interpreter created the same objects, gave them the same values, and
-    /// shared them in the same way.
-    /// <para/>
-    /// The two dumpers are deliberately not factored into one. Each is a plain
-    /// description of one object model, and keeping them separate means neither can
-    /// paper over a difference by describing both models in the same terms.
-    /// </remarks>
-    static class InterpretedTreeDumper
-    {
-        /// <summary>
-        /// Renders an interpreted tree as canonical text.
-        /// </summary>
-        /// <param name="root">The root of the tree.</param>
-        /// <returns>The canonical text of the tree.</returns>
-        public static string Dump(Visual root)
-        {
-            var writer = new Writer();
-            writer.WriteVisual(root);
-            return writer.ToString();
-        }
-
-        sealed class Writer
-        {
-            readonly StringBuilder _builder = new StringBuilder();
-
-            readonly Dictionary<object, int> _ids =
-                new Dictionary<object, int>(ReferenceEqualityComparer.Instance);
-
-            int _indent;
-
-            public override string ToString() => _builder.ToString();
-
-            public void WriteVisual(Visual? value)
-            {
-                if (WriteNodeHeader(value, "Visual"))
-                {
-                    return;
-                }
-
-                WriteCompositionObject(value!);
-
-                WriteOptional("BorderMode", value!.BorderMode);
-                WriteOptional("CenterPoint", value.CenterPoint);
-                WriteChild("Clip", value.Clip, WriteClip);
-                WriteOptional("IsVisible", value.IsVisible);
-                WriteOptional("Offset", value.Offset);
-                WriteOptional("Opacity", value.Opacity);
-                WriteOptional("RotationAngleInDegrees", value.RotationAngleInDegrees);
-                WriteOptional("RotationAxis", value.RotationAxis);
-                WriteOptional("Scale", value.Scale);
-                WriteOptional("Size", value.Size);
-                WriteOptional("TransformMatrix", value.TransformMatrix);
-
-                if (value is ContainerVisual container)
-                {
-                    WriteList("Children", container.Children.Visuals, WriteVisual);
-                }
-
-                switch (value)
-                {
-                    case ShapeVisual shapeVisual:
-                        WriteList("Shapes", shapeVisual.Shapes, WriteShape);
-                        WriteChild("ViewBox", shapeVisual.ViewBox, WriteViewBox);
-                        break;
-                    case SpriteVisual spriteVisual:
-                        WriteChild("Brush", spriteVisual.Brush, WriteBrush);
-                        WriteChild("Shadow", spriteVisual.Shadow, WriteShadow);
-                        break;
-                    case LayerVisual layerVisual:
-                        WriteChild("Shadow", layerVisual.Shadow, WriteShadow);
-                        break;
-                    case ContainerVisual _:
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected visual {value.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            public void WriteShape(CompositionShape? value)
-            {
-                if (WriteNodeHeader(value, "Shape"))
-                {
-                    return;
-                }
-
-                WriteCompositionObject(value!);
-
-                WriteOptional("CenterPoint", value!.CenterPoint);
-                WriteOptional("Offset", value.Offset);
-                WriteOptional("RotationAngleInDegrees", value.RotationAngleInDegrees);
-                WriteOptional("Scale", value.Scale);
-                WriteOptional("TransformMatrix", value.TransformMatrix);
-
-                switch (value)
-                {
-                    case CompositionContainerShape containerShape:
-                        WriteList("Shapes", containerShape.Shapes, WriteShape);
-                        break;
-                    case CompositionSpriteShape spriteShape:
-                        WriteChild("FillBrush", spriteShape.FillBrush, WriteBrush);
-                        WriteChild("StrokeBrush", spriteShape.StrokeBrush, WriteBrush);
-                        WriteChild("Geometry", spriteShape.Geometry, WriteGeometry);
-                        WriteOptional("IsStrokeNonScaling", spriteShape.IsStrokeNonScaling);
-                        WriteOptional("StrokeDashOffset", spriteShape.StrokeDashOffset);
-                        WriteFloats("StrokeDashArray", spriteShape.StrokeDashArray);
-                        WriteOptional("StrokeDashCap", spriteShape.StrokeDashCap);
-                        WriteOptional("StrokeStartCap", spriteShape.StrokeStartCap);
-                        WriteOptional("StrokeEndCap", spriteShape.StrokeEndCap);
-                        WriteOptional("StrokeLineJoin", spriteShape.StrokeLineJoin);
-                        WriteOptional("StrokeMiterLimit", spriteShape.StrokeMiterLimit);
-                        WriteOptional("StrokeThickness", spriteShape.StrokeThickness);
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected shape {value.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            public void WriteGeometry(CompositionGeometry? value)
-            {
-                if (WriteNodeHeader(value, "Geometry"))
-                {
-                    return;
-                }
-
-                WriteCompositionObject(value!);
-
-                WriteOptional("TrimStart", value!.TrimStart);
-                WriteOptional("TrimEnd", value.TrimEnd);
-                WriteOptional("TrimOffset", value.TrimOffset);
-
-                switch (value)
-                {
-                    case CompositionPathGeometry pathGeometry:
-                        WriteChild("Path", pathGeometry.Path?.Source, WriteCanvasGeometry);
-                        break;
-                    case CompositionRoundedRectangleGeometry roundedRectangle:
-                        WriteOptional("Offset", roundedRectangle.Offset);
-                        WriteOptional("Size", roundedRectangle.Size);
-                        Write("CornerRadius", roundedRectangle.CornerRadius ?? default);
-                        break;
-                    case CompositionRectangleGeometry rectangle:
-                        WriteOptional("Offset", rectangle.Offset);
-                        WriteOptional("Size", rectangle.Size);
-                        break;
-                    case CompositionEllipseGeometry ellipse:
-                        Write("Center", ellipse.Center ?? default);
-                        Write("Radius", ellipse.Radius ?? default);
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected geometry {value.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            public void WriteBrush(CompositionBrush? value)
-            {
-                if (WriteNodeHeader(value, "Brush"))
-                {
-                    return;
-                }
-
-                WriteCompositionObject(value!);
-
-                switch (value)
-                {
-                    case CompositionColorBrush colorBrush:
-                        WriteOptional("Color", colorBrush.Color);
-                        break;
-                    case CompositionMaskBrush maskBrush:
-                        WriteChild("Source", maskBrush.Source, WriteBrush);
-                        WriteChild("Mask", maskBrush.Mask, WriteBrush);
-                        break;
-                    case CompositionSurfaceBrush surfaceBrush:
-                        WriteChild("Surface", surfaceBrush.Surface, WriteSurface);
-                        break;
-                    case CompositionEffectBrush effectBrush:
-                        var effect = effectBrush.GetEffectFactory().Effect;
-                        WriteChild("Effect", effect, WriteEffect);
-
-                        foreach (var source in SourcesOf(effect))
-                        {
-                            WriteChild(
-                                $"Source({source.Name})",
-                                effectBrush.GetSourceParameter(source.Name),
-                                WriteBrush);
-                        }
-
-                        break;
-                    case CompositionLinearGradientBrush _:
-                    case CompositionRadialGradientBrush _:
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected brush {value!.GetType().Name}.");
-                }
-
-                if (value is CompositionGradientBrush gradientBrush)
-                {
-                    WriteOptional("AnchorPoint", gradientBrush.AnchorPoint);
-                    WriteOptional("CenterPoint", gradientBrush.CenterPoint);
-                    WriteList("ColorStops", gradientBrush.ColorStops, WriteGradientStop);
-                    WriteOptional("ExtendMode", gradientBrush.ExtendMode);
-                    WriteOptional("InterpolationSpace", gradientBrush.InterpolationSpace);
-                    WriteOptional("MappingMode", gradientBrush.MappingMode);
-                    WriteOptional("Offset", gradientBrush.Offset);
-                    WriteOptional("RotationAngleInDegrees", gradientBrush.RotationAngleInDegrees);
-                    WriteOptional("Scale", gradientBrush.Scale);
-                    WriteOptional("TransformMatrix", gradientBrush.TransformMatrix);
-
-                    switch (gradientBrush)
-                    {
-                        case CompositionLinearGradientBrush linear:
-                            WriteOptional("StartPoint", linear.StartPoint);
-                            WriteOptional("EndPoint", linear.EndPoint);
-                            break;
-                        case CompositionRadialGradientBrush radial:
-                            WriteOptional("EllipseCenter", radial.EllipseCenter);
-                            WriteOptional("EllipseRadius", radial.EllipseRadius);
-                            WriteOptional("GradientOriginOffset", radial.GradientOriginOffset);
-                            break;
-                    }
-                }
-
-                _indent--;
-            }
-
-            public void WriteGradientStop(CompositionColorGradientStop? value)
-            {
-                if (WriteNodeHeader(value, "GradientStop"))
-                {
-                    return;
-                }
-
-                WriteCompositionObject(value!);
-                Write("Color", value!.Color ?? default);
-                Write("Offset", value.Offset ?? default);
-                _indent--;
-            }
-
-            public void WriteViewBox(CompositionViewBox? value)
-            {
-                if (WriteNodeHeader(value, "ViewBox"))
-                {
-                    return;
-                }
-
-                WriteCompositionObject(value!);
-                Write("Size", value!.Size ?? default);
-                _indent--;
-            }
-
-            public void WriteClip(CompositionClip? value)
-            {
-                if (WriteNodeHeader(value, "Clip"))
-                {
-                    return;
-                }
-
-                WriteCompositionObject(value!);
-                WriteOptional("CenterPoint", value!.CenterPoint);
-                WriteOptional("Scale", value.Scale);
-
-                switch (value)
-                {
-                    case InsetClip inset:
-                        WriteOptional("LeftInset", inset.LeftInset);
-                        WriteOptional("RightInset", inset.RightInset);
-                        WriteOptional("TopInset", inset.TopInset);
-                        WriteOptional("BottomInset", inset.BottomInset);
-                        break;
-                    case CompositionGeometricClip geometric:
-                        WriteChild("Geometry", geometric.Geometry, WriteGeometry);
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected clip {value.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            public void WriteShadow(CompositionShadow? value)
-            {
-                if (WriteNodeHeader(value, "Shadow"))
-                {
-                    return;
-                }
-
-                WriteCompositionObject(value!);
-
-                switch (value)
-                {
-                    case DropShadow dropShadow:
-                        WriteOptional("BlurRadius", dropShadow.BlurRadius);
-                        WriteOptional("Color", dropShadow.Color);
-                        WriteChild("Mask", dropShadow.Mask, WriteBrush);
-                        WriteOptional("Offset", dropShadow.Offset);
-                        WriteOptional("Opacity", dropShadow.Opacity);
-                        WriteOptional("SourcePolicy", dropShadow.SourcePolicy);
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected shadow {value!.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            public void WriteSurface(ICompositionSurface? value)
-            {
-                if (WriteNodeHeader(value, "Surface"))
-                {
-                    return;
-                }
-
-                switch (value)
-                {
-                    case CompositionVisualSurface visualSurface:
-                        WriteCompositionObject(visualSurface);
-                        WriteChild("SourceVisual", visualSurface.SourceVisual, WriteVisual);
-                        WriteOptional("SourceSize", visualSurface.SourceSize);
-                        WriteOptional("SourceOffset", visualSurface.SourceOffset);
-                        break;
-                    case LoadedImageSurfaceFromUri fromUri:
-                        WriteLine($"Kind: FromUri");
-                        WriteLine($"Uri: {fromUri.Uri}");
-                        break;
-                    case LoadedImageSurfaceFromStream fromStream:
-                        WriteLine($"Kind: FromStream");
-                        WriteLine($"Bytes: {Convert.ToBase64String(fromStream.Bytes)}");
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected surface {value!.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            public void WriteEffect(IGraphicsEffect? value)
-            {
-                if (WriteNodeHeader(value, "Effect"))
-                {
-                    return;
-                }
-
-                WriteLine($"Sources: {string.Join(", ", SourcesOf(value!).Select(s => s.Name))}");
-
-                switch (value)
-                {
-                    case Mgce.CompositeEffect composite:
-                        Write("Mode", composite.Mode);
-                        break;
-                    case Mgce.GaussianBlurEffect blur:
-                        Write("BlurAmount", blur.BlurAmount);
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected effect {value!.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            public void WriteEasing(CompositionEasingFunction? value)
-            {
-                if (WriteNodeHeader(value, "Easing"))
-                {
-                    return;
-                }
-
-                WriteCompositionObject(value!);
-
-                switch (value)
-                {
-                    case LinearEasingFunction _:
-                        break;
-                    case CubicBezierEasingFunction cubicBezier:
-                        Write("ControlPoint1", cubicBezier.ControlPoint1);
-                        Write("ControlPoint2", cubicBezier.ControlPoint2);
-                        break;
-                    case StepEasingFunction step:
-                        WriteOptional("StepCount", step.StepCount);
-                        WriteOptional("InitialStep", step.InitialStep);
-                        WriteOptional("FinalStep", step.FinalStep);
-                        WriteOptional("IsInitialStepSingleFrame", step.IsInitialStepSingleFrame);
-                        WriteOptional("IsFinalStepSingleFrame", step.IsFinalStepSingleFrame);
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected easing {value!.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            public void WriteAnimation(CompositionAnimation? value)
-            {
-                if (WriteNodeHeader(value, "Animation"))
-                {
-                    return;
-                }
-
-                WriteCompositionObject(value!);
-                WriteLine($"Target: {Text(value!.Target)}");
-
-                foreach (var parameter in value.ReferenceParameters.OrderBy(p => p.Key, StringComparer.Ordinal))
-                {
-                    WriteChild($"Reference({parameter.Key})", parameter.Value, WriteCompositionObjectReference);
-                }
-
-                switch (value)
-                {
-                    case ExpressionAnimation expression:
-                        WriteLine($"Expression: {expression.Expression}");
-                        break;
-                    case KeyFrameAnimation keyFrameAnimation:
-                        WriteLine($"Duration: {keyFrameAnimation.Duration.Ticks}");
-
-                        if (value is ColorKeyFrameAnimation color)
-                        {
-                            Write("InterpolationColorSpace", color.InterpolationColorSpace ?? CompositionColorSpace.Auto);
-                        }
-
-                        foreach (var keyFrame in keyFrameAnimation.KeyFrames)
-                        {
-                            WriteKeyFrame(keyFrame);
-                        }
-
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected animation {value.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            void WriteKeyFrame(KeyFrameAnimation.KeyFrame value)
-            {
-                WriteLine($"KeyFrame @{Text(value.Progress)}");
-                _indent++;
-                WriteChild("Easing", value.Easing, WriteEasing);
-
-                switch (value)
-                {
-                    case KeyFrameAnimation.ExpressionKeyFrame expression:
-                        WriteLine($"Expression: {expression.Expression}");
-                        break;
-                    case KeyFrameAnimation.ValueKeyFrame valueKeyFrame:
-                        if (valueKeyFrame.Value is CompositionPath path)
-                        {
-                            WriteChild("Value", path.Source, WriteCanvasGeometry);
-                        }
-                        else
-                        {
-                            WriteLine($"Value: {Text(valueKeyFrame.Value)}");
-                        }
-
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected key frame {value.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            public void WriteCanvasGeometry(CanvasGeometry? value)
-            {
-                if (WriteNodeHeader(value, "CanvasGeometry"))
-                {
-                    return;
-                }
-
-                switch (value)
-                {
-                    case CanvasGeometry.Combination combination:
-                        WriteChild("A", combination.A, WriteCanvasGeometry);
-                        WriteChild("B", combination.B, WriteCanvasGeometry);
-                        Write("CombineMode", combination.CombineMode);
-                        Write("Matrix", combination.Matrix);
-                        break;
-                    case CanvasGeometry.TransformedGeometry transformed:
-                        WriteChild("Source", transformed.SourceGeometry, WriteCanvasGeometry);
-                        Write("TransformMatrix", transformed.TransformMatrix);
-                        break;
-                    case CanvasGeometry.Group group:
-                        Write("FilledRegionDetermination", group.FilledRegionDetermination);
-                        WriteList("Geometries", group.Geometries, WriteCanvasGeometry);
-                        break;
-                    case CanvasGeometry.Path path:
-                        Write("FilledRegionDetermination", path.FilledRegionDetermination);
-
-                        foreach (var command in path.Commands)
-                        {
-                            WriteLine(Text(command));
-                        }
-
-                        break;
-                    case CanvasGeometry.Ellipse ellipse:
-                        WriteLine(
-                            $"Ellipse: {Text(ellipse.X)} {Text(ellipse.Y)} " +
-                            $"{Text(ellipse.RadiusX)} {Text(ellipse.RadiusY)}");
-                        break;
-                    case CanvasGeometry.RoundedRectangle rectangle:
-                        WriteLine(
-                            $"RoundedRectangle: {Text(rectangle.X)} {Text(rectangle.Y)} " +
-                            $"{Text(rectangle.W)} {Text(rectangle.H)} " +
-                            $"{Text(rectangle.RadiusX)} {Text(rectangle.RadiusY)}");
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected canvas geometry {value!.GetType().Name}.");
-                }
-
-                _indent--;
-            }
-
-            void WriteCompositionObjectReference(CompositionObject? value)
-            {
-                switch (value)
-                {
-                    case null:
-                        WriteLine("null");
-                        break;
-                    case Visual visual:
-                        WriteVisual(visual);
-                        break;
-                    case CompositionShape shape:
-                        WriteShape(shape);
-                        break;
-                    case CompositionGeometry geometry:
-                        WriteGeometry(geometry);
-                        break;
-                    case CompositionBrush brush:
-                        WriteBrush(brush);
-                        break;
-                    case CompositionAnimation animation:
-                        WriteAnimation(animation);
-                        break;
-                    case CompositionEasingFunction easing:
-                        WriteEasing(easing);
-                        break;
-                    case CompositionPropertySet propertySet:
-                        WritePropertySet(propertySet);
-                        break;
-                    case CompositionVisualSurface surface:
-                        WriteSurface(surface);
-                        break;
-                    case CompositionClip clip:
-                        WriteClip(clip);
-                        break;
-                    case AnimationController controller:
-                        WriteController(controller);
-                        break;
-                    case CompositionShadow shadow:
-                        WriteShadow(shadow);
-                        break;
-                    case CompositionColorGradientStop stop:
-                        WriteGradientStop(stop);
-                        break;
-                    case CompositionViewBox viewBox:
-                        WriteViewBox(viewBox);
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Unexpected reference to {value.GetType().Name}.");
-                }
-            }
-
-            void WritePropertySet(CompositionPropertySet? value)
-            {
-                if (WriteNodeHeader(value, "PropertySet"))
-                {
-                    return;
-                }
-
-                WritePropertySetContents(value!);
-                _indent--;
-            }
-
-            void WriteController(AnimationController? value)
-            {
-                if (WriteNodeHeader(value, "Controller"))
-                {
-                    return;
-                }
-
-                WriteLine($"IsCustom: {value!.IsCustom}");
-                WriteLine($"IsPaused: {value.IsPaused}");
-                WriteLine($"TargetProperty: {Text(value.TargetProperty)}");
-                WriteCompositionObject(value);
-                _indent--;
-            }
-
-            void WriteCompositionObject(CompositionObject value)
-            {
-                if (value.Comment is not null)
-                {
-                    WriteLine($"Comment: {value.Comment}");
-                }
-
-                var properties = value.Properties;
-                if (value is not CompositionPropertySet &&
-                    (properties.Names.Count > 0 || properties.Animators.Count > 0))
-                {
-                    WriteLine("Properties");
-                    _indent++;
-                    WritePropertySetContents(properties);
-                    _indent--;
-                }
-
-                foreach (var animator in value.Animators)
-                {
-                    WriteLine($"Animator: {animator.AnimatedProperty}");
-                    _indent++;
-                    WriteChild("Animation", animator.Animation, WriteAnimation);
-
-                    if (animator.Controller is not null)
-                    {
-                        WriteChild("Controller", animator.Controller, WriteController);
-                    }
-
-                    _indent--;
-                }
-            }
-
-            void WritePropertySetContents(CompositionPropertySet value)
-            {
-                foreach (var name in value.Names.Keys)
-                {
-                    WriteLine($"{name}: {Text(value.GetValue(name))}");
-                }
-
-                foreach (var animator in value.Animators)
-                {
-                    WriteLine($"Animator: {animator.AnimatedProperty}");
-                    _indent++;
-                    WriteChild("Animation", animator.Animation, WriteAnimation);
-                    _indent--;
-                }
-            }
-
-            // The sources of an effect, in the order that they were given to it.
-            static IEnumerable<CompositionEffectSourceParameter> SourcesOf(IGraphicsEffect effect)
-                => effect switch
-                {
-                    Mgce.CompositeEffect composite => composite.Sources.Cast<CompositionEffectSourceParameter>(),
-                    Mgce.GaussianBlurEffect blur => new[] { (CompositionEffectSourceParameter)blur.Source! },
-                    _ => throw new InvalidOperationException($"Unexpected effect {effect.GetType().Name}."),
-                };
-
-            bool WriteNodeHeader(object? value, string category)
-            {
-                if (value is null)
-                {
-                    WriteLine($"{category}: null");
-                    return true;
-                }
-
-                if (_ids.TryGetValue(value, out var existing))
-                {
-                    WriteLine($"{category} #{existing} (shared)");
-                    return true;
-                }
-
-                var id = _ids.Count;
-                _ids.Add(value, id);
-                WriteLine($"{category} #{id} {TypeNameOf(value)}");
-                _indent++;
-                return false;
-            }
-
-            // The names of the stand-in types are the names of the real composition
-            // types, which are also the names of the WinCompData types, so the two
-            // dumps name the same object identically.
-            static string TypeNameOf(object value)
-                => value switch
-                {
-                    LoadedImageSurfaceFromUri _ => "FromUri",
-                    LoadedImageSurfaceFromStream _ => "FromStream",
-                    _ => value.GetType().Name,
-                };
-
-            void WriteChild<T>(string name, T? value, Action<T?> write)
-                where T : class
-            {
-                WriteLine($"{name}:");
-                _indent++;
-                write(value);
-                _indent--;
-            }
-
-            void WriteList<T>(string name, IEnumerable<T> values, Action<T?> write)
-                where T : class
-            {
-                var array = values.ToArray();
-                if (array.Length == 0)
-                {
-                    return;
-                }
-
-                WriteLine($"{name}: [{array.Length}]");
-                _indent++;
-                foreach (var value in array)
-                {
-                    write(value);
-                }
-
-                _indent--;
-            }
-
-            void WriteOptional<T>(string name, T? value)
-                where T : struct
-            {
-                if (value.HasValue)
-                {
-                    WriteLine($"{name}: {Text(value.Value)}");
-                }
-            }
-
-            void Write<T>(string name, T value)
-                where T : struct
-                => WriteLine($"{name}: {Text(value)}");
-
-            void WriteFloats(string name, IEnumerable<float> values)
-            {
-                var array = values.ToArray();
-                if (array.Length > 0)
-                {
-                    WriteLine($"{name}: {string.Join(", ", array.Select(v => Text(v)))}");
-                }
-            }
-
-            void WriteLine(string text)
-                => _builder.Append(' ', _indent * 2).Append(text).Append('\n');
-
-            static string Text(object? value)
-                => value switch
-                {
-                    null => "null",
-                    float f => f.ToString("R", CultureInfo.InvariantCulture),
-                    Vector2 v => $"<{Text(v.X)}, {Text(v.Y)}>",
-                    Vector3 v => $"<{Text(v.X)}, {Text(v.Y)}, {Text(v.Z)}>",
-                    Vector4 v => $"<{Text(v.X)}, {Text(v.Y)}, {Text(v.Z)}, {Text(v.W)}>",
-                    Matrix3x2 m =>
-                        $"[{Text(m.M11)}, {Text(m.M12)}, {Text(m.M21)}, " +
-                        $"{Text(m.M22)}, {Text(m.M31)}, {Text(m.M32)}]",
-                    Matrix4x4 m =>
-                        $"[{Text(m.M11)}, {Text(m.M12)}, {Text(m.M13)}, {Text(m.M14)}, " +
-                        $"{Text(m.M21)}, {Text(m.M22)}, {Text(m.M23)}, {Text(m.M24)}, " +
-                        $"{Text(m.M31)}, {Text(m.M32)}, {Text(m.M33)}, {Text(m.M34)}, " +
-                        $"{Text(m.M41)}, {Text(m.M42)}, {Text(m.M43)}, {Text(m.M44)}]",
-                    Wui.Color c => $"#{c.A:X2}{c.R:X2}{c.G:X2}{c.B:X2}",
-                    CanvasPathBuilder.Command.BeginFigure begin => $"BeginFigure {Text(begin.StartPoint)}",
-                    CanvasPathBuilder.Command.EndFigure end => $"EndFigure {end.FigureLoop}",
-                    CanvasPathBuilder.Command.AddLine line => $"AddLine {Text(line.EndPoint)}",
-                    CanvasPathBuilder.Command.AddCubicBezier bezier =>
-                        $"AddCubicBezier {Text(bezier.ControlPoint1)} " +
-                        $"{Text(bezier.ControlPoint2)} {Text(bezier.EndPoint)}",
-                    _ => value.ToString() ?? string.Empty,
-                };
-        }
-
-        sealed class ReferenceEqualityComparer : IEqualityComparer<object>
-        {
-            internal static readonly ReferenceEqualityComparer Instance = new ReferenceEqualityComparer();
-
-            ReferenceEqualityComparer()
-            {
-            }
-
-            bool IEqualityComparer<object>.Equals(object? x, object? y) => ReferenceEquals(x, y);
-
-            int IEqualityComparer<object>.GetHashCode(object obj)
-                => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
-        }
-    }
-}
diff --git a/tests/CompDataFlatbuffer.Tests/InterpreterTests.cs b/tests/CompDataFlatbuffer.Tests/InterpreterTests.cs
deleted file mode 100644
index 224cbf6a..00000000
--- a/tests/CompDataFlatbuffer.Tests/InterpreterTests.cs
+++ /dev/null
@@ -1,214 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#nullable enable
-
-using System;
-using System.Linq;
-using CommunityToolkit.WinUI.Lottie.LottieRuntime;
-using Google.FlatBuffers;
-using Windows.UI.Composition;
-using Xunit;
-using Fb = CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Schema;
-
-namespace CommunityToolkit.WinUI.Lottie.CompDataFlatbuffer.Tests
-{
-    /// <summary>
-    /// Verifies that the managed interpreter builds the composition that the buffer
-    /// describes.
-    /// </summary>
-    /// <remarks>
-    /// The interpreter goes straight from bytes to composition objects, so unlike the
-    /// deserializer it cannot be checked by comparing WinCompData graphs. Instead the
-    /// tree it builds is dumped in the same canonical text as the graph that the
-    /// buffer was written from, and the two are compared. Equal text means the
-    /// interpreter created the same objects, gave them the same values, and shared
-    /// them in the same way, which is the whole of what an interpreter has to get
-    /// right.
-    /// <para/>
-    /// The composition APIs that the interpreter calls only exist on Windows, so this
-    /// runs against the stand-ins in CompositionApiStandIns.cs. That means these tests
-    /// verify the calls that the interpreter makes rather than the pixels that Windows
-    /// draws; the pixels are the same as the deserializer's precisely because the
-    /// calls are.
-    /// </remarks>
-    public class InterpreterTests
-    {
-        [Theory]
-        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
-        public void InterpretedTreeMatchesTheGraph(string fileName)
-        {
-            var translated = Corpus.Translate(fileName);
-
-            var expected = CompositionTreeDumper.Dump(translated.RootVisual);
-            var actual = InterpretedTreeDumper.Dump(Interpret(translated.Serialize()));
-
-            Assert.Equal(expected, actual);
-        }
-
-        [Theory]
-        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
-        public void InterpretationIsRepeatable(string fileName)
-        {
-            var buffer = Corpus.Translate(fileName).Serialize();
-
-            // Interpreting the same buffer twice must produce the same tree. A buffer
-            // is read in place, so this also shows that reading it does not modify it.
-            Assert.Equal(
-                InterpretedTreeDumper.Dump(Interpret(buffer)),
-                InterpretedTreeDumper.Dump(Interpret(buffer)));
-        }
-
-        [Theory]
-        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
-        public void ProgressPropertySetHoldsTheProgressProperty(string fileName)
-        {
-            var root = Interpret(Corpus.Translate(fileName).Serialize());
-
-            // Every translated animation is driven by a single Progress property on the
-            // root visual's property set. A host that cannot find it cannot play the
-            // animation, so this is checked separately from the dump.
-            Assert.Contains(
-                "Progress",
-                CompositionInterpreter.ProgressPropertySet(root).Names.Keys,
-                StringComparer.Ordinal);
-        }
-
-        [Fact]
-        public void EmptyBufferIsRejected()
-            => Assert.Throws<FlatBufferFormatException>(() => Interpret(Array.Empty<byte>()));
-
-        [Fact]
-        public void GarbageIsRejected()
-        {
-            var garbage = new byte[512];
-            new Random(0).NextBytes(garbage);
-
-            Assert.Throws<FlatBufferFormatException>(() => Interpret(garbage));
-        }
-
-        [Fact]
-        public void BufferWithTheWrongFileIdentifierIsRejected()
-        {
-            var buffer = Corpus.Translate("LightBulb.json").Serialize();
-
-            // The file identifier sits at offset 4, immediately after the root offset.
-            buffer[4] = (byte)'X';
-
-            Assert.Throws<FlatBufferFormatException>(() => Interpret(buffer));
-        }
-
-        [Fact]
-        public void BufferWithNoRootVisualIsRejected()
-            => Assert.Throws<FlatBufferFormatException>(
-                () => Interpret(CreateComposition(Format.Version, 0, withRootVisual: false)));
-
-        [Fact]
-        public void NewerSchemaVersionIsRejected()
-        {
-            // A buffer written by a newer serializer may use fields that this build
-            // does not know about, so loading it would silently lose part of the
-            // animation. It is refused instead.
-            var exception = Assert.Throws<NotSupportedException>(
-                () => Interpret(CreateComposition((ushort)(Format.Version + 1), 0)));
-
-            Assert.Contains($"{Format.Version + 1}", exception.Message, StringComparison.Ordinal);
-        }
-
-        [Fact]
-        public void CurrentSchemaVersionIsAccepted()
-            => Assert.NotNull(Interpret(CreateComposition(Format.Version, 0)));
-
-        [Fact]
-        public void UnavailableApiContractIsRejected()
-        {
-            // An animation that needs composition APIs that this version of Windows
-            // does not have is refused rather than built into a tree that cannot run.
-            var exception = Assert.Throws<NotSupportedException>(
-                () => Interpret(CreateComposition(Format.Version, ushort.MaxValue)));
-
-            Assert.Contains("UniversalApiContract", exception.Message, StringComparison.Ordinal);
-        }
-
-        [Theory]
-        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
-        public void TruncatedBuffersAreRejected(string fileName)
-        {
-            var buffer = Corpus.Translate(fileName).Serialize();
-
-            // Truncation is checked at a spread of lengths rather than at every length,
-            // which would make the test run for minutes without finding anything more.
-            for (var length = 0; length < buffer.Length; length += Math.Max(1, buffer.Length / 64))
-            {
-                var truncated = new byte[length];
-                Array.Copy(buffer, truncated, length);
-
-                Assert.Throws<FlatBufferFormatException>(() => Interpret(truncated));
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(Corpus.FileNames), MemberType = typeof(Corpus))]
-        public void CorruptedBuffersDoNotCrash(string fileName)
-        {
-            var original = Corpus.Translate(fileName).Serialize();
-            var random = new Random(fileName.GetHashCode(StringComparison.Ordinal));
-
-            // Unlike truncation, a flipped bit may leave a buffer that is still valid,
-            // just describing a different animation. So the requirement here is weaker:
-            // the interpreter either succeeds or reports a format error, but never
-            // throws something else and never reads outside the buffer.
-            for (var i = 0; i < 200; i++)
-            {
-                var corrupted = (byte[])original.Clone();
-                corrupted[random.Next(corrupted.Length)] ^= (byte)(1 << random.Next(8));
-
-                try
-                {
-                    Interpret(corrupted);
-                }
-                catch (FlatBufferFormatException)
-                {
-                }
-                catch (NotSupportedException)
-                {
-                    // A flipped bit can also land in the schema version or the required
-                    // API contract version.
-                }
-            }
-        }
-
-        static Visual Interpret(byte[] buffer)
-            => CompositionInterpreter.LoadComposition(new Compositor(), buffer);
-
-        // Builds the smallest possible composition: one empty container visual. Used by
-        // the tests of the header, which have nothing to do with the contents.
-        static byte[] CreateComposition(ushort schemaVersion, ushort requiredUapVersion, bool withRootVisual = true)
-        {
-            var builder = new FlatBufferBuilder(256);
-
-            Fb.Visual.StartVisual(builder);
-            Fb.Visual.AddKind(builder, Fb.VisualKind.Container);
-            var visual = Fb.Visual.EndVisual(builder);
-
-            var visuals = Fb.LottieComposition.CreateVisualsVector(builder, new[] { visual });
-
-            Fb.LottieComposition.StartLottieComposition(builder);
-            Fb.LottieComposition.AddSchemaVersion(builder, schemaVersion);
-            Fb.LottieComposition.AddRequiredUapVersion(builder, requiredUapVersion);
-
-            if (withRootVisual)
-            {
-                Fb.LottieComposition.AddRootVisual(builder, 0);
-            }
-
-            Fb.LottieComposition.AddVisuals(builder, visuals);
-            var composition = Fb.LottieComposition.EndLottieComposition(builder);
-
-            Fb.LottieComposition.FinishLottieCompositionBuffer(builder, composition);
-
-            return builder.SizedByteArray();
-        }
-    }
-}

From a380992c3edc5a08346711e924d5ded9cc36e042 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Mon, 12 Oct 2026 17:10:57 -0700
Subject: [PATCH 32/39] Vendor FlatBuffers C++ headers

Replace the FlatBuffers submodule with the pinned public headers and license, and document a validated regeneration workflow for matching flatc binaries and headers.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: adcabe6f-aa5c-4e06-948d-b49e5adae80c
---
 .gitmodules                                   |    3 -
 build/RegenerateFlatbuffers.ps1               |   61 +-
 external/flatbuffers                          |    1 -
 external/flatbuffers/LICENSE                  |  202 ++
 external/flatbuffers/UPSTREAM.md              |   11 +
 .../include/flatbuffers/allocator.h           |   68 +
 .../flatbuffers/include/flatbuffers/array.h   |  258 ++
 .../flatbuffers/include/flatbuffers/base.h    |  503 ++++
 .../flatbuffers/include/flatbuffers/buffer.h  |  225 ++
 .../include/flatbuffers/buffer_ref.h          |   54 +
 .../include/flatbuffers/code_generator.h      |   99 +
 .../include/flatbuffers/code_generators.h     |  238 ++
 .../include/flatbuffers/default_allocator.h   |   64 +
 .../include/flatbuffers/detached_buffer.h     |  121 +
 .../include/flatbuffers/file_manager.h        |   70 +
 .../include/flatbuffers/flatbuffer_builder.h  | 1518 ++++++++++++
 .../include/flatbuffers/flatbuffers.h         |  284 +++
 .../flatbuffers/include/flatbuffers/flatc.h   |  131 ++
 .../include/flatbuffers/flex_flat_util.h      |   37 +
 .../include/flatbuffers/flexbuffers.h         | 2086 +++++++++++++++++
 .../flatbuffers/include/flatbuffers/grpc.h    |  303 +++
 .../flatbuffers/include/flatbuffers/hash.h    |  135 ++
 .../flatbuffers/include/flatbuffers/idl.h     | 1329 +++++++++++
 .../include/flatbuffers/minireflect.h         |  441 ++++
 .../include/flatbuffers/pch/flatc_pch.h       |   39 +
 .../flatbuffers/include/flatbuffers/pch/pch.h |   38 +
 .../include/flatbuffers/reflection.h          |  530 +++++
 .../flatbuffers/reflection_generated.h        | 1541 ++++++++++++
 .../include/flatbuffers/registry.h            |  130 +
 .../include/flatbuffers/stl_emulation.h       |  516 ++++
 .../flatbuffers/include/flatbuffers/string.h  |   69 +
 .../flatbuffers/include/flatbuffers/struct.h  |   55 +
 .../flatbuffers/include/flatbuffers/table.h   |  263 +++
 .../flatbuffers/include/flatbuffers/util.h    |  781 ++++++
 .../flatbuffers/include/flatbuffers/vector.h  |  455 ++++
 .../include/flatbuffers/vector_downward.h     |  298 +++
 .../include/flatbuffers/verifier.h            |  370 +++
 source/LottieFlatbuffer/README.md             |   12 +-
 38 files changed, 13330 insertions(+), 9 deletions(-)
 delete mode 100644 .gitmodules
 delete mode 160000 external/flatbuffers
 create mode 100644 external/flatbuffers/LICENSE
 create mode 100644 external/flatbuffers/UPSTREAM.md
 create mode 100644 external/flatbuffers/include/flatbuffers/allocator.h
 create mode 100644 external/flatbuffers/include/flatbuffers/array.h
 create mode 100644 external/flatbuffers/include/flatbuffers/base.h
 create mode 100644 external/flatbuffers/include/flatbuffers/buffer.h
 create mode 100644 external/flatbuffers/include/flatbuffers/buffer_ref.h
 create mode 100644 external/flatbuffers/include/flatbuffers/code_generator.h
 create mode 100644 external/flatbuffers/include/flatbuffers/code_generators.h
 create mode 100644 external/flatbuffers/include/flatbuffers/default_allocator.h
 create mode 100644 external/flatbuffers/include/flatbuffers/detached_buffer.h
 create mode 100644 external/flatbuffers/include/flatbuffers/file_manager.h
 create mode 100644 external/flatbuffers/include/flatbuffers/flatbuffer_builder.h
 create mode 100644 external/flatbuffers/include/flatbuffers/flatbuffers.h
 create mode 100644 external/flatbuffers/include/flatbuffers/flatc.h
 create mode 100644 external/flatbuffers/include/flatbuffers/flex_flat_util.h
 create mode 100644 external/flatbuffers/include/flatbuffers/flexbuffers.h
 create mode 100644 external/flatbuffers/include/flatbuffers/grpc.h
 create mode 100644 external/flatbuffers/include/flatbuffers/hash.h
 create mode 100644 external/flatbuffers/include/flatbuffers/idl.h
 create mode 100644 external/flatbuffers/include/flatbuffers/minireflect.h
 create mode 100644 external/flatbuffers/include/flatbuffers/pch/flatc_pch.h
 create mode 100644 external/flatbuffers/include/flatbuffers/pch/pch.h
 create mode 100644 external/flatbuffers/include/flatbuffers/reflection.h
 create mode 100644 external/flatbuffers/include/flatbuffers/reflection_generated.h
 create mode 100644 external/flatbuffers/include/flatbuffers/registry.h
 create mode 100644 external/flatbuffers/include/flatbuffers/stl_emulation.h
 create mode 100644 external/flatbuffers/include/flatbuffers/string.h
 create mode 100644 external/flatbuffers/include/flatbuffers/struct.h
 create mode 100644 external/flatbuffers/include/flatbuffers/table.h
 create mode 100644 external/flatbuffers/include/flatbuffers/util.h
 create mode 100644 external/flatbuffers/include/flatbuffers/vector.h
 create mode 100644 external/flatbuffers/include/flatbuffers/vector_downward.h
 create mode 100644 external/flatbuffers/include/flatbuffers/verifier.h

diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index d67d60a6..00000000
--- a/.gitmodules
+++ /dev/null
@@ -1,3 +0,0 @@
-[submodule "external/flatbuffers"]
-	path = external/flatbuffers
-	url = https://github.com/google/flatbuffers.git
diff --git a/build/RegenerateFlatbuffers.ps1 b/build/RegenerateFlatbuffers.ps1
index 0de938e3..134f1e10 100644
--- a/build/RegenerateFlatbuffers.ps1
+++ b/build/RegenerateFlatbuffers.ps1
@@ -6,6 +6,15 @@
 #
 # C# output must match the Google.FlatBuffers package available through the
 # configured Microsoft feed. C++ output must match external/flatbuffers.
+#
+# To obtain the matching C++ compiler and headers:
+# 1. Download the Windows flatc binary for v25.12.19 from
+#    https://github.com/google/flatbuffers/releases/tag/v25.12.19.
+# 2. Download and extract the source archive for commit
+#    5761d6e67af841d15ee21bc1ce9a78ffa9cf939e.
+# 3. Pass the extracted source directory as -CppSource. The script validates
+#    its version, copies include/flatbuffers and LICENSE into external/flatbuffers,
+#    and regenerates the checked-in C++ binding with the matching flatc.exe.
 
 [CmdletBinding()]
 param(
@@ -14,18 +23,42 @@ param(
 
     # C++ code must match the headers in external/flatbuffers.
     [Parameter(Mandatory)]
-    [string]$CppFlatc
+    [string]$CppFlatc,
+
+    # Optional extracted FlatBuffers source tree. Supply this when updating the
+    # vendored headers and license.
+    [string]$CppSource
 )
 
 $ErrorActionPreference = "Stop"
 
 $expectedCSharpVersion = "25.2.10"
 $expectedCppVersion = "25.12.19"
+$expectedCppCommit = "5761d6e67af841d15ee21bc1ce9a78ffa9cf939e"
 
 $repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..")
 $schema = Join-Path $repoRoot "source/LottieFlatbuffer/lottie_comp.fbs"
 $csharpOut = Join-Path $repoRoot "source/CompDataFlatbuffer/Generated"
 $cppOut = Join-Path $repoRoot "source/LottieRuntime/Generated"
+$vendoredFlatBuffers = Join-Path $repoRoot "external/flatbuffers"
+
+function Get-HeaderVersion([string]$sourceRoot) {
+    $baseHeader = Join-Path $sourceRoot "include/flatbuffers/base.h"
+    if (!(Test-Path $baseHeader)) {
+        throw "FlatBuffers header not found: $baseHeader"
+    }
+
+    $contents = Get-Content $baseHeader -Raw
+    $major = [regex]::Match($contents, '#define FLATBUFFERS_VERSION_MAJOR\s+(\d+)').Groups[1].Value
+    $minor = [regex]::Match($contents, '#define FLATBUFFERS_VERSION_MINOR\s+(\d+)').Groups[1].Value
+    $revision = [regex]::Match($contents, '#define FLATBUFFERS_VERSION_REVISION\s+(\d+)').Groups[1].Value
+
+    if (!$major -or !$minor -or !$revision) {
+        throw "Could not read the FlatBuffers version from $baseHeader."
+    }
+
+    return "$major.$minor.$revision"
+}
 
 $actualCSharpVersion = (& $CSharpFlatc --version) -replace '^flatc version ', ''
 if ($actualCSharpVersion.Trim() -ne $expectedCSharpVersion) {
@@ -37,6 +70,32 @@ if ($actualCppVersion.Trim() -ne $expectedCppVersion) {
     throw "C++ flatc version $expectedCppVersion is required, but '$CppFlatc' is version $($actualCppVersion.Trim())."
 }
 
+if ($CppSource) {
+    $resolvedCppSource = Resolve-Path $CppSource
+    $sourceVersion = Get-HeaderVersion $resolvedCppSource
+    if ($sourceVersion -ne $expectedCppVersion) {
+        throw "FlatBuffers headers version $expectedCppVersion is required, but '$resolvedCppSource' contains version $sourceVersion."
+    }
+
+    $sourceLicense = Join-Path $resolvedCppSource "LICENSE"
+    if (!(Test-Path $sourceLicense)) {
+        throw "FlatBuffers license not found: $sourceLicense"
+    }
+
+    $vendoredHeaders = Join-Path $vendoredFlatBuffers "include/flatbuffers"
+    Remove-Item -LiteralPath $vendoredHeaders -Recurse -Force -ErrorAction SilentlyContinue
+    New-Item -ItemType Directory -Force -Path (Split-Path $vendoredHeaders) | Out-Null
+    Copy-Item -LiteralPath (Join-Path $resolvedCppSource "include/flatbuffers") -Destination $vendoredHeaders -Recurse
+    Copy-Item -LiteralPath $sourceLicense -Destination (Join-Path $vendoredFlatBuffers "LICENSE") -Force
+
+    Write-Host "Updated vendored FlatBuffers headers from commit $expectedCppCommit"
+}
+
+$vendoredVersion = Get-HeaderVersion $vendoredFlatBuffers
+if ($vendoredVersion -ne $expectedCppVersion) {
+    throw "Vendored FlatBuffers headers must be version $expectedCppVersion, but they are version $vendoredVersion."
+}
+
 New-Item -ItemType Directory -Force -Path $csharpOut, $cppOut | Out-Null
 
 # --gen-onefile keeps the checked in C# to a single file rather than one file
diff --git a/external/flatbuffers b/external/flatbuffers
deleted file mode 160000
index 5761d6e6..00000000
--- a/external/flatbuffers
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 5761d6e67af841d15ee21bc1ce9a78ffa9cf939e
diff --git a/external/flatbuffers/LICENSE b/external/flatbuffers/LICENSE
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/external/flatbuffers/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/external/flatbuffers/UPSTREAM.md b/external/flatbuffers/UPSTREAM.md
new file mode 100644
index 00000000..751489c9
--- /dev/null
+++ b/external/flatbuffers/UPSTREAM.md
@@ -0,0 +1,11 @@
+# FlatBuffers headers
+
+The files in this directory are vendored from:
+
+- Repository: <https://github.com/google/flatbuffers>
+- Commit: `5761d6e67af841d15ee21bc1ce9a78ffa9cf939e`
+- Header and `flatc` version: `25.12.19`
+
+Only the C++ headers under `include/flatbuffers` and the upstream `LICENSE` are
+included. Use `build/RegenerateFlatbuffers.ps1` to validate and update this copy
+alongside the generated C++ binding.
diff --git a/external/flatbuffers/include/flatbuffers/allocator.h b/external/flatbuffers/include/flatbuffers/allocator.h
new file mode 100644
index 00000000..d4518185
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/allocator.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_ALLOCATOR_H_
+#define FLATBUFFERS_ALLOCATOR_H_
+
+#include "flatbuffers/base.h"
+
+namespace flatbuffers {
+
+// Allocator interface. This is flatbuffers-specific and meant only for
+// `vector_downward` usage.
+class Allocator {
+ public:
+  virtual ~Allocator() {}
+
+  // Allocate `size` bytes of memory.
+  virtual uint8_t* allocate(size_t size) = 0;
+
+  // Deallocate `size` bytes of memory at `p` allocated by this allocator.
+  virtual void deallocate(uint8_t* p, size_t size) = 0;
+
+  // Reallocate `new_size` bytes of memory, replacing the old region of size
+  // `old_size` at `p`. In contrast to a normal realloc, this grows downwards,
+  // and is intended specifcally for `vector_downward` use.
+  // `in_use_back` and `in_use_front` indicate how much of `old_size` is
+  // actually in use at each end, and needs to be copied.
+  virtual uint8_t* reallocate_downward(uint8_t* old_p, size_t old_size,
+                                       size_t new_size, size_t in_use_back,
+                                       size_t in_use_front) {
+    FLATBUFFERS_ASSERT(new_size > old_size);  // vector_downward only grows
+    uint8_t* new_p = allocate(new_size);
+    memcpy_downward(old_p, old_size, new_p, new_size, in_use_back,
+                    in_use_front);
+    deallocate(old_p, old_size);
+    return new_p;
+  }
+
+ protected:
+  // Called by `reallocate_downward` to copy memory from `old_p` of `old_size`
+  // to `new_p` of `new_size`. Only memory of size `in_use_front` and
+  // `in_use_back` will be copied from the front and back of the old memory
+  // allocation.
+  void memcpy_downward(uint8_t* old_p, size_t old_size, uint8_t* new_p,
+                       size_t new_size, size_t in_use_back,
+                       size_t in_use_front) {
+    memcpy(new_p + new_size - in_use_back, old_p + old_size - in_use_back,
+           in_use_back);
+    memcpy(new_p, old_p, in_use_front);
+  }
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_ALLOCATOR_H_
diff --git a/external/flatbuffers/include/flatbuffers/array.h b/external/flatbuffers/include/flatbuffers/array.h
new file mode 100644
index 00000000..163d8c36
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/array.h
@@ -0,0 +1,258 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_ARRAY_H_
+#define FLATBUFFERS_ARRAY_H_
+
+#include <cstdint>
+#include <memory>
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/stl_emulation.h"
+#include "flatbuffers/vector.h"
+
+namespace flatbuffers {
+
+// This is used as a helper type for accessing arrays.
+template <typename T, uint16_t length>
+class Array {
+  // Array<T> can carry only POD data types (scalars or structs).
+  typedef typename flatbuffers::bool_constant<flatbuffers::is_scalar<T>::value>
+      scalar_tag;
+
+ public:
+  typedef uint16_t size_type;
+  typedef typename IndirectHelper<T>::return_type return_type;
+  typedef VectorConstIterator<T, return_type, uoffset_t> const_iterator;
+  typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
+
+  // If T is a non-pointer and a LE-scalar or a struct (!scalar_tag::value).
+  static FLATBUFFERS_CONSTEXPR bool is_span_observable =
+      !std::is_pointer<T>::value &&
+      ((scalar_tag::value && (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1)) ||
+       !scalar_tag::value);
+
+  FLATBUFFERS_CONSTEXPR uint16_t size() const { return length; }
+
+  return_type Get(uoffset_t i) const {
+    FLATBUFFERS_ASSERT(i < size());
+    return IndirectHelper<T>::Read(Data(), i);
+  }
+
+  return_type operator[](uoffset_t i) const { return Get(i); }
+
+  // If this is a Vector of enums, T will be its storage type, not the enum
+  // type. This function makes it convenient to retrieve value with enum
+  // type E.
+  template <typename E>
+  E GetEnum(uoffset_t i) const {
+    return static_cast<E>(Get(i));
+  }
+
+  const_iterator begin() const { return const_iterator(Data(), 0); }
+  const_iterator end() const { return const_iterator(Data(), size()); }
+
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  const_iterator cbegin() const { return begin(); }
+  const_iterator cend() const { return end(); }
+
+  const_reverse_iterator crbegin() const { return rbegin(); }
+  const_reverse_iterator crend() const { return rend(); }
+
+  // Get a mutable pointer to elements inside this array.
+  // This method used to mutate arrays of structs followed by a @p Mutate
+  // operation. For primitive types use @p Mutate directly.
+  // @warning Assignments and reads to/from the dereferenced pointer are not
+  //  automatically converted to the correct endianness.
+  typename flatbuffers::conditional<scalar_tag::value, void, T*>::type
+  GetMutablePointer(uoffset_t i) const {
+    FLATBUFFERS_ASSERT(i < size());
+    return const_cast<T*>(&data()[i]);
+  }
+
+  // Change elements if you have a non-const pointer to this object.
+  void Mutate(uoffset_t i, const T& val) { MutateImpl(scalar_tag(), i, val); }
+
+  // The raw data in little endian format. Use with care.
+  const uint8_t* Data() const { return data_; }
+
+  uint8_t* Data() { return data_; }
+
+  // Similarly, but typed, much like std::vector::data
+  const T* data() const { return reinterpret_cast<const T*>(Data()); }
+  T* data() { return reinterpret_cast<T*>(Data()); }
+
+  // Copy data from a span with endian conversion.
+  // If this Array and the span overlap, the behavior is undefined.
+  void CopyFromSpan(flatbuffers::span<const T, length> src) {
+    const auto p1 = reinterpret_cast<const uint8_t*>(src.data());
+    const auto p2 = Data();
+    FLATBUFFERS_ASSERT(!(p1 >= p2 && p1 < (p2 + length)) &&
+                       !(p2 >= p1 && p2 < (p1 + length)));
+    (void)p1;
+    (void)p2;
+    CopyFromSpanImpl(flatbuffers::bool_constant<is_span_observable>(), src);
+  }
+
+ protected:
+  void MutateImpl(flatbuffers::true_type, uoffset_t i, const T& val) {
+    FLATBUFFERS_ASSERT(i < size());
+    WriteScalar(data() + i, val);
+  }
+
+  void MutateImpl(flatbuffers::false_type, uoffset_t i, const T& val) {
+    *(GetMutablePointer(i)) = val;
+  }
+
+  void CopyFromSpanImpl(flatbuffers::true_type,
+                        flatbuffers::span<const T, length> src) {
+    // Use std::memcpy() instead of std::copy() to avoid performance degradation
+    // due to aliasing if T is char or unsigned char.
+    // The size is known at compile time, so memcpy would be inlined.
+    std::memcpy(data(), src.data(), length * sizeof(T));
+  }
+
+  // Copy data from flatbuffers::span with endian conversion.
+  void CopyFromSpanImpl(flatbuffers::false_type,
+                        flatbuffers::span<const T, length> src) {
+    for (size_type k = 0; k < length; k++) {
+      Mutate(k, src[k]);
+    }
+  }
+
+  // This class is only used to access pre-existing data. Don't ever
+  // try to construct these manually.
+  // 'constexpr' allows us to use 'size()' at compile time.
+  // @note Must not use 'FLATBUFFERS_CONSTEXPR' here, as const is not allowed on
+  //  a constructor.
+#if defined(__cpp_constexpr)
+  constexpr Array();
+#else
+  Array();
+#endif
+
+  uint8_t data_[length * sizeof(T)];
+
+ private:
+  // This class is a pointer. Copying will therefore create an invalid object.
+  // Private and unimplemented copy constructor.
+  Array(const Array&);
+  Array& operator=(const Array&);
+};
+
+// Specialization for Array[struct] with access using Offset<void> pointer.
+// This specialization used by idl_gen_text.cpp.
+template <typename T, uint16_t length, template <typename> class OffsetT>
+class Array<OffsetT<T>, length> {
+  static_assert(flatbuffers::is_same<T, void>::value, "unexpected type T");
+
+ public:
+  typedef const void* return_type;
+  typedef uint16_t size_type;
+
+  const uint8_t* Data() const { return data_; }
+
+  // Make idl_gen_text.cpp::PrintContainer happy.
+  return_type operator[](uoffset_t) const {
+    FLATBUFFERS_ASSERT(false);
+    return nullptr;
+  }
+
+ private:
+  // This class is only used to access pre-existing data.
+  Array();
+  Array(const Array&);
+  Array& operator=(const Array&);
+
+  uint8_t data_[1];
+};
+
+template <class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U, N> make_span(Array<U, N>& arr)
+    FLATBUFFERS_NOEXCEPT {
+  static_assert(
+      Array<U, N>::is_span_observable,
+      "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
+  return span<U, N>(arr.data(), N);
+}
+
+template <class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U, N> make_span(
+    const Array<U, N>& arr) FLATBUFFERS_NOEXCEPT {
+  static_assert(
+      Array<U, N>::is_span_observable,
+      "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
+  return span<const U, N>(arr.data(), N);
+}
+
+template <class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<uint8_t, sizeof(U) * N>
+make_bytes_span(Array<U, N>& arr) FLATBUFFERS_NOEXCEPT {
+  static_assert(Array<U, N>::is_span_observable,
+                "internal error, Array<T> might hold only scalars or structs");
+  return span<uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
+}
+
+template <class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const uint8_t, sizeof(U) * N>
+make_bytes_span(const Array<U, N>& arr) FLATBUFFERS_NOEXCEPT {
+  static_assert(Array<U, N>::is_span_observable,
+                "internal error, Array<T> might hold only scalars or structs");
+  return span<const uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
+}
+
+// Cast a raw T[length] to a raw flatbuffers::Array<T, length>
+// without endian conversion. Use with care.
+// TODO: move these Cast-methods to `internal` namespace.
+template <typename T, uint16_t length>
+Array<T, length>& CastToArray(T (&arr)[length]) {
+  return *reinterpret_cast<Array<T, length>*>(arr);
+}
+
+template <typename T, uint16_t length>
+const Array<T, length>& CastToArray(const T (&arr)[length]) {
+  return *reinterpret_cast<const Array<T, length>*>(arr);
+}
+
+template <typename E, typename T, uint16_t length>
+Array<E, length>& CastToArrayOfEnum(T (&arr)[length]) {
+  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
+  return *reinterpret_cast<Array<E, length>*>(arr);
+}
+
+template <typename E, typename T, uint16_t length>
+const Array<E, length>& CastToArrayOfEnum(const T (&arr)[length]) {
+  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
+  return *reinterpret_cast<const Array<E, length>*>(arr);
+}
+
+template <typename T, uint16_t length>
+bool operator==(const Array<T, length>& lhs,
+                const Array<T, length>& rhs) noexcept {
+  return std::addressof(lhs) == std::addressof(rhs) ||
+         (lhs.size() == rhs.size() &&
+          std::memcmp(lhs.Data(), rhs.Data(), rhs.size() * sizeof(T)) == 0);
+}
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_ARRAY_H_
diff --git a/external/flatbuffers/include/flatbuffers/base.h b/external/flatbuffers/include/flatbuffers/base.h
new file mode 100644
index 00000000..1d2ab585
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/base.h
@@ -0,0 +1,503 @@
+#ifndef FLATBUFFERS_BASE_H_
+#define FLATBUFFERS_BASE_H_
+
+// clang-format off
+
+// If activate should be declared and included first.
+#if defined(FLATBUFFERS_MEMORY_LEAK_TRACKING) && \
+    defined(_MSC_VER) && defined(_DEBUG)
+  // The _CRTDBG_MAP_ALLOC inside <crtdbg.h> will replace
+  // calloc/free (etc) to its debug version using #define directives.
+  #define _CRTDBG_MAP_ALLOC
+  #include <stdlib.h>
+  #include <crtdbg.h>
+  // Replace operator new by trace-enabled version.
+  #define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
+  #define new DEBUG_NEW
+#endif
+
+#if !defined(FLATBUFFERS_ASSERT)
+#include <assert.h>
+#define FLATBUFFERS_ASSERT assert
+#elif defined(FLATBUFFERS_ASSERT_INCLUDE)
+// Include file with forward declaration
+#include FLATBUFFERS_ASSERT_INCLUDE
+#endif
+
+#ifndef ARDUINO
+#include <cstdint>
+#endif
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+
+#if defined(ARDUINO) && !defined(ARDUINOSTL_M_H) && defined(__AVR__)
+  #include <utility.h>
+#else
+  #include <utility>
+#endif
+
+#include <string>
+#include <type_traits>
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <limits>
+#include <iterator>
+#include <memory>
+
+#if defined(__unix__) && !defined(FLATBUFFERS_LOCALE_INDEPENDENT)
+  #include <unistd.h>
+#endif
+
+#ifdef __ANDROID__
+  #include <android/api-level.h>
+#endif
+
+#if defined(__ICCARM__)
+#include <intrinsics.h>
+#endif
+
+// Note the __clang__ check is needed, because clang presents itself
+// as an older GNUC compiler (4.2).
+// Clang 3.3 and later implement all of the ISO C++ 2011 standard.
+// Clang 3.4 and later implement all of the ISO C++ 2014 standard.
+// http://clang.llvm.org/cxx_status.html
+
+// Note the MSVC value '__cplusplus' may be incorrect:
+// The '__cplusplus' predefined macro in the MSVC stuck at the value 199711L,
+// indicating (erroneously!) that the compiler conformed to the C++98 Standard.
+// This value should be correct starting from MSVC2017-15.7-Preview-3.
+// The '__cplusplus' will be valid only if MSVC2017-15.7-P3 and the `/Zc:__cplusplus` switch is set.
+// Workaround (for details see MSDN):
+// Use the _MSC_VER and _MSVC_LANG definition instead of the __cplusplus  for compatibility.
+// The _MSVC_LANG macro reports the Standard version regardless of the '/Zc:__cplusplus' switch.
+
+#if defined(__GNUC__) && !defined(__clang__)
+  #define FLATBUFFERS_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#else
+  #define FLATBUFFERS_GCC 0
+#endif
+
+#if defined(__clang__)
+  #define FLATBUFFERS_CLANG (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
+#else
+  #define FLATBUFFERS_CLANG 0
+#endif
+
+/// @cond FLATBUFFERS_INTERNAL
+#if __cplusplus <= 199711L && \
+    (!defined(_MSC_VER) || _MSC_VER < 1600) && \
+    (!defined(__GNUC__) || \
+      (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 40400))
+  #error A C++11 compatible compiler with support for the auto typing is \
+         required for FlatBuffers.
+  #error __cplusplus _MSC_VER __GNUC__  __GNUC_MINOR__  __GNUC_PATCHLEVEL__
+#endif
+
+#if !defined(__clang__) && \
+    defined(__GNUC__) && \
+    (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 40600)
+  // Backwards compatibility for g++ 4.4, and 4.5 which don't have the nullptr
+  // and constexpr keywords. Note the __clang__ check is needed, because clang
+  // presents itself as an older GNUC compiler.
+  #ifndef nullptr_t
+    const class nullptr_t {
+    public:
+      template<class T> inline operator T*() const { return 0; }
+    private:
+      void operator&() const;
+    } nullptr = {};
+  #endif
+  #ifndef constexpr
+    #define constexpr const
+  #endif
+#endif
+
+// The wire format uses a little endian encoding (since that's efficient for
+// the common platforms).
+#if defined(__s390x__)
+  #define FLATBUFFERS_LITTLEENDIAN 0
+#endif // __s390x__
+#if !defined(FLATBUFFERS_LITTLEENDIAN)
+  #if defined(__GNUC__) || defined(__clang__) || defined(__ICCARM__)
+    #if (defined(__BIG_ENDIAN__) || \
+         (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+      #define FLATBUFFERS_LITTLEENDIAN 0
+    #else
+      #define FLATBUFFERS_LITTLEENDIAN 1
+    #endif // __BIG_ENDIAN__
+  #elif defined(_MSC_VER)
+    #if defined(_M_PPC)
+      #define FLATBUFFERS_LITTLEENDIAN 0
+    #else
+      #define FLATBUFFERS_LITTLEENDIAN 1
+    #endif
+  #else
+    #error Unable to determine endianness, define FLATBUFFERS_LITTLEENDIAN.
+  #endif
+#endif // !defined(FLATBUFFERS_LITTLEENDIAN)
+
+#define FLATBUFFERS_VERSION_MAJOR 25
+#define FLATBUFFERS_VERSION_MINOR 12
+#define FLATBUFFERS_VERSION_REVISION 19
+#define FLATBUFFERS_STRING_EXPAND(X) #X
+#define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
+namespace flatbuffers {
+  // Returns version as string  "MAJOR.MINOR.REVISION".
+  const char* FLATBUFFERS_VERSION();
+}
+
+#if (!defined(_MSC_VER) || _MSC_VER > 1600) && \
+    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 407)) || \
+    defined(__clang__)
+  #define FLATBUFFERS_FINAL_CLASS final
+  #define FLATBUFFERS_OVERRIDE override
+  #define FLATBUFFERS_EXPLICIT_CPP11 explicit
+  #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE : ::flatbuffers::voffset_t
+#else
+  #define FLATBUFFERS_FINAL_CLASS
+  #define FLATBUFFERS_OVERRIDE
+  #define FLATBUFFERS_EXPLICIT_CPP11
+  #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE
+#endif
+
+#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && \
+    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)) || \
+    (defined(__cpp_constexpr) && __cpp_constexpr >= 200704)
+  #define FLATBUFFERS_CONSTEXPR constexpr
+  #define FLATBUFFERS_CONSTEXPR_CPP11 constexpr
+  #define FLATBUFFERS_CONSTEXPR_DEFINED
+#else
+  #define FLATBUFFERS_CONSTEXPR const
+  #define FLATBUFFERS_CONSTEXPR_CPP11
+#endif
+
+#if (defined(__cplusplus) && __cplusplus >= 201402L) || \
+    (defined(__cpp_constexpr) && __cpp_constexpr >= 201304)
+  #define FLATBUFFERS_CONSTEXPR_CPP14 FLATBUFFERS_CONSTEXPR_CPP11
+#else
+  #define FLATBUFFERS_CONSTEXPR_CPP14
+#endif
+
+#if (defined(__GXX_EXPERIMENTAL_CXX0X__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)) || \
+    (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 190023026)) || \
+    defined(__clang__)
+  #define FLATBUFFERS_NOEXCEPT noexcept
+#else
+  #define FLATBUFFERS_NOEXCEPT
+#endif
+
+// NOTE: the FLATBUFFERS_DELETE_FUNC macro may change the access mode to
+// private, so be sure to put it at the end or reset access mode explicitly.
+#if (!defined(_MSC_VER) || _MSC_FULL_VER >= 180020827) && \
+    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 404)) || \
+    defined(__clang__)
+  #define FLATBUFFERS_DELETE_FUNC(func) func = delete
+#else
+  #define FLATBUFFERS_DELETE_FUNC(func) private: func
+#endif
+
+#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && \
+    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || \
+    defined(__clang__)
+  #define FLATBUFFERS_DEFAULT_DECLARATION
+#endif
+
+// Check if we can use template aliases
+// Not possible if Microsoft Compiler before 2012
+// Possible is the language feature __cpp_alias_templates is defined well
+// Or possible if the C++ std is C+11 or newer
+#if (defined(_MSC_VER) && _MSC_VER > 1700 /* MSVC2012 */) \
+    || (defined(__cpp_alias_templates) && __cpp_alias_templates >= 200704) \
+    || (defined(__cplusplus) && __cplusplus >= 201103L)
+  #define FLATBUFFERS_TEMPLATES_ALIASES
+#endif
+
+#ifndef FLATBUFFERS_HAS_STRING_VIEW
+  // Only provide flatbuffers::string_view if __has_include can be used
+  // to detect a header that provides an implementation
+  #if defined(__has_include)
+    // Check for std::string_view (in c++17)
+    #if __has_include(<string_view>) && (__cplusplus >= 201606 || (defined(_HAS_CXX17) && _HAS_CXX17))
+      #include <string_view>
+      namespace flatbuffers {
+        typedef std::string_view string_view;
+      }
+      #define FLATBUFFERS_HAS_STRING_VIEW 1
+    // Check for std::experimental::string_view (in c++14, compiler-dependent)
+    #elif __has_include(<experimental/string_view>) && (__cplusplus >= 201411)
+      #include <experimental/string_view>
+      namespace flatbuffers {
+        typedef std::experimental::string_view string_view;
+      }
+      #define FLATBUFFERS_HAS_STRING_VIEW 1
+    // Check for absl::string_view
+    #elif __has_include("absl/strings/string_view.h") && \
+          __has_include("absl/base/config.h") && \
+          (__cplusplus >= 201411)
+      #include "absl/base/config.h"
+      #if !defined(ABSL_USES_STD_STRING_VIEW)
+        #include "absl/strings/string_view.h"
+        namespace flatbuffers {
+          typedef absl::string_view string_view;
+        }
+        #define FLATBUFFERS_HAS_STRING_VIEW 1
+      #endif
+    #endif
+  #endif // __has_include
+#endif // !FLATBUFFERS_HAS_STRING_VIEW
+
+#ifndef FLATBUFFERS_GENERAL_HEAP_ALLOC_OK
+  // Allow heap allocations to be used
+  #define FLATBUFFERS_GENERAL_HEAP_ALLOC_OK 1
+#endif // !FLATBUFFERS_GENERAL_HEAP_ALLOC_OK
+
+#ifndef FLATBUFFERS_HAS_NEW_STRTOD
+  // Modern (C++11) strtod and strtof functions are available for use.
+  // 1) nan/inf strings as argument of strtod;
+  // 2) hex-float  as argument of  strtod/strtof.
+  #if (defined(_MSC_VER) && _MSC_VER >= 1900) || \
+      (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || \
+      (defined(__clang__))
+    #define FLATBUFFERS_HAS_NEW_STRTOD 1
+  #endif
+#endif // !FLATBUFFERS_HAS_NEW_STRTOD
+
+#ifndef FLATBUFFERS_LOCALE_INDEPENDENT
+  // Enable locale independent functions {strtof_l, strtod_l,strtoll_l,
+  // strtoull_l} on platforms that support them.
+  #if (defined(_MSC_VER) && _MSC_VER >= 1800) || \
+      (defined(__ANDROID__) && defined(__ANDROID_API__) && __ANDROID_API__>= 26) || \
+      (defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 700)) && \
+      !defined(__Fuchsia__)
+    #define FLATBUFFERS_LOCALE_INDEPENDENT 1
+  #else
+    #define FLATBUFFERS_LOCALE_INDEPENDENT 0
+  #endif
+#endif  // !FLATBUFFERS_LOCALE_INDEPENDENT
+
+// Suppress Undefined Behavior Sanitizer (recoverable only). Usage:
+// - FLATBUFFERS_SUPPRESS_UBSAN("undefined")
+// - FLATBUFFERS_SUPPRESS_UBSAN("signed-integer-overflow")
+#if defined(__clang__) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >=7))
+  #define FLATBUFFERS_SUPPRESS_UBSAN(type) __attribute__((no_sanitize(type)))
+#elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)
+  #define FLATBUFFERS_SUPPRESS_UBSAN(type) __attribute__((no_sanitize_undefined))
+#else
+  #define FLATBUFFERS_SUPPRESS_UBSAN(type)
+#endif
+
+namespace flatbuffers {
+  // This is constexpr function used for checking compile-time constants.
+  // Avoid `#pragma warning(disable: 4127) // C4127: expression is constant`.
+  template<typename T> FLATBUFFERS_CONSTEXPR inline bool IsConstTrue(T t) {
+    return !!t;
+  }
+}
+
+// Enable C++ attribute [[]] if std:c++17 or higher.
+#if ((__cplusplus >= 201703L) \
+    || (defined(_MSVC_LANG) &&  (_MSVC_LANG >= 201703L)))
+  // All attributes unknown to an implementation are ignored without causing an error.
+  #define FLATBUFFERS_ATTRIBUTE(attr) attr
+
+  #define FLATBUFFERS_FALLTHROUGH() [[fallthrough]]
+#else
+  #define FLATBUFFERS_ATTRIBUTE(attr)
+
+  #if FLATBUFFERS_CLANG >= 30800
+    #define FLATBUFFERS_FALLTHROUGH() [[clang::fallthrough]]
+  #elif FLATBUFFERS_GCC >= 70300
+    #define FLATBUFFERS_FALLTHROUGH() [[gnu::fallthrough]]
+  #else
+    #define FLATBUFFERS_FALLTHROUGH()
+  #endif
+#endif
+
+/// @endcond
+
+/// @file
+namespace flatbuffers {
+
+/// @cond FLATBUFFERS_INTERNAL
+// Our default offset / size type, 32bit on purpose on 64bit systems.
+// Also, using a consistent offset type maintains compatibility of serialized
+// offset values between 32bit and 64bit systems.
+typedef uint32_t uoffset_t;
+typedef uint64_t uoffset64_t;
+
+// Signed offsets for references that can go in both directions.
+typedef int32_t soffset_t;
+typedef int64_t soffset64_t;
+
+// Offset/index used in v-tables, can be changed to uint8_t in
+// format forks to save a bit of space if desired.
+typedef uint16_t voffset_t;
+
+typedef uintmax_t largest_scalar_t;
+
+// In 32bits, this evaluates to 2GB - 1
+#define FLATBUFFERS_MAX_BUFFER_SIZE (std::numeric_limits<::flatbuffers::soffset_t>::max)()
+#define FLATBUFFERS_MAX_64_BUFFER_SIZE (std::numeric_limits<::flatbuffers::soffset64_t>::max)()
+
+// The minimum size buffer that can be a valid flatbuffer.
+// Includes the offset to the root table (uoffset_t), the offset to the vtable
+// of the root table (soffset_t), the size of the vtable (uint16_t), and the
+// size of the referring table (uint16_t).
+#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(::flatbuffers::uoffset_t) + \
+  sizeof(::flatbuffers::soffset_t) + sizeof(uint16_t) + sizeof(uint16_t)
+
+// We support aligning the contents of buffers up to this size.
+#ifndef FLATBUFFERS_MAX_ALIGNMENT
+  #define FLATBUFFERS_MAX_ALIGNMENT 32
+#endif
+
+/// @brief The length of a FlatBuffer file header.
+static const size_t kFileIdentifierLength = 4;
+
+inline bool VerifyAlignmentRequirements(size_t align, size_t min_align = 1) {
+  return (min_align <= align) && (align <= (FLATBUFFERS_MAX_ALIGNMENT)) &&
+         (align & (align - 1)) == 0;  // must be power of 2
+}
+
+#if defined(_MSC_VER)
+  #pragma warning(push)
+  #pragma warning(disable: 4127) // C4127: conditional expression is constant
+#endif
+
+template<typename T> T EndianSwap(T t) {
+  #if defined(_MSC_VER)
+    #define FLATBUFFERS_BYTESWAP16 _byteswap_ushort
+    #define FLATBUFFERS_BYTESWAP32 _byteswap_ulong
+    #define FLATBUFFERS_BYTESWAP64 _byteswap_uint64
+  #elif defined(__ICCARM__)
+    #define FLATBUFFERS_BYTESWAP16 __REV16
+    #define FLATBUFFERS_BYTESWAP32 __REV
+    #define FLATBUFFERS_BYTESWAP64(x) \
+       ((__REV(static_cast<uint32_t>(x >> 32U))) | (static_cast<uint64_t>(__REV(static_cast<uint32_t>(x)))) << 32U)
+  #else
+    #if defined(__GNUC__) && __GNUC__ * 100 + __GNUC_MINOR__ < 408 && !defined(__clang__)
+      // __builtin_bswap16 was missing prior to GCC 4.8.
+      #define FLATBUFFERS_BYTESWAP16(x) \
+        static_cast<uint16_t>(__builtin_bswap32(static_cast<uint32_t>(x) << 16))
+    #else
+      #define FLATBUFFERS_BYTESWAP16 __builtin_bswap16
+    #endif
+    #define FLATBUFFERS_BYTESWAP32 __builtin_bswap32
+    #define FLATBUFFERS_BYTESWAP64 __builtin_bswap64
+  #endif
+  if (sizeof(T) == 1) {   // Compile-time if-then's.
+    return t;
+  } else if (sizeof(T) == 2) {
+    union { T t; uint16_t i; } u = { t };
+    u.i = FLATBUFFERS_BYTESWAP16(u.i);
+    return u.t;
+  } else if (sizeof(T) == 4) {
+    union { T t; uint32_t i; } u = { t };
+    u.i = FLATBUFFERS_BYTESWAP32(u.i);
+    return u.t;
+  } else if (sizeof(T) == 8) {
+    union { T t; uint64_t i; } u = { t };
+    u.i = FLATBUFFERS_BYTESWAP64(u.i);
+    return u.t;
+  } else {
+    FLATBUFFERS_ASSERT(0);
+    return t;
+  }
+}
+
+#if defined(_MSC_VER)
+  #pragma warning(pop)
+#endif
+
+
+template<typename T> T EndianScalar(T t) {
+  #if FLATBUFFERS_LITTLEENDIAN
+    return t;
+  #else
+    return EndianSwap(t);
+  #endif
+}
+
+template<typename T>
+// UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
+FLATBUFFERS_SUPPRESS_UBSAN("alignment")
+T ReadScalar(const void *p) {
+  return EndianScalar(*reinterpret_cast<const T *>(p));
+}
+
+// See https://github.com/google/flatbuffers/issues/5950
+
+#if (FLATBUFFERS_GCC >= 100000) && (FLATBUFFERS_GCC < 110000)
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstringop-overflow"
+#endif
+
+template<typename T>
+// UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
+FLATBUFFERS_SUPPRESS_UBSAN("alignment")
+void WriteScalar(void *p, T t) {
+  *reinterpret_cast<T *>(p) = EndianScalar(t);
+}
+
+template<typename T> struct Offset;
+template<typename T> FLATBUFFERS_SUPPRESS_UBSAN("alignment") void WriteScalar(void *p, Offset<T> t) {
+  *reinterpret_cast<uoffset_t *>(p) = EndianScalar(t.o);
+}
+
+#if (FLATBUFFERS_GCC >= 100000) && (FLATBUFFERS_GCC < 110000)
+  #pragma GCC diagnostic pop
+#endif
+
+// Computes how many bytes you'd have to pad to be able to write an
+// "scalar_size" scalar if the buffer had grown to "buf_size" (downwards in
+// memory).
+FLATBUFFERS_SUPPRESS_UBSAN("unsigned-integer-overflow")
+inline size_t PaddingBytes(size_t buf_size, size_t scalar_size) {
+  return ((~buf_size) + 1) & (scalar_size - 1);
+}
+
+#if !defined(_MSC_VER)
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+// Generic 'operator==' with conditional specialisations.
+// T e - new value of a scalar field.
+// T def - default of scalar (is known at compile-time).
+template<typename T> inline bool IsTheSameAs(T e, T def) { return e == def; }
+#if !defined(_MSC_VER)
+  #pragma GCC diagnostic pop
+#endif
+
+#if defined(FLATBUFFERS_NAN_DEFAULTS) && \
+    defined(FLATBUFFERS_HAS_NEW_STRTOD) && (FLATBUFFERS_HAS_NEW_STRTOD > 0)
+// Like `operator==(e, def)` with weak NaN if T=(float|double).
+template<typename T> inline bool IsFloatTheSameAs(T e, T def) {
+  return (e == def) || ((def != def) && (e != e));
+}
+template<> inline bool IsTheSameAs<float>(float e, float def) {
+  return IsFloatTheSameAs(e, def);
+}
+template<> inline bool IsTheSameAs<double>(double e, double def) {
+  return IsFloatTheSameAs(e, def);
+}
+#endif
+
+// Check 'v' is out of closed range [low; high].
+// Workaround for GCC warning [-Werror=type-limits]:
+// comparison is always true due to limited range of data type.
+template<typename T>
+inline bool IsOutRange(const T &v, const T &low, const T &high) {
+  return (v < low) || (high < v);
+}
+
+// Check 'v' is in closed range [low; high].
+template<typename T>
+inline bool IsInRange(const T &v, const T &low, const T &high) {
+  return !IsOutRange(v, low, high);
+}
+
+}  // namespace flatbuffers
+#endif  // FLATBUFFERS_BASE_H_
diff --git a/external/flatbuffers/include/flatbuffers/buffer.h b/external/flatbuffers/include/flatbuffers/buffer.h
new file mode 100644
index 00000000..154d187a
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/buffer.h
@@ -0,0 +1,225 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_BUFFER_H_
+#define FLATBUFFERS_BUFFER_H_
+
+#include <algorithm>
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/stl_emulation.h"
+
+namespace flatbuffers {
+
+// Wrapper for uoffset_t to allow safe template specialization.
+// Value is allowed to be 0 to indicate a null object (see e.g. AddOffset).
+template <typename T = void>
+struct Offset {
+  // The type of offset to use.
+  typedef uoffset_t offset_type;
+
+  offset_type o;
+  Offset() : o(0) {}
+  Offset(const offset_type _o) : o(_o) {}
+  Offset<> Union() const { return o; }
+  bool IsNull() const { return !o; }
+};
+
+template <typename T>
+struct is_specialisation_of_Offset : false_type {};
+template <typename T>
+struct is_specialisation_of_Offset<Offset<T>> : true_type {};
+
+// Wrapper for uoffset64_t Offsets.
+template <typename T = void>
+struct Offset64 {
+  // The type of offset to use.
+  typedef uoffset64_t offset_type;
+
+  offset_type o;
+  Offset64() : o(0) {}
+  Offset64(const offset_type offset) : o(offset) {}
+  Offset64<> Union() const { return o; }
+  bool IsNull() const { return !o; }
+};
+
+template <typename T>
+struct is_specialisation_of_Offset64 : false_type {};
+template <typename T>
+struct is_specialisation_of_Offset64<Offset64<T>> : true_type {};
+
+// Litmus check for ensuring the Offsets are the expected size.
+static_assert(sizeof(Offset<>) == 4, "Offset has wrong size");
+static_assert(sizeof(Offset64<>) == 8, "Offset64 has wrong size");
+
+inline void EndianCheck() {
+  int endiantest = 1;
+  // If this fails, see FLATBUFFERS_LITTLEENDIAN above.
+  FLATBUFFERS_ASSERT(*reinterpret_cast<char*>(&endiantest) ==
+                     FLATBUFFERS_LITTLEENDIAN);
+  (void)endiantest;
+}
+
+template <typename T>
+FLATBUFFERS_CONSTEXPR size_t AlignOf() {
+  // clang-format off
+  #ifdef _MSC_VER
+    return __alignof(T);
+  #else
+    #ifndef alignof
+      return __alignof__(T);
+    #else
+      return alignof(T);
+    #endif
+  #endif
+  // clang-format on
+}
+
+// Lexicographically compare two strings (possibly containing nulls), and
+// return true if the first is less than the second.
+static inline bool StringLessThan(const char* a_data, uoffset_t a_size,
+                                  const char* b_data, uoffset_t b_size) {
+  const auto cmp = memcmp(a_data, b_data, (std::min)(a_size, b_size));
+  return cmp == 0 ? a_size < b_size : cmp < 0;
+}
+
+// When we read serialized data from memory, in the case of most scalars,
+// we want to just read T, but in the case of Offset, we want to actually
+// perform the indirection and return a pointer.
+// The template specialization below does just that.
+// It is wrapped in a struct since function templates can't overload on the
+// return type like this.
+// The typedef is for the convenience of callers of this function
+// (avoiding the need for a trailing return decltype)
+template <typename T, typename Enable = void>
+struct IndirectHelper {
+  typedef T return_type;
+  typedef T mutable_return_type;
+  static const size_t element_stride = sizeof(T);
+
+  static return_type Read(const uint8_t* p, const size_t i) {
+    return EndianScalar((reinterpret_cast<const T*>(p))[i]);
+  }
+  static mutable_return_type Read(uint8_t* p, const size_t i) {
+    return reinterpret_cast<mutable_return_type>(
+        Read(const_cast<const uint8_t*>(p), i));
+  }
+};
+
+// For vector of Offsets.
+template <typename T, template <typename> class OffsetT>
+struct IndirectHelper<OffsetT<T>> {
+  typedef const T* return_type;
+  typedef T* mutable_return_type;
+  typedef typename OffsetT<T>::offset_type offset_type;
+  static const offset_type element_stride = sizeof(offset_type);
+
+  static return_type Read(const uint8_t* const p, const offset_type i) {
+    // Offsets are relative to themselves, so first update the pointer to
+    // point to the offset location.
+    const uint8_t* const offset_location = p + i * element_stride;
+
+    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
+    // then determine the relative location from the offset location.
+    return reinterpret_cast<return_type>(
+        offset_location + ReadScalar<offset_type>(offset_location));
+  }
+  static mutable_return_type Read(uint8_t* const p, const offset_type i) {
+    // Offsets are relative to themselves, so first update the pointer to
+    // point to the offset location.
+    uint8_t* const offset_location = p + i * element_stride;
+
+    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
+    // then determine the relative location from the offset location.
+    return reinterpret_cast<mutable_return_type>(
+        offset_location + ReadScalar<offset_type>(offset_location));
+  }
+};
+
+// For vector of structs.
+template <typename T>
+struct IndirectHelper<
+    T, typename std::enable_if<
+           !std::is_scalar<typename std::remove_pointer<T>::type>::value &&
+           !is_specialisation_of_Offset<T>::value &&
+           !is_specialisation_of_Offset64<T>::value>::type> {
+ private:
+  typedef typename std::remove_pointer<typename std::remove_cv<T>::type>::type
+      pointee_type;
+
+ public:
+  typedef const pointee_type* return_type;
+  typedef pointee_type* mutable_return_type;
+  static const size_t element_stride = sizeof(pointee_type);
+
+  static return_type Read(const uint8_t* const p, const size_t i) {
+    // Structs are stored inline, relative to the first struct pointer.
+    return reinterpret_cast<return_type>(p + i * element_stride);
+  }
+  static mutable_return_type Read(uint8_t* const p, const size_t i) {
+    // Structs are stored inline, relative to the first struct pointer.
+    return reinterpret_cast<mutable_return_type>(p + i * element_stride);
+  }
+};
+
+/// @brief Get a pointer to the file_identifier section of the buffer.
+/// @return Returns a const char pointer to the start of the file_identifier
+/// characters in the buffer.  The returned char * has length
+/// 'flatbuffers::FlatBufferBuilder::kFileIdentifierLength'.
+/// This function is UNDEFINED for FlatBuffers whose schema does not include
+/// a file_identifier (likely points at padding or the start of a the root
+/// vtable).
+inline const char* GetBufferIdentifier(const void* buf,
+                                       bool size_prefixed = false) {
+  return reinterpret_cast<const char*>(buf) +
+         ((size_prefixed) ? 2 * sizeof(uoffset_t) : sizeof(uoffset_t));
+}
+
+// Helper to see if the identifier in a buffer has the expected value.
+inline bool BufferHasIdentifier(const void* buf, const char* identifier,
+                                bool size_prefixed = false) {
+  return strncmp(GetBufferIdentifier(buf, size_prefixed), identifier,
+                 flatbuffers::kFileIdentifierLength) == 0;
+}
+
+/// @cond FLATBUFFERS_INTERNAL
+// Helpers to get a typed pointer to the root object contained in the buffer.
+template <typename T>
+T* GetMutableRoot(void* buf) {
+  if (!buf) return nullptr;
+  EndianCheck();
+  return reinterpret_cast<T*>(reinterpret_cast<uint8_t*>(buf) +
+                              EndianScalar(*reinterpret_cast<uoffset_t*>(buf)));
+}
+
+template <typename T, typename SizeT = uoffset_t>
+T* GetMutableSizePrefixedRoot(void* buf) {
+  return GetMutableRoot<T>(reinterpret_cast<uint8_t*>(buf) + sizeof(SizeT));
+}
+
+template <typename T>
+const T* GetRoot(const void* buf) {
+  return GetMutableRoot<T>(const_cast<void*>(buf));
+}
+
+template <typename T, typename SizeT = uoffset_t>
+const T* GetSizePrefixedRoot(const void* buf) {
+  return GetRoot<T>(reinterpret_cast<const uint8_t*>(buf) + sizeof(SizeT));
+}
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_BUFFER_H_
diff --git a/external/flatbuffers/include/flatbuffers/buffer_ref.h b/external/flatbuffers/include/flatbuffers/buffer_ref.h
new file mode 100644
index 00000000..746903eb
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/buffer_ref.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_BUFFER_REF_H_
+#define FLATBUFFERS_BUFFER_REF_H_
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/verifier.h"
+
+namespace flatbuffers {
+
+// Convenient way to bundle a buffer and its length, to pass it around
+// typed by its root.
+// A BufferRef does not own its buffer.
+struct BufferRefBase {};  // for std::is_base_of
+
+template <typename T>
+struct BufferRef : BufferRefBase {
+  BufferRef() : buf(nullptr), len(0), must_free(false) {}
+  BufferRef(uint8_t* _buf, uoffset_t _len)
+      : buf(_buf), len(_len), must_free(false) {}
+
+  ~BufferRef() {
+    if (must_free) free(buf);
+  }
+
+  const T* GetRoot() const { return flatbuffers::GetRoot<T>(buf); }
+
+  bool Verify() {
+    Verifier verifier(buf, len);
+    return verifier.VerifyBuffer<T>(nullptr);
+  }
+
+  uint8_t* buf;
+  uoffset_t len;
+  bool must_free;
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_BUFFER_REF_H_
diff --git a/external/flatbuffers/include/flatbuffers/code_generator.h b/external/flatbuffers/include/flatbuffers/code_generator.h
new file mode 100644
index 00000000..bfd771da
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/code_generator.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2023 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_CODE_GENERATOR_H_
+#define FLATBUFFERS_CODE_GENERATOR_H_
+
+#include <string>
+
+#include "flatbuffers/file_manager.h"
+#include "flatbuffers/idl.h"
+
+namespace flatbuffers {
+
+struct CodeGenOptions {
+  std::string output_path;
+  FileSaver* file_saver{nullptr};
+};
+
+// A code generator interface for producing converting flatbuffer schema into
+// code.
+class CodeGenerator {
+ public:
+  virtual ~CodeGenerator() = default;
+
+  enum Status {
+    OK = 0,
+    ERROR = 1,
+    FAILED_VERIFICATION = 2,
+    NOT_IMPLEMENTED = 3
+  };
+
+  std::string status_detail;
+
+  // Generate code from the provided `parser`.
+  //
+  // DEPRECATED: prefer using the other overload of GenerateCode for bfbs.
+  virtual Status GenerateCode(const Parser& parser, const std::string& path,
+                              const std::string& filename) = 0;
+
+  // Generate code from the provided `parser` and place it in the output.
+  virtual Status GenerateCodeString(const Parser& parser,
+                                    const std::string& filename,
+                                    std::string& output) {
+    (void)parser;
+    (void)filename;
+    (void)output;
+    return Status::NOT_IMPLEMENTED;
+  }
+
+  // Generate code from the provided `buffer` of given `length`. The buffer is a
+  // serialized reflection.fbs.
+  virtual Status GenerateCode(const uint8_t* buffer, int64_t length,
+                              const CodeGenOptions& options) = 0;
+
+  virtual Status GenerateMakeRule(const Parser& parser, const std::string& path,
+                                  const std::string& filename,
+                                  std::string& output) = 0;
+
+  virtual Status GenerateGrpcCode(const Parser& parser, const std::string& path,
+                                  const std::string& filename) = 0;
+
+  virtual Status GenerateRootFile(const Parser& parser,
+                                  const std::string& path) = 0;
+
+  virtual bool IsSchemaOnly() const = 0;
+
+  virtual bool SupportsBfbsGeneration() const = 0;
+
+  virtual bool SupportsRootFileGeneration() const = 0;
+
+  virtual IDLOptions::Language Language() const = 0;
+
+  virtual std::string LanguageName() const = 0;
+
+ protected:
+  CodeGenerator() = default;
+
+ private:
+  // Copying is not supported.
+  CodeGenerator(const CodeGenerator&) = delete;
+  CodeGenerator& operator=(const CodeGenerator&) = delete;
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_CODE_GENERATOR_H_
diff --git a/external/flatbuffers/include/flatbuffers/code_generators.h b/external/flatbuffers/include/flatbuffers/code_generators.h
new file mode 100644
index 00000000..d284ac5a
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/code_generators.h
@@ -0,0 +1,238 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_CODE_GENERATORS_H_
+#define FLATBUFFERS_CODE_GENERATORS_H_
+
+#include <map>
+#include <sstream>
+
+#include "flatbuffers/idl.h"
+
+namespace flatbuffers {
+
+// Utility class to assist in generating code through use of text templates.
+//
+// Example code:
+//   CodeWriter code("\t");
+//   code.SetValue("NAME", "Foo");
+//   code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
+//   code.SetValue("NAME", "Bar");
+//   code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
+//   std::cout << code.ToString() << std::endl;
+//
+// Output:
+//  void Foo() { printf("%s", "Foo"); }
+//  void Bar() { printf("%s", "Bar"); }
+class CodeWriter {
+ public:
+  CodeWriter(std::string pad = std::string())
+      : pad_(pad), cur_ident_lvl_(0), ignore_ident_(false) {}
+
+  // Clears the current "written" code.
+  void Clear() {
+    stream_.str("");
+    stream_.clear();
+  }
+
+  // Associates a key with a value.  All subsequent calls to operator+=, where
+  // the specified key is contained in {{ and }} delimiters will be replaced by
+  // the given value.
+  void SetValue(const std::string& key, const std::string& value) {
+    value_map_[key] = value;
+  }
+
+  std::string GetValue(const std::string& key) const {
+    const auto it = value_map_.find(key);
+    return it == value_map_.end() ? "" : it->second;
+  }
+
+  // Appends the given text to the generated code as well as a newline
+  // character.  Any text within {{ and }} delimiters is replaced by values
+  // previously stored in the CodeWriter by calling SetValue above.  The newline
+  // will be suppressed if the text ends with the \\ character.
+  void operator+=(std::string text);
+
+  // Returns the current contents of the CodeWriter as a std::string.
+  std::string ToString() const { return stream_.str(); }
+
+  // Increase ident level for writing code
+  void IncrementIdentLevel() { cur_ident_lvl_++; }
+  // Decrease ident level for writing code
+  void DecrementIdentLevel() {
+    if (cur_ident_lvl_) cur_ident_lvl_--;
+  }
+
+  void SetPadding(const std::string& padding) { pad_ = padding; }
+
+ private:
+  std::map<std::string, std::string> value_map_;
+  std::stringstream stream_;
+  std::string pad_;
+  int cur_ident_lvl_;
+  bool ignore_ident_;
+
+  // Add ident padding (tab or space) based on ident level
+  void AppendIdent(std::stringstream& stream);
+};
+
+class BaseGenerator {
+ public:
+  virtual bool generate() = 0;
+
+  static std::string NamespaceDir(const Parser& parser, const std::string& path,
+                                  const Namespace& ns,
+                                  const bool dasherize = false);
+
+  std::string GeneratedFileName(const std::string& path,
+                                const std::string& file_name,
+                                const IDLOptions& options) const;
+
+ protected:
+  BaseGenerator(const Parser& parser, const std::string& path,
+                const std::string& file_name, std::string qualifying_start,
+                std::string qualifying_separator, std::string default_extension)
+      : parser_(parser),
+        path_(path),
+        file_name_(file_name),
+        qualifying_start_(qualifying_start),
+        qualifying_separator_(qualifying_separator),
+        default_extension_(default_extension) {}
+  virtual ~BaseGenerator() {}
+
+  // No copy/assign.
+  BaseGenerator& operator=(const BaseGenerator&);
+  BaseGenerator(const BaseGenerator&);
+
+  std::string NamespaceDir(const Namespace& ns,
+                           const bool dasherize = false) const;
+
+  static const char* FlatBuffersGeneratedWarning();
+
+  static std::string FullNamespace(const char* separator, const Namespace& ns);
+
+  static std::string LastNamespacePart(const Namespace& ns);
+
+  // tracks the current namespace for early exit in WrapInNameSpace
+  // c++, java and csharp returns a different namespace from
+  // the following default (no early exit, always fully qualify),
+  // which works for js and php
+  virtual const Namespace* CurrentNameSpace() const { return nullptr; }
+
+  // Ensure that a type is prefixed with its namespace even within
+  // its own namespace to avoid conflict between generated method
+  // names and similarly named classes or structs
+  std::string WrapInNameSpace(const Namespace* ns,
+                              const std::string& name) const;
+
+  std::string WrapInNameSpace(const Definition& def,
+                              const std::string& suffix = "") const;
+
+  std::string GetNameSpace(const Definition& def) const;
+
+  const Parser& parser_;
+  const std::string& path_;
+  const std::string& file_name_;
+  const std::string qualifying_start_;
+  const std::string qualifying_separator_;
+  const std::string default_extension_;
+};
+
+struct CommentConfig {
+  const char* first_line;
+  const char* content_line_prefix;
+  const char* last_line;
+};
+
+extern void GenComment(const std::vector<std::string>& dc,
+                       std::string* code_ptr, const CommentConfig* config,
+                       const char* prefix = "");
+
+class FloatConstantGenerator {
+ public:
+  virtual ~FloatConstantGenerator() {}
+  std::string GenFloatConstant(const FieldDef& field) const;
+
+ private:
+  virtual std::string Value(double v, const std::string& src) const = 0;
+  virtual std::string Inf(double v) const = 0;
+  virtual std::string NaN(double v) const = 0;
+
+  virtual std::string Value(float v, const std::string& src) const = 0;
+  virtual std::string Inf(float v) const = 0;
+  virtual std::string NaN(float v) const = 0;
+
+  template <typename T>
+  std::string GenFloatConstantImpl(const FieldDef& field) const;
+};
+
+class SimpleFloatConstantGenerator : public FloatConstantGenerator {
+ public:
+  SimpleFloatConstantGenerator(const char* nan_number,
+                               const char* pos_inf_number,
+                               const char* neg_inf_number);
+
+ private:
+  std::string Value(double v,
+                    const std::string& src) const FLATBUFFERS_OVERRIDE;
+  std::string Inf(double v) const FLATBUFFERS_OVERRIDE;
+  std::string NaN(double v) const FLATBUFFERS_OVERRIDE;
+
+  std::string Value(float v, const std::string& src) const FLATBUFFERS_OVERRIDE;
+  std::string Inf(float v) const FLATBUFFERS_OVERRIDE;
+  std::string NaN(float v) const FLATBUFFERS_OVERRIDE;
+
+  const std::string nan_number_;
+  const std::string pos_inf_number_;
+  const std::string neg_inf_number_;
+};
+
+// C++, C#, Java like generator.
+class TypedFloatConstantGenerator : public FloatConstantGenerator {
+ public:
+  TypedFloatConstantGenerator(const char* double_prefix,
+                              const char* single_prefix, const char* nan_number,
+                              const char* pos_inf_number,
+                              const char* neg_inf_number = "");
+
+ private:
+  std::string Value(double v,
+                    const std::string& src) const FLATBUFFERS_OVERRIDE;
+  std::string Inf(double v) const FLATBUFFERS_OVERRIDE;
+
+  std::string NaN(double v) const FLATBUFFERS_OVERRIDE;
+
+  std::string Value(float v, const std::string& src) const FLATBUFFERS_OVERRIDE;
+  std::string Inf(float v) const FLATBUFFERS_OVERRIDE;
+  std::string NaN(float v) const FLATBUFFERS_OVERRIDE;
+
+  std::string MakeNaN(const std::string& prefix) const;
+  std::string MakeInf(bool neg, const std::string& prefix) const;
+
+  const std::string double_prefix_;
+  const std::string single_prefix_;
+  const std::string nan_number_;
+  const std::string pos_inf_number_;
+  const std::string neg_inf_number_;
+};
+
+std::string JavaCSharpMakeRule(const bool java, const Parser& parser,
+                               const std::string& path,
+                               const std::string& file_name);
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_CODE_GENERATORS_H_
diff --git a/external/flatbuffers/include/flatbuffers/default_allocator.h b/external/flatbuffers/include/flatbuffers/default_allocator.h
new file mode 100644
index 00000000..d1cab08d
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/default_allocator.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_DEFAULT_ALLOCATOR_H_
+#define FLATBUFFERS_DEFAULT_ALLOCATOR_H_
+
+#include "flatbuffers/allocator.h"
+#include "flatbuffers/base.h"
+
+namespace flatbuffers {
+
+// DefaultAllocator uses new/delete to allocate memory regions
+class DefaultAllocator : public Allocator {
+ public:
+  uint8_t* allocate(size_t size) FLATBUFFERS_OVERRIDE {
+    return new uint8_t[size];
+  }
+
+  void deallocate(uint8_t* p, size_t) FLATBUFFERS_OVERRIDE { delete[] p; }
+
+  static void dealloc(void* p, size_t) { delete[] static_cast<uint8_t*>(p); }
+};
+
+// These functions allow for a null allocator to mean use the default allocator,
+// as used by DetachedBuffer and vector_downward below.
+// This is to avoid having a statically or dynamically allocated default
+// allocator, or having to move it between the classes that may own it.
+inline uint8_t* Allocate(Allocator* allocator, size_t size) {
+  return allocator ? allocator->allocate(size)
+                   : DefaultAllocator().allocate(size);
+}
+
+inline void Deallocate(Allocator* allocator, uint8_t* p, size_t size) {
+  if (allocator)
+    allocator->deallocate(p, size);
+  else
+    DefaultAllocator().deallocate(p, size);
+}
+
+inline uint8_t* ReallocateDownward(Allocator* allocator, uint8_t* old_p,
+                                   size_t old_size, size_t new_size,
+                                   size_t in_use_back, size_t in_use_front) {
+  return allocator ? allocator->reallocate_downward(old_p, old_size, new_size,
+                                                    in_use_back, in_use_front)
+                   : DefaultAllocator().reallocate_downward(
+                         old_p, old_size, new_size, in_use_back, in_use_front);
+}
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_DEFAULT_ALLOCATOR_H_
diff --git a/external/flatbuffers/include/flatbuffers/detached_buffer.h b/external/flatbuffers/include/flatbuffers/detached_buffer.h
new file mode 100644
index 00000000..0577a42d
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/detached_buffer.h
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_DETACHED_BUFFER_H_
+#define FLATBUFFERS_DETACHED_BUFFER_H_
+
+#include "flatbuffers/allocator.h"
+#include "flatbuffers/base.h"
+#include "flatbuffers/default_allocator.h"
+
+namespace flatbuffers {
+
+// DetachedBuffer is a finished flatbuffer memory region, detached from its
+// builder. The original memory region and allocator are also stored so that
+// the DetachedBuffer can manage the memory lifetime.
+class DetachedBuffer {
+ public:
+  DetachedBuffer()
+      : allocator_(nullptr),
+        own_allocator_(false),
+        buf_(nullptr),
+        reserved_(0),
+        cur_(nullptr),
+        size_(0) {}
+
+  DetachedBuffer(Allocator* allocator, bool own_allocator, uint8_t* buf,
+                 size_t reserved, uint8_t* cur, size_t sz)
+      : allocator_(allocator),
+        own_allocator_(own_allocator),
+        buf_(buf),
+        reserved_(reserved),
+        cur_(cur),
+        size_(sz) {}
+
+  DetachedBuffer(DetachedBuffer&& other) noexcept
+      : allocator_(other.allocator_),
+        own_allocator_(other.own_allocator_),
+        buf_(other.buf_),
+        reserved_(other.reserved_),
+        cur_(other.cur_),
+        size_(other.size_) {
+    other.reset();
+  }
+
+  DetachedBuffer& operator=(DetachedBuffer&& other) noexcept {
+    if (this == &other) return *this;
+
+    destroy();
+
+    allocator_ = other.allocator_;
+    own_allocator_ = other.own_allocator_;
+    buf_ = other.buf_;
+    reserved_ = other.reserved_;
+    cur_ = other.cur_;
+    size_ = other.size_;
+
+    other.reset();
+
+    return *this;
+  }
+
+  ~DetachedBuffer() { destroy(); }
+
+  const uint8_t* data() const { return cur_; }
+
+  uint8_t* data() { return cur_; }
+
+  size_t size() const { return size_; }
+
+  uint8_t* begin() { return data(); }
+  const uint8_t* begin() const { return data(); }
+  uint8_t* end() { return data() + size(); }
+  const uint8_t* end() const { return data() + size(); }
+
+  // These may change access mode, leave these at end of public section
+  FLATBUFFERS_DELETE_FUNC(DetachedBuffer(const DetachedBuffer& other));
+  FLATBUFFERS_DELETE_FUNC(
+      DetachedBuffer& operator=(const DetachedBuffer& other));
+
+ protected:
+  Allocator* allocator_;
+  bool own_allocator_;
+  uint8_t* buf_;
+  size_t reserved_;
+  uint8_t* cur_;
+  size_t size_;
+
+  inline void destroy() {
+    if (buf_) Deallocate(allocator_, buf_, reserved_);
+    if (own_allocator_ && allocator_) {
+      delete allocator_;
+    }
+    reset();
+  }
+
+  inline void reset() {
+    allocator_ = nullptr;
+    own_allocator_ = false;
+    buf_ = nullptr;
+    reserved_ = 0;
+    cur_ = nullptr;
+    size_ = 0;
+  }
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_DETACHED_BUFFER_H_
diff --git a/external/flatbuffers/include/flatbuffers/file_manager.h b/external/flatbuffers/include/flatbuffers/file_manager.h
new file mode 100644
index 00000000..bafe6f29
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/file_manager.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2023 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_FILE_MANAGER_H_
+#define FLATBUFFERS_FILE_MANAGER_H_
+
+#include <cstddef>
+#include <set>
+#include <string>
+
+namespace flatbuffers {
+
+// A File interface to write data to file by default or
+// save only file names
+class FileSaver {
+ public:
+  FileSaver() = default;
+  virtual ~FileSaver() = default;
+
+  virtual bool SaveFile(const char* name, const char* buf, size_t len,
+                        bool binary) = 0;
+
+  bool SaveFile(const char* name, const std::string& buf, bool binary) {
+    return SaveFile(name, buf.c_str(), buf.size(), binary);
+  }
+
+  virtual void Finish() {}
+
+ private:
+  // Copying is not supported.
+  FileSaver(const FileSaver&) = delete;
+  FileSaver& operator=(const FileSaver&) = delete;
+  // Rule of 5
+  FileSaver(FileSaver&&) = default;
+  FileSaver& operator=(FileSaver&&) = default;
+};
+
+class RealFileSaver final : public FileSaver {
+ public:
+  bool SaveFile(const char* name, const char* buf, size_t len,
+                bool binary) final;
+};
+
+class FileNameSaver final : public FileSaver {
+ public:
+  bool SaveFile(const char* name, const char* buf, size_t len,
+                bool binary) final;
+
+  void Finish() final;
+
+ private:
+  std::set<std::string> file_names_{};
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_FILE_MANAGER_H_
diff --git a/external/flatbuffers/include/flatbuffers/flatbuffer_builder.h b/external/flatbuffers/include/flatbuffers/flatbuffer_builder.h
new file mode 100644
index 00000000..636d3776
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/flatbuffer_builder.h
@@ -0,0 +1,1518 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_FLATBUFFER_BUILDER_H_
+#define FLATBUFFERS_FLATBUFFER_BUILDER_H_
+
+#include <algorithm>
+#include <cstdint>
+#include <functional>
+#include <initializer_list>
+#include <type_traits>
+
+#include "flatbuffers/allocator.h"
+#include "flatbuffers/array.h"
+#include "flatbuffers/base.h"
+#include "flatbuffers/buffer.h"
+#include "flatbuffers/buffer_ref.h"
+#include "flatbuffers/default_allocator.h"
+#include "flatbuffers/detached_buffer.h"
+#include "flatbuffers/stl_emulation.h"
+#include "flatbuffers/string.h"
+#include "flatbuffers/struct.h"
+#include "flatbuffers/table.h"
+#include "flatbuffers/vector.h"
+#include "flatbuffers/vector_downward.h"
+#include "flatbuffers/verifier.h"
+
+namespace flatbuffers {
+
+// Converts a Field ID to a virtual table offset.
+inline voffset_t FieldIndexToOffset(voffset_t field_id) {
+  // Should correspond to what EndTable() below builds up.
+  const voffset_t fixed_fields =
+      2 * sizeof(voffset_t);  // Vtable size and Object Size.
+  size_t offset = fixed_fields + field_id * sizeof(voffset_t);
+  FLATBUFFERS_ASSERT(offset < std::numeric_limits<voffset_t>::max());
+  return static_cast<voffset_t>(offset);
+}
+
+template <typename T, typename Alloc = std::allocator<T>>
+const T* data(const std::vector<T, Alloc>& v) {
+  // Eventually the returned pointer gets passed down to memcpy, so
+  // we need it to be non-null to avoid undefined behavior.
+  static uint8_t t;
+  return v.empty() ? reinterpret_cast<const T*>(&t) : &v.front();
+}
+template <typename T, typename Alloc = std::allocator<T>>
+T* data(std::vector<T, Alloc>& v) {
+  // Eventually the returned pointer gets passed down to memcpy, so
+  // we need it to be non-null to avoid undefined behavior.
+  static uint8_t t;
+  return v.empty() ? reinterpret_cast<T*>(&t) : &v.front();
+}
+
+/// @addtogroup flatbuffers_cpp_api
+/// @{
+/// @class FlatBufferBuilder
+/// @brief Helper class to hold data needed in creation of a FlatBuffer.
+/// To serialize data, you typically call one of the `Create*()` functions in
+/// the generated code, which in turn call a sequence of `StartTable`/
+/// `PushElement`/`AddElement`/`EndTable`, or the builtin `CreateString`/
+/// `CreateVector` functions. Do this is depth-first order to build up a tree to
+/// the root. `Finish()` wraps up the buffer ready for transport.
+template <bool Is64Aware = false>
+class FlatBufferBuilderImpl {
+ public:
+  // This switches the size type of the builder, based on if its 64-bit aware
+  // (uoffset64_t) or not (uoffset_t).
+  typedef
+      typename std::conditional<Is64Aware, uoffset64_t, uoffset_t>::type SizeT;
+
+  /// @brief Default constructor for FlatBufferBuilder.
+  /// @param[in] initial_size The initial size of the buffer, in bytes. Defaults
+  /// to `1024`.
+  /// @param[in] allocator An `Allocator` to use. If null will use
+  /// `DefaultAllocator`.
+  /// @param[in] own_allocator Whether the builder/vector should own the
+  /// allocator. Defaults to / `false`.
+  /// @param[in] buffer_minalign Force the buffer to be aligned to the given
+  /// minimum alignment upon reallocation. Only needed if you intend to store
+  /// types with custom alignment AND you wish to read the buffer in-place
+  /// directly after creation.
+  explicit FlatBufferBuilderImpl(
+      size_t initial_size = 1024, Allocator* allocator = nullptr,
+      bool own_allocator = false,
+      size_t buffer_minalign = AlignOf<largest_scalar_t>())
+      : buf_(initial_size, allocator, own_allocator, buffer_minalign,
+             static_cast<SizeT>(Is64Aware ? FLATBUFFERS_MAX_64_BUFFER_SIZE
+                                          : FLATBUFFERS_MAX_BUFFER_SIZE)),
+        num_field_loc(0),
+        max_voffset_(0),
+        length_of_64_bit_region_(0),
+        nested(false),
+        finished(false),
+        minalign_(1),
+        force_defaults_(false),
+        dedup_vtables_(true),
+        string_pool(nullptr) {
+    EndianCheck();
+  }
+
+  /// @brief Move constructor for FlatBufferBuilder.
+  FlatBufferBuilderImpl(FlatBufferBuilderImpl&& other) noexcept
+      : buf_(1024, nullptr, false, AlignOf<largest_scalar_t>(),
+             static_cast<SizeT>(Is64Aware ? FLATBUFFERS_MAX_64_BUFFER_SIZE
+                                          : FLATBUFFERS_MAX_BUFFER_SIZE)),
+        num_field_loc(0),
+        max_voffset_(0),
+        length_of_64_bit_region_(0),
+        nested(false),
+        finished(false),
+        minalign_(1),
+        force_defaults_(false),
+        dedup_vtables_(true),
+        string_pool(nullptr) {
+    EndianCheck();
+    // Default construct and swap idiom.
+    // Lack of delegating constructors in vs2010 makes it more verbose than
+    // needed.
+    Swap(other);
+  }
+
+  /// @brief Move assignment operator for FlatBufferBuilder.
+  FlatBufferBuilderImpl& operator=(FlatBufferBuilderImpl&& other) noexcept {
+    // Move construct a temporary and swap idiom
+    FlatBufferBuilderImpl temp(std::move(other));
+    Swap(temp);
+    return *this;
+  }
+
+  void Swap(FlatBufferBuilderImpl& other) {
+    using std::swap;
+    buf_.swap(other.buf_);
+    swap(num_field_loc, other.num_field_loc);
+    swap(max_voffset_, other.max_voffset_);
+    swap(length_of_64_bit_region_, other.length_of_64_bit_region_);
+    swap(nested, other.nested);
+    swap(finished, other.finished);
+    swap(minalign_, other.minalign_);
+    swap(force_defaults_, other.force_defaults_);
+    swap(dedup_vtables_, other.dedup_vtables_);
+    swap(string_pool, other.string_pool);
+  }
+
+  ~FlatBufferBuilderImpl() {
+    if (string_pool) delete string_pool;
+  }
+
+  void Reset() {
+    Clear();       // clear builder state
+    buf_.reset();  // deallocate buffer
+  }
+
+  /// @brief Reset all the state in this FlatBufferBuilder so it can be reused
+  /// to construct another buffer.
+  void Clear() {
+    ClearOffsets();
+    buf_.clear();
+    nested = false;
+    finished = false;
+    minalign_ = 1;
+    length_of_64_bit_region_ = 0;
+    if (string_pool) string_pool->clear();
+  }
+
+  /// @brief The current size of the serialized buffer, counting from the end.
+  /// @return Returns an `SizeT` with the current size of the buffer.
+  SizeT GetSize() const { return buf_.size(); }
+
+  /// @brief The current size of the serialized buffer relative to the end of
+  /// the 32-bit region.
+  /// @return Returns an `uoffset_t` with the current size of the buffer.
+  template <bool is_64 = Is64Aware>
+  // Only enable this method for the 64-bit builder, as only that builder is
+  // concerned with the 32/64-bit boundary, and should be the one to bare any
+  // run time costs.
+  typename std::enable_if<is_64, uoffset_t>::type GetSizeRelative32BitRegion()
+      const {
+    //[32-bit region][64-bit region]
+    //         [XXXXXXXXXXXXXXXXXXX] GetSize()
+    //               [YYYYYYYYYYYYY] length_of_64_bit_region_
+    //         [ZZZZ]                return size
+    return static_cast<uoffset_t>(GetSize() - length_of_64_bit_region_);
+  }
+
+  template <bool is_64 = Is64Aware>
+  // Only enable this method for the 32-bit builder.
+  typename std::enable_if<!is_64, uoffset_t>::type GetSizeRelative32BitRegion()
+      const {
+    return static_cast<uoffset_t>(GetSize());
+  }
+
+  /// @brief Get the serialized buffer (after you call `Finish()`).
+  /// @return Returns an `uint8_t` pointer to the FlatBuffer data inside the
+  /// buffer.
+  uint8_t* GetBufferPointer() const {
+    Finished();
+    return buf_.data();
+  }
+
+  /// @brief Get the serialized buffer (after you call `Finish()`) as a span.
+  /// @return Returns a constructed flatbuffers::span that is a view over the
+  /// FlatBuffer data inside the buffer.
+  flatbuffers::span<uint8_t> GetBufferSpan() const {
+    Finished();
+    return flatbuffers::span<uint8_t>(buf_.data(), buf_.size());
+  }
+
+  /// @brief Get a pointer to an unfinished buffer.
+  /// @return Returns a `uint8_t` pointer to the unfinished buffer.
+  uint8_t* GetCurrentBufferPointer() const { return buf_.data(); }
+
+  /// @brief Get the released DetachedBuffer.
+  /// @return A `DetachedBuffer` that owns the buffer and its allocator.
+  DetachedBuffer Release() {
+    Finished();
+    DetachedBuffer buffer = buf_.release();
+    Clear();
+    return buffer;
+  }
+
+  /// @brief Get the released pointer to the serialized buffer.
+  /// @param size The size of the memory block containing
+  /// the serialized `FlatBuffer`.
+  /// @param offset The offset from the released pointer where the finished
+  /// `FlatBuffer` starts.
+  /// @return A raw pointer to the start of the memory block containing
+  /// the serialized `FlatBuffer`.
+  /// @remark If the allocator is owned, it gets deleted when the destructor is
+  /// called.
+  uint8_t* ReleaseRaw(size_t& size, size_t& offset) {
+    Finished();
+    uint8_t* raw = buf_.release_raw(size, offset);
+    Clear();
+    return raw;
+  }
+
+  /// @brief get the minimum alignment this buffer needs to be accessed
+  /// properly. This is only known once all elements have been written (after
+  /// you call Finish()). You can use this information if you need to embed
+  /// a FlatBuffer in some other buffer, such that you can later read it
+  /// without first having to copy it into its own buffer.
+  size_t GetBufferMinAlignment() const {
+    Finished();
+    return minalign_;
+  }
+
+  /// @cond FLATBUFFERS_INTERNAL
+  void Finished() const {
+    // If you get this assert, you're attempting to get access a buffer
+    // which hasn't been finished yet. Be sure to call
+    // FlatBufferBuilder::Finish with your root table.
+    // If you really need to access an unfinished buffer, call
+    // GetCurrentBufferPointer instead.
+    FLATBUFFERS_ASSERT(finished);
+  }
+  /// @endcond
+
+  /// @brief In order to save space, fields that are set to their default value
+  /// don't get serialized into the buffer.
+  /// @param[in] fd When set to `true`, always serializes default values that
+  /// are set. Optional fields which are not set explicitly, will still not be
+  /// serialized.
+  void ForceDefaults(bool fd) { force_defaults_ = fd; }
+
+  /// @brief By default vtables are deduped in order to save space.
+  /// @param[in] dedup When set to `true`, dedup vtables.
+  void DedupVtables(bool dedup) { dedup_vtables_ = dedup; }
+
+  /// @cond FLATBUFFERS_INTERNAL
+  void Pad(size_t num_bytes) { buf_.fill(num_bytes); }
+
+  void TrackMinAlign(size_t elem_size) {
+    if (elem_size > minalign_) minalign_ = elem_size;
+  }
+
+  void Align(size_t elem_size) {
+    TrackMinAlign(elem_size);
+    buf_.fill(PaddingBytes(buf_.size(), elem_size));
+  }
+
+  void PushFlatBuffer(const uint8_t* bytes, size_t size) {
+    PushBytes(bytes, size);
+    finished = true;
+  }
+
+  void PushBytes(const uint8_t* bytes, size_t size) { buf_.push(bytes, size); }
+
+  void PopBytes(size_t amount) { buf_.pop(amount); }
+
+  template <typename T>
+  void AssertScalarT() {
+    // The code assumes power of 2 sizes and endian-swap-ability.
+    static_assert(flatbuffers::is_scalar<T>::value, "T must be a scalar type");
+  }
+
+  // Write a single aligned scalar to the buffer
+  template <typename T, typename ReturnT = uoffset_t>
+  ReturnT PushElement(T element) {
+    AssertScalarT<T>();
+    Align(sizeof(T));
+    buf_.push_small(EndianScalar(element));
+    return CalculateOffset<ReturnT>();
+  }
+
+  template <typename T, template <typename> class OffsetT = Offset>
+  uoffset_t PushElement(OffsetT<T> off) {
+    // Special case for offsets: see ReferTo below.
+    return PushElement(ReferTo(off.o));
+  }
+
+  // When writing fields, we track where they are, so we can create correct
+  // vtables later.
+  void TrackField(voffset_t field, uoffset_t off) {
+    FieldLoc fl = {off, field};
+    buf_.scratch_push_small(fl);
+    num_field_loc++;
+    if (field > max_voffset_) {
+      max_voffset_ = field;
+    }
+  }
+
+  // Like PushElement, but additionally tracks the field this represents.
+  template <typename T>
+  void AddElement(voffset_t field, T e, T def) {
+    // We don't serialize values equal to the default.
+    if (IsTheSameAs(e, def) && !force_defaults_) return;
+    TrackField(field, PushElement(e));
+  }
+
+  template <typename T>
+  void AddElement(voffset_t field, T e) {
+    TrackField(field, PushElement(e));
+  }
+
+  template <typename T>
+  void AddOffset(voffset_t field, Offset<T> off) {
+    if (off.IsNull()) return;  // Don't store.
+    AddElement(field, ReferTo(off.o), static_cast<uoffset_t>(0));
+  }
+
+  template <typename T>
+  void AddOffset(voffset_t field, Offset64<T> off) {
+    if (off.IsNull()) return;  // Don't store.
+    AddElement(field, ReferTo(off.o), static_cast<uoffset64_t>(0));
+  }
+
+  template <typename T>
+  void AddStruct(voffset_t field, const T* structptr) {
+    if (!structptr) return;  // Default, don't store.
+    Align(AlignOf<T>());
+    buf_.push_small(*structptr);
+    TrackField(field, CalculateOffset<uoffset_t>());
+  }
+
+  void AddStructOffset(voffset_t field, uoffset_t off) {
+    TrackField(field, off);
+  }
+
+  // Offsets initially are relative to the end of the buffer (downwards).
+  // This function converts them to be relative to the current location
+  // in the buffer (when stored here), pointing upwards.
+  uoffset_t ReferTo(uoffset_t off) {
+    // Align to ensure GetSizeRelative32BitRegion() below is correct.
+    Align(sizeof(uoffset_t));
+    // 32-bit offsets are relative to the tail of the 32-bit region of the
+    // buffer. For most cases (without 64-bit entities) this is equivalent to
+    // size of the whole buffer (e.g. GetSize())
+    return ReferTo(off, GetSizeRelative32BitRegion());
+  }
+
+  uoffset64_t ReferTo(uoffset64_t off) {
+    // Align to ensure GetSize() below is correct.
+    Align(sizeof(uoffset64_t));
+    // 64-bit offsets are relative to tail of the whole buffer
+    return ReferTo(off, GetSize());
+  }
+
+  template <typename T, typename T2>
+  T ReferTo(const T off, const T2 size) {
+    FLATBUFFERS_ASSERT(off && off <= size);
+    return size - off + static_cast<T>(sizeof(T));
+  }
+
+  template <typename T>
+  T ReferTo(const T off, const T size) {
+    FLATBUFFERS_ASSERT(off && off <= size);
+    return size - off + static_cast<T>(sizeof(T));
+  }
+
+  void NotNested() {
+    // If you hit this, you're trying to construct a Table/Vector/String
+    // during the construction of its parent table (between the MyTableBuilder
+    // and table.Finish().
+    // Move the creation of these sub-objects to above the MyTableBuilder to
+    // not get this assert.
+    // Ignoring this assert may appear to work in simple cases, but the reason
+    // it is here is that storing objects in-line may cause vtable offsets
+    // to not fit anymore. It also leads to vtable duplication.
+    FLATBUFFERS_ASSERT(!nested);
+    // If you hit this, fields were added outside the scope of a table.
+    FLATBUFFERS_ASSERT(!num_field_loc);
+  }
+
+  // From generated code (or from the parser), we call StartTable/EndTable
+  // with a sequence of AddElement calls in between.
+  uoffset_t StartTable() {
+    NotNested();
+    nested = true;
+    return GetSizeRelative32BitRegion();
+  }
+
+  // This finishes one serialized object by generating the vtable if it's a
+  // table, comparing it against existing vtables, and writing the
+  // resulting vtable offset.
+  uoffset_t EndTable(uoffset_t start) {
+    // If you get this assert, a corresponding StartTable wasn't called.
+    FLATBUFFERS_ASSERT(nested);
+    // Write the vtable offset, which is the start of any Table.
+    // We fill its value later.
+    // This is relative to the end of the 32-bit region.
+    const uoffset_t vtable_offset_loc =
+        static_cast<uoffset_t>(PushElement<soffset_t>(0));
+    // Write a vtable, which consists entirely of voffset_t elements.
+    // It starts with the number of offsets, followed by a type id, followed
+    // by the offsets themselves. In reverse:
+    // Include space for the last offset and ensure empty tables have a
+    // minimum size.
+    max_voffset_ =
+        (std::max)(static_cast<voffset_t>(max_voffset_ + sizeof(voffset_t)),
+                   FieldIndexToOffset(0));
+    buf_.fill_big(max_voffset_);
+    const uoffset_t table_object_size = vtable_offset_loc - start;
+    // Vtable use 16bit offsets.
+    FLATBUFFERS_ASSERT(table_object_size < 0x10000);
+    WriteScalar<voffset_t>(buf_.data() + sizeof(voffset_t),
+                           static_cast<voffset_t>(table_object_size));
+    WriteScalar<voffset_t>(buf_.data(), max_voffset_);
+    // Write the offsets into the table
+    for (auto it = buf_.scratch_end() - num_field_loc * sizeof(FieldLoc);
+         it < buf_.scratch_end(); it += sizeof(FieldLoc)) {
+      auto field_location = reinterpret_cast<FieldLoc*>(it);
+      const voffset_t pos =
+          static_cast<voffset_t>(vtable_offset_loc - field_location->off);
+      // If this asserts, it means you've set a field twice.
+      FLATBUFFERS_ASSERT(
+          !ReadScalar<voffset_t>(buf_.data() + field_location->id));
+      WriteScalar<voffset_t>(buf_.data() + field_location->id, pos);
+    }
+    ClearOffsets();
+    auto vt1 = reinterpret_cast<voffset_t*>(buf_.data());
+    auto vt1_size = ReadScalar<voffset_t>(vt1);
+    auto vt_use = GetSizeRelative32BitRegion();
+    // See if we already have generated a vtable with this exact same
+    // layout before. If so, make it point to the old one, remove this one.
+    if (dedup_vtables_) {
+      for (auto it = buf_.scratch_data(); it < buf_.scratch_end();
+           it += sizeof(uoffset_t)) {
+        auto vt_offset_ptr = reinterpret_cast<uoffset_t*>(it);
+        auto vt2 = reinterpret_cast<voffset_t*>(
+            buf_.data_at(*vt_offset_ptr + length_of_64_bit_region_));
+        auto vt2_size = ReadScalar<voffset_t>(vt2);
+        if (vt1_size != vt2_size || 0 != memcmp(vt2, vt1, vt1_size)) continue;
+        vt_use = *vt_offset_ptr;
+        buf_.pop(GetSizeRelative32BitRegion() - vtable_offset_loc);
+        break;
+      }
+    }
+    // If this is a new vtable, remember it.
+    if (vt_use == GetSizeRelative32BitRegion()) {
+      buf_.scratch_push_small(vt_use);
+    }
+    // Fill the vtable offset we created above.
+    // The offset points from the beginning of the object to where the vtable is
+    // stored.
+    // Offsets default direction is downward in memory for future format
+    // flexibility (storing all vtables at the start of the file).
+    WriteScalar(buf_.data_at(vtable_offset_loc + length_of_64_bit_region_),
+                static_cast<soffset_t>(vt_use) -
+                    static_cast<soffset_t>(vtable_offset_loc));
+    nested = false;
+    return vtable_offset_loc;
+  }
+
+  FLATBUFFERS_ATTRIBUTE([[deprecated("call the version above instead")]])
+  uoffset_t EndTable(uoffset_t start, voffset_t /*numfields*/) {
+    return EndTable(start);
+  }
+
+  // This checks a required field has been set in a given table that has
+  // just been constructed.
+  template <typename T>
+  void Required(Offset<T> table, voffset_t field) {
+    auto table_ptr = reinterpret_cast<const Table*>(buf_.data_at(table.o));
+    bool ok = table_ptr->GetOptionalFieldOffset(field) != 0;
+    // If this fails, the caller will show what field needs to be set.
+    FLATBUFFERS_ASSERT(ok);
+    (void)ok;
+  }
+
+  uoffset_t StartStruct(size_t alignment) {
+    Align(alignment);
+    return GetSizeRelative32BitRegion();
+  }
+
+  uoffset_t EndStruct() { return GetSizeRelative32BitRegion(); }
+
+  void ClearOffsets() {
+    buf_.scratch_pop(num_field_loc * sizeof(FieldLoc));
+    num_field_loc = 0;
+    max_voffset_ = 0;
+  }
+
+  // Aligns such that when "len" bytes are written, an object can be written
+  // after it (forward in the buffer) with "alignment" without padding.
+  void PreAlign(size_t len, size_t alignment) {
+    if (len == 0) return;
+    TrackMinAlign(alignment);
+    buf_.fill(PaddingBytes(GetSize() + len, alignment));
+  }
+
+  // Aligns such than when "len" bytes are written, an object of type `AlignT`
+  // can be written after it (forward in the buffer) without padding.
+  template <typename AlignT>
+  void PreAlign(size_t len) {
+    AssertScalarT<AlignT>();
+    PreAlign(len, AlignOf<AlignT>());
+  }
+  /// @endcond
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const char pointer to the data to be stored as a string.
+  /// @param[in] len The number of bytes that should be stored from `str`.
+  /// @return Returns the offset in the buffer where the string starts.
+  template <template <typename> class OffsetT = Offset>
+  OffsetT<String> CreateString(const char* str, size_t len) {
+    CreateStringImpl(str, len);
+    return OffsetT<String>(
+        CalculateOffset<typename OffsetT<String>::offset_type>());
+  }
+
+  /// @brief Store a string in the buffer, which is null-terminated.
+  /// @param[in] str A const char pointer to a C-string to add to the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  template <template <typename> class OffsetT = Offset>
+  OffsetT<String> CreateString(const char* str) {
+    return CreateString<OffsetT>(str, strlen(str));
+  }
+
+  /// @brief Store a string in the buffer, which is null-terminated.
+  /// @param[in] str A char pointer to a C-string to add to the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  template <template <typename> class OffsetT = Offset>
+  OffsetT<String> CreateString(char* str) {
+    return CreateString<OffsetT>(str, strlen(str));
+  }
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const reference to a std::string to store in the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  template <template <typename> class OffsetT = Offset>
+  OffsetT<String> CreateString(const std::string& str) {
+    return CreateString<OffsetT>(str.c_str(), str.length());
+  }
+
+  // clang-format off
+  #ifdef FLATBUFFERS_HAS_STRING_VIEW
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const string_view to copy in to the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  template<template <typename> class OffsetT = Offset>
+  OffsetT<String>CreateString(flatbuffers::string_view str) {
+    return CreateString<OffsetT>(str.data(), str.size());
+  }
+  #endif // FLATBUFFERS_HAS_STRING_VIEW
+  // clang-format on
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const pointer to a `String` struct to add to the buffer.
+  /// @return Returns the offset in the buffer where the string starts
+  template <template <typename> class OffsetT = Offset>
+  OffsetT<String> CreateString(const String* str) {
+    return str ? CreateString<OffsetT>(str->c_str(), str->size()) : 0;
+  }
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const reference to a std::string like type with support
+  /// of T::data() and T::length() to store in the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  template <template <typename> class OffsetT = Offset,
+            // No need to explicitly declare the T type, let the compiler deduce
+            // it.
+            int&... ExplicitArgumentBarrier, typename T>
+  OffsetT<String> CreateString(const T& str) {
+    return CreateString<OffsetT>(str.data(), str.length());
+  }
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const char pointer to the data to be stored as a string.
+  /// @param[in] len The number of bytes that should be stored from `str`.
+  /// @return Returns the offset in the buffer where the string starts.
+  Offset<String> CreateSharedString(const char* str, size_t len) {
+    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
+    if (!string_pool) {
+      string_pool = new StringOffsetMap(StringOffsetCompare(buf_));
+    }
+
+    const size_t size_before_string = buf_.size();
+    // Must first serialize the string, since the set is all offsets into
+    // buffer.
+    const Offset<String> off = CreateString<Offset>(str, len);
+    auto it = string_pool->find(off);
+    // If it exists we reuse existing serialized data!
+    if (it != string_pool->end()) {
+      // We can remove the string we serialized.
+      buf_.pop(buf_.size() - size_before_string);
+      return *it;
+    }
+    // Record this string for future use.
+    string_pool->insert(off);
+    return off;
+  }
+
+#ifdef FLATBUFFERS_HAS_STRING_VIEW
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const std::string_view to store in the buffer.
+  /// @return Returns the offset in the buffer where the string starts
+  Offset<String> CreateSharedString(const flatbuffers::string_view str) {
+    return CreateSharedString(str.data(), str.size());
+  }
+#else
+  /// @brief Store a string in the buffer, which null-terminated.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const char pointer to a C-string to add to the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  Offset<String> CreateSharedString(const char* str) {
+    return CreateSharedString(str, strlen(str));
+  }
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const reference to a std::string to store in the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  Offset<String> CreateSharedString(const std::string& str) {
+    return CreateSharedString(str.c_str(), str.length());
+  }
+#endif
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const pointer to a `String` struct to add to the buffer.
+  /// @return Returns the offset in the buffer where the string starts
+  Offset<String> CreateSharedString(const String* str) {
+    return str ? CreateSharedString(str->c_str(), str->size()) : 0;
+  }
+
+  /// @cond FLATBUFFERS_INTERNAL
+  template <typename LenT = uoffset_t, typename ReturnT = uoffset_t>
+  ReturnT EndVector(size_t len) {
+    FLATBUFFERS_ASSERT(nested);  // Hit if no corresponding StartVector.
+    nested = false;
+    return PushElement<LenT, ReturnT>(static_cast<LenT>(len));
+  }
+
+  template <template <typename> class OffsetT = Offset,
+            typename LenT = uint32_t>
+  void StartVector(size_t len, size_t elemsize, size_t alignment) {
+    NotNested();
+    nested = true;
+    // Align to the Length type of the vector (either 32-bit or 64-bit), so
+    // that the length of the buffer can be added without padding.
+    PreAlign<LenT>(len * elemsize);
+    PreAlign(len * elemsize, alignment);  // Just in case elemsize > uoffset_t.
+  }
+
+  template <typename T, template <typename> class OffsetT = Offset,
+            typename LenT = uint32_t>
+  void StartVector(size_t len) {
+    return StartVector<OffsetT, LenT>(len, sizeof(T), AlignOf<T>());
+  }
+
+  // Call this right before StartVector/CreateVector if you want to force the
+  // alignment to be something different than what the element size would
+  // normally dictate.
+  // This is useful when storing a nested_flatbuffer in a vector of bytes,
+  // or when storing SIMD floats, etc.
+  void ForceVectorAlignment(const size_t len, const size_t elemsize,
+                            const size_t alignment) {
+    if (len == 0) return;
+    FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
+    PreAlign(len * elemsize, alignment);
+  }
+
+  template <bool is_64 = Is64Aware>
+  typename std::enable_if<is_64, void>::type ForceVectorAlignment64(
+      const size_t len, const size_t elemsize, const size_t alignment) {
+    // If you hit this assertion, you are trying to force alignment on a
+    // vector with offset64 after serializing a 32-bit offset.
+    FLATBUFFERS_ASSERT(GetSize() == length_of_64_bit_region_);
+
+    // Call through.
+    ForceVectorAlignment(len, elemsize, alignment);
+
+    // Update the 64 bit region.
+    length_of_64_bit_region_ = GetSize();
+  }
+
+  // Similar to ForceVectorAlignment but for String fields.
+  void ForceStringAlignment(size_t len, size_t alignment) {
+    if (len == 0) return;
+    FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
+    PreAlign((len + 1) * sizeof(char), alignment);
+  }
+
+  /// @endcond
+
+  /// @brief Serialize an array into a FlatBuffer `vector`.
+  /// @tparam T The data type of the array elements.
+  /// @tparam OffsetT the type of offset to return
+  /// @tparam VectorT the type of vector to cast to.
+  /// @param[in] v A pointer to the array of type `T` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @return Returns a typed `TOffset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, template <typename...> class OffsetT = Offset,
+            template <typename...> class VectorT = Vector>
+  OffsetT<VectorT<T>> CreateVector(const T* v, size_t len) {
+    // The type of the length field in the vector.
+    typedef typename VectorT<T>::size_type LenT;
+    typedef typename OffsetT<VectorT<T>>::offset_type offset_type;
+    // If this assert hits, you're specifying a template argument that is
+    // causing the wrong overload to be selected, remove it.
+    AssertScalarT<T>();
+    StartVector<T, OffsetT, LenT>(len);
+    if (len > 0) {
+      // clang-format off
+      #if FLATBUFFERS_LITTLEENDIAN
+        PushBytes(reinterpret_cast<const uint8_t *>(v), len * sizeof(T));
+      #else
+        if (sizeof(T) == 1) {
+          PushBytes(reinterpret_cast<const uint8_t *>(v), len);
+        } else {
+          for (auto i = len; i > 0; ) {
+            PushElement(v[--i]);
+          }
+        }
+      #endif
+      // clang-format on
+    }
+    return OffsetT<VectorT<T>>(EndVector<LenT, offset_type>(len));
+  }
+
+  /// @brief Serialize an array like object into a FlatBuffer `vector`.
+  /// @tparam T The data type of the array elements.
+  /// @tparam C The type of the array.
+  /// @param[in] array A reference to an array like object of type `T` to
+  /// serialize into the buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, class C>
+  Offset<Vector<T>> CreateVector(const C& array) {
+    return CreateVector(array.data(), array.size());
+  }
+
+  /// @brief Serialize an initializer list into a FlatBuffer `vector`.
+  /// @tparam T The data type of the initializer list elements.
+  /// @param[in] v The value of the initializer list.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T>
+  Offset<Vector<T>> CreateVector(std::initializer_list<T> v) {
+    return CreateVector(v.begin(), v.size());
+  }
+
+  template <typename T>
+  Offset<Vector<Offset<T>>> CreateVector(const Offset<T>* v, size_t len) {
+    StartVector<Offset<T>>(len);
+    for (auto i = len; i > 0;) {
+      PushElement(v[--i]);
+    }
+    return Offset<Vector<Offset<T>>>(EndVector(len));
+  }
+
+  /// @brief Serialize a `std::vector` into a FlatBuffer `vector`.
+  /// @tparam T The data type of the `std::vector` elements.
+  /// @param v A const reference to the `std::vector` to serialize into the
+  /// buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, typename Alloc = std::allocator<T>>
+  Offset<Vector<T>> CreateVector(const std::vector<T, Alloc>& v) {
+    return CreateVector(data(v), v.size());
+  }
+
+  template <template <typename...> class VectorT = Vector64,
+            int&... ExplicitArgumentBarrier, typename T>
+  Offset64<VectorT<T>> CreateVector64(const std::vector<T>& v) {
+    return CreateVector<T, Offset64, VectorT>(data(v), v.size());
+  }
+
+  // vector<bool> may be implemented using a bit-set, so we can't access it as
+  // an array. Instead, read elements manually.
+  // Background: https://isocpp.org/blog/2012/11/on-vectorbool
+  Offset<Vector<uint8_t>> CreateVector(const std::vector<bool>& v) {
+    StartVector<uint8_t>(v.size());
+    for (auto i = v.size(); i > 0;) {
+      PushElement(static_cast<uint8_t>(v[--i]));
+    }
+    return Offset<Vector<uint8_t>>(EndVector(v.size()));
+  }
+
+  Offset64<Vector64<uint8_t>> CreateVector64(const std::vector<bool>& v) {
+    StartVector<uint8_t, Offset64, Vector64<uint8_t>::size_type>(v.size());
+    for (auto i = v.size(); i > 0;) {
+      PushElement(static_cast<uint8_t>(v[--i]));
+    }
+    return Offset64<Vector64<uint8_t>>(
+        EndVector<Vector64<uint8_t>::size_type,
+                  Offset64<Vector64<uint8_t>>::offset_type>(v.size()));
+  }
+
+  /// @brief Serialize values returned by a function into a FlatBuffer `vector`.
+  /// This is a convenience function that takes care of iteration for you.
+  /// @tparam T The data type of the `std::vector` elements.
+  /// @param f A function that takes the current iteration 0..vector_size-1 and
+  /// returns any type that you can construct a FlatBuffers vector out of.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T>
+  Offset<Vector<T>> CreateVector(size_t vector_size,
+                                 const std::function<T(size_t i)>& f) {
+    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
+    std::vector<T> elems(vector_size);
+    for (size_t i = 0; i < vector_size; i++) elems[i] = f(i);
+    return CreateVector(elems);
+  }
+
+  /// @brief Serialize values returned by a function into a FlatBuffer `vector`.
+  /// This is a convenience function that takes care of iteration for you. This
+  /// uses a vector stored on the heap to store the intermediate results of the
+  /// iteration.
+  /// @tparam T The data type of the `std::vector` elements.
+  /// @param f A function that takes the current iteration 0..vector_size-1,
+  /// and the state parameter returning any type that you can construct a
+  /// FlatBuffers vector out of.
+  /// @param state State passed to f.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, typename F, typename S>
+  Offset<Vector<T>> CreateVector(size_t vector_size, F f, S* state) {
+    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
+    std::vector<T> elems(vector_size);
+    for (size_t i = 0; i < vector_size; i++) elems[i] = f(i, state);
+    return CreateVector(elems);
+  }
+
+  /// @brief Serialize a `std::vector<StringType>` into a FlatBuffer `vector`.
+  /// whereas StringType is any type that is accepted by the CreateString()
+  /// overloads.
+  /// This is a convenience function for a common case.
+  /// @param v A const reference to the `std::vector` to serialize into the
+  /// buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename StringType = std::string,
+            typename Alloc = std::allocator<StringType>>
+  Offset<Vector<Offset<String>>> CreateVectorOfStrings(
+      const std::vector<StringType, Alloc>& v) {
+    return CreateVectorOfStrings(v.cbegin(), v.cend());
+  }
+
+  /// @brief Serialize a collection of Strings into a FlatBuffer `vector`.
+  /// This is a convenience function for a common case.
+  /// @param begin The beginning iterator of the collection
+  /// @param end The ending iterator of the collection
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <class It>
+  Offset<Vector<Offset<String>>> CreateVectorOfStrings(It begin, It end) {
+    auto distance = std::distance(begin, end);
+    FLATBUFFERS_ASSERT(distance >= 0);
+    auto size = static_cast<size_t>(distance);
+    auto scratch_buffer_usage = size * sizeof(Offset<String>);
+    // If there is not enough space to store the offsets, there definitely won't
+    // be enough space to store all the strings. So ensuring space for the
+    // scratch region is OK, for if it fails, it would have failed later.
+    buf_.ensure_space(scratch_buffer_usage);
+    for (auto it = begin; it != end; ++it) {
+      buf_.scratch_push_small(CreateString(*it));
+    }
+    StartVector<Offset<String>>(size);
+    for (size_t i = 1; i <= size; i++) {
+      // Note we re-evaluate the buf location each iteration to account for any
+      // underlying buffer resizing that may occur.
+      PushElement(*reinterpret_cast<Offset<String>*>(
+          buf_.scratch_end() - i * sizeof(Offset<String>)));
+    }
+    buf_.scratch_pop(scratch_buffer_usage);
+    return Offset<Vector<Offset<String>>>(EndVector(size));
+  }
+
+  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @param[in] v A pointer to the array of type `T` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, template <typename...> class OffsetT = Offset,
+            template <typename...> class VectorT = Vector>
+  OffsetT<VectorT<const T*>> CreateVectorOfStructs(const T* v, size_t len) {
+    // The type of the length field in the vector.
+    typedef typename VectorT<T>::size_type LenT;
+    typedef typename OffsetT<VectorT<const T*>>::offset_type offset_type;
+
+    StartVector<OffsetT, LenT>(len, sizeof(T), AlignOf<T>());
+    if (len > 0) {
+      PushBytes(reinterpret_cast<const uint8_t*>(v), sizeof(T) * len);
+    }
+    return OffsetT<VectorT<const T*>>(EndVector<LenT, offset_type>(len));
+  }
+
+  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @param[in] filler A function that takes the current iteration
+  /// 0..vector_size-1 and a pointer to the struct that must be filled.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  /// This is mostly useful when flatbuffers are generated with mutation
+  /// accessors.
+  template <typename T>
+  Offset<Vector<const T*>> CreateVectorOfStructs(
+      size_t vector_size, const std::function<void(size_t i, T*)>& filler) {
+    T* structs = StartVectorOfStructs<T>(vector_size);
+    for (size_t i = 0; i < vector_size; i++) {
+      filler(i, structs);
+      structs++;
+    }
+    return EndVectorOfStructs<T>(vector_size);
+  }
+
+  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @param[in] f A function that takes the current iteration 0..vector_size-1,
+  /// a pointer to the struct that must be filled and the state argument.
+  /// @param[in] state Arbitrary state to pass to f.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  /// This is mostly useful when flatbuffers are generated with mutation
+  /// accessors.
+  template <typename T, typename F, typename S>
+  Offset<Vector<const T*>> CreateVectorOfStructs(size_t vector_size, F f,
+                                                 S* state) {
+    T* structs = StartVectorOfStructs<T>(vector_size);
+    for (size_t i = 0; i < vector_size; i++) {
+      f(i, structs, state);
+      structs++;
+    }
+    return EndVectorOfStructs<T>(vector_size);
+  }
+
+  /// @brief Serialize a `std::vector` of structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, template <typename...> class OffsetT = Offset,
+            template <typename...> class VectorT = Vector,
+            typename Alloc = std::allocator<T>>
+  OffsetT<VectorT<const T*>> CreateVectorOfStructs(
+      const std::vector<T, Alloc>& v) {
+    return CreateVectorOfStructs<T, OffsetT, VectorT>(data(v), v.size());
+  }
+
+  template <template <typename...> class VectorT = Vector64, int&...,
+            typename T>
+  Offset64<VectorT<const T*>> CreateVectorOfStructs64(const std::vector<T>& v) {
+    return CreateVectorOfStructs<T, Offset64, VectorT>(data(v), v.size());
+  }
+
+  /// @brief Serialize an array of native structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @tparam S The data type of the native struct array elements.
+  /// @param[in] v A pointer to the array of type `S` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @param[in] pack_func Pointer to a function to convert the native struct
+  /// to the FlatBuffer struct.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, typename S>
+  Offset<Vector<const T*>> CreateVectorOfNativeStructs(
+      const S* v, size_t len, T (*const pack_func)(const S&)) {
+    FLATBUFFERS_ASSERT(pack_func);
+    auto structs = StartVectorOfStructs<T>(len);
+    for (size_t i = 0; i < len; i++) {
+      structs[i] = pack_func(v[i]);
+    }
+    return EndVectorOfStructs<T>(len);
+  }
+
+  /// @brief Serialize an array of native structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @tparam S The data type of the native struct array elements.
+  /// @param[in] v A pointer to the array of type `S` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, typename S>
+  Offset<Vector<const T*>> CreateVectorOfNativeStructs(const S* v, size_t len) {
+    extern T Pack(const S&);
+    return CreateVectorOfNativeStructs(v, len, Pack);
+  }
+
+  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
+  /// `vector`.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @tparam S The data type of the `std::vector` native struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @param[in] pack_func Pointer to a function to convert the native struct
+  /// to the FlatBuffer struct.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, typename S, typename Alloc = std::allocator<T>>
+  Offset<Vector<const T*>> CreateVectorOfNativeStructs(
+      const std::vector<S, Alloc>& v, T (*const pack_func)(const S&)) {
+    return CreateVectorOfNativeStructs<T, S>(data(v), v.size(), pack_func);
+  }
+
+  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
+  /// `vector`.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @tparam S The data type of the `std::vector` native struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, typename S, typename Alloc = std::allocator<S>>
+  Offset<Vector<const T*>> CreateVectorOfNativeStructs(
+      const std::vector<S, Alloc>& v) {
+    return CreateVectorOfNativeStructs<T, S>(data(v), v.size());
+  }
+
+  /// @cond FLATBUFFERS_INTERNAL
+  template <typename T>
+  struct StructKeyComparator {
+    bool operator()(const T& a, const T& b) const {
+      return a.KeyCompareLessThan(&b);
+    }
+  };
+  /// @endcond
+
+  /// @brief Serialize a `std::vector` of structs into a FlatBuffer `vector`
+  /// in sorted order.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, typename Alloc = std::allocator<T>>
+  Offset<Vector<const T*>> CreateVectorOfSortedStructs(
+      std::vector<T, Alloc>* v) {
+    return CreateVectorOfSortedStructs(data(*v), v->size());
+  }
+
+  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
+  /// `vector` in sorted order.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @tparam S The data type of the `std::vector` native struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, typename S, typename Alloc = std::allocator<T>>
+  Offset<Vector<const T*>> CreateVectorOfSortedNativeStructs(
+      std::vector<S, Alloc>* v) {
+    return CreateVectorOfSortedNativeStructs<T, S>(data(*v), v->size());
+  }
+
+  /// @brief Serialize an array of structs into a FlatBuffer `vector` in sorted
+  /// order.
+  /// @tparam T The data type of the struct array elements.
+  /// @param[in] v A pointer to the array of type `T` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T>
+  Offset<Vector<const T*>> CreateVectorOfSortedStructs(T* v, size_t len) {
+    std::stable_sort(v, v + len, StructKeyComparator<T>());
+    return CreateVectorOfStructs(v, len);
+  }
+
+  /// @brief Serialize an array of native structs into a FlatBuffer `vector` in
+  /// sorted order.
+  /// @tparam T The data type of the struct array elements.
+  /// @tparam S The data type of the native struct array elements.
+  /// @param[in] v A pointer to the array of type `S` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, typename S>
+  Offset<Vector<const T*>> CreateVectorOfSortedNativeStructs(S* v, size_t len) {
+    extern T Pack(const S&);
+    auto structs = StartVectorOfStructs<T>(len);
+    for (size_t i = 0; i < len; i++) {
+      structs[i] = Pack(v[i]);
+    }
+    std::stable_sort(structs, structs + len, StructKeyComparator<T>());
+    return EndVectorOfStructs<T>(len);
+  }
+
+  /// @cond FLATBUFFERS_INTERNAL
+  template <typename T>
+  struct TableKeyComparator {
+    explicit TableKeyComparator(vector_downward<SizeT>& buf) : buf_(buf) {}
+    TableKeyComparator(const TableKeyComparator& other) : buf_(other.buf_) {}
+    bool operator()(const Offset<T>& a, const Offset<T>& b) const {
+      auto table_a = reinterpret_cast<T*>(buf_.data_at(a.o));
+      auto table_b = reinterpret_cast<T*>(buf_.data_at(b.o));
+      return table_a->KeyCompareLessThan(table_b);
+    }
+    vector_downward<SizeT>& buf_;
+
+   private:
+    FLATBUFFERS_DELETE_FUNC(
+        TableKeyComparator& operator=(const TableKeyComparator& other));
+  };
+  /// @endcond
+
+  /// @brief Serialize an array of `table` offsets as a `vector` in the buffer
+  /// in sorted order.
+  /// @tparam T The data type that the offset refers to.
+  /// @param[in] v An array of type `Offset<T>` that contains the `table`
+  /// offsets to store in the buffer in sorted order.
+  /// @param[in] len The number of elements to store in the `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T>
+  Offset<Vector<Offset<T>>> CreateVectorOfSortedTables(Offset<T>* v,
+                                                       size_t len) {
+    std::stable_sort(v, v + len, TableKeyComparator<T>(buf_));
+    return CreateVector(v, len);
+  }
+
+  /// @brief Serialize an array of `table` offsets as a `vector` in the buffer
+  /// in sorted order.
+  /// @tparam T The data type that the offset refers to.
+  /// @param[in] v An array of type `Offset<T>` that contains the `table`
+  /// offsets to store in the buffer in sorted order.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template <typename T, typename Alloc = std::allocator<T>>
+  Offset<Vector<Offset<T>>> CreateVectorOfSortedTables(
+      std::vector<Offset<T>, Alloc>* v) {
+    return CreateVectorOfSortedTables(data(*v), v->size());
+  }
+
+  /// @brief Specialized version of `CreateVector` for non-copying use cases.
+  /// Write the data any time later to the returned buffer pointer `buf`.
+  /// @param[in] len The number of elements to store in the `vector`.
+  /// @param[in] elemsize The size of each element in the `vector`.
+  /// @param[out] buf A pointer to a `uint8_t` pointer that can be
+  /// written to at a later time to serialize the data into a `vector`
+  /// in the buffer.
+  uoffset_t CreateUninitializedVector(size_t len, size_t elemsize,
+                                      size_t alignment, uint8_t** buf) {
+    NotNested();
+    StartVector(len, elemsize, alignment);
+    buf_.make_space(len * elemsize);
+    const uoffset_t vec_start = GetSizeRelative32BitRegion();
+    auto vec_end = EndVector(len);
+    *buf = buf_.data_at(vec_start);
+    return vec_end;
+  }
+
+  FLATBUFFERS_ATTRIBUTE([[deprecated("call the version above instead")]])
+  uoffset_t CreateUninitializedVector(size_t len, size_t elemsize,
+                                      uint8_t** buf) {
+    return CreateUninitializedVector(len, elemsize, elemsize, buf);
+  }
+
+  /// @brief Specialized version of `CreateVector` for non-copying use cases.
+  /// Write the data any time later to the returned buffer pointer `buf`.
+  /// @tparam T The data type of the data that will be stored in the buffer
+  /// as a `vector`.
+  /// @param[in] len The number of elements to store in the `vector`.
+  /// @param[out] buf A pointer to a pointer of type `T` that can be
+  /// written to at a later time to serialize the data into a `vector`
+  /// in the buffer.
+  template <typename T>
+  Offset<Vector<T>> CreateUninitializedVector(size_t len, T** buf) {
+    AssertScalarT<T>();
+    return CreateUninitializedVector(len, sizeof(T), AlignOf<T>(),
+                                     reinterpret_cast<uint8_t**>(buf));
+  }
+
+  template <typename T>
+  Offset<Vector<const T*>> CreateUninitializedVectorOfStructs(size_t len,
+                                                              T** buf) {
+    return CreateUninitializedVector(len, sizeof(T), AlignOf<T>(),
+                                     reinterpret_cast<uint8_t**>(buf));
+  }
+
+  // @brief Create a vector of scalar type T given as input a vector of scalar
+  // type U, useful with e.g. pre "enum class" enums, or any existing scalar
+  // data of the wrong type.
+  template <typename T, typename U>
+  Offset<Vector<T>> CreateVectorScalarCast(const U* v, size_t len) {
+    AssertScalarT<T>();
+    AssertScalarT<U>();
+    StartVector<T>(len);
+    for (auto i = len; i > 0;) {
+      PushElement(static_cast<T>(v[--i]));
+    }
+    return Offset<Vector<T>>(EndVector(len));
+  }
+
+  /// @brief Write a struct by itself, typically to be part of a union.
+  template <typename T>
+  Offset<const T*> CreateStruct(const T& structobj) {
+    NotNested();
+    Align(AlignOf<T>());
+    buf_.push_small(structobj);
+    return Offset<const T*>(
+        CalculateOffset<typename Offset<const T*>::offset_type>());
+  }
+
+  /// @brief Finish serializing a buffer by writing the root offset.
+  /// @param[in] file_identifier If a `file_identifier` is given, the buffer
+  /// will be prefixed with a standard FlatBuffers file header.
+  template <typename T>
+  void Finish(Offset<T> root, const char* file_identifier = nullptr) {
+    Finish(root.o, file_identifier, false);
+  }
+
+  /// @brief Finish a buffer with a 32 bit size field pre-fixed (size of the
+  /// buffer following the size field). These buffers are NOT compatible
+  /// with standard buffers created by Finish, i.e. you can't call GetRoot
+  /// on them, you have to use GetSizePrefixedRoot instead.
+  /// All >32 bit quantities in this buffer will be aligned when the whole
+  /// size pre-fixed buffer is aligned.
+  /// These kinds of buffers are useful for creating a stream of FlatBuffers.
+  template <typename T>
+  void FinishSizePrefixed(Offset<T> root,
+                          const char* file_identifier = nullptr) {
+    Finish(root.o, file_identifier, true);
+  }
+
+  void SwapBufAllocator(FlatBufferBuilderImpl& other) {
+    buf_.swap_allocator(other.buf_);
+  }
+
+  /// @brief The length of a FlatBuffer file header.
+  static const size_t kFileIdentifierLength =
+      ::flatbuffers::kFileIdentifierLength;
+
+ protected:
+  // You shouldn't really be copying instances of this class.
+  FlatBufferBuilderImpl(const FlatBufferBuilderImpl&);
+  FlatBufferBuilderImpl& operator=(const FlatBufferBuilderImpl&);
+
+  void Finish(uoffset_t root, const char* file_identifier, bool size_prefix) {
+    // A buffer can only be finished once. To reuse a builder use `clear()`.
+    FLATBUFFERS_ASSERT(!finished);
+
+    NotNested();
+    buf_.clear_scratch();
+
+    const size_t prefix_size = size_prefix ? sizeof(SizeT) : 0;
+    // Make sure we track the alignment of the size prefix.
+    TrackMinAlign(prefix_size);
+
+    const size_t root_offset_size = sizeof(uoffset_t);
+    const size_t file_id_size = file_identifier ? kFileIdentifierLength : 0;
+
+    // This will cause the whole buffer to be aligned.
+    PreAlign(prefix_size + root_offset_size + file_id_size, minalign_);
+
+    if (file_identifier) {
+      FLATBUFFERS_ASSERT(strlen(file_identifier) == kFileIdentifierLength);
+      PushBytes(reinterpret_cast<const uint8_t*>(file_identifier),
+                kFileIdentifierLength);
+    }
+    PushElement(ReferTo(root));  // Location of root.
+    if (size_prefix) {
+      PushElement(GetSize());
+    }
+    finished = true;
+  }
+
+  struct FieldLoc {
+    uoffset_t off;
+    voffset_t id;
+  };
+
+  vector_downward<SizeT> buf_;
+
+  // Accumulating offsets of table members while it is being built.
+  // We store these in the scratch pad of buf_, after the vtable offsets.
+  uoffset_t num_field_loc;
+  // Track how much of the vtable is in use, so we can output the most compact
+  // possible vtable.
+  voffset_t max_voffset_;
+
+  // This is the length of the 64-bit region of the buffer. The buffer supports
+  // 64-bit offsets by forcing serialization of those elements in the "tail"
+  // region of the buffer (i.e. "64-bit region"). To properly keep track of
+  // offsets that are referenced from the tail of the buffer to not overflow
+  // their size (e.g. Offset is a uint32_t type), the boundary of the 32-/64-bit
+  // regions must be tracked.
+  //
+  // [    Complete FlatBuffer     ]
+  // [32-bit region][64-bit region]
+  //               ^              ^
+  //               |              Tail of the buffer.
+  //               |
+  //               Tail of the 32-bit region of the buffer.
+  //
+  // This keeps track of the size of the 64-bit region so that the tail of the
+  // 32-bit region can be calculated as `GetSize() - length_of_64_bit_region_`.
+  //
+  // This will remain 0 if no 64-bit offset types are added to the buffer.
+  size_t length_of_64_bit_region_;
+
+  // Ensure objects are not nested.
+  bool nested;
+
+  // Ensure the buffer is finished before it is being accessed.
+  bool finished;
+
+  size_t minalign_;
+
+  bool force_defaults_;  // Serialize values equal to their defaults anyway.
+
+  bool dedup_vtables_;
+
+  struct StringOffsetCompare {
+    explicit StringOffsetCompare(const vector_downward<SizeT>& buf)
+        : buf_(&buf) {}
+    bool operator()(const Offset<String>& a, const Offset<String>& b) const {
+      auto stra = reinterpret_cast<const String*>(buf_->data_at(a.o));
+      auto strb = reinterpret_cast<const String*>(buf_->data_at(b.o));
+      return StringLessThan(stra->data(), stra->size(), strb->data(),
+                            strb->size());
+    }
+    const vector_downward<SizeT>* buf_;
+  };
+
+  // For use with CreateSharedString. Instantiated on first use only.
+  typedef std::set<Offset<String>, StringOffsetCompare> StringOffsetMap;
+  StringOffsetMap* string_pool;
+
+ private:
+  void CanAddOffset64() {
+    // If you hit this assertion, you are attempting to add a 64-bit offset to
+    // a 32-bit only builder. This is because the builder has overloads that
+    // differ only on the offset size returned: e.g.:
+    //
+    //   FlatBufferBuilder builder;
+    //   Offset64<String> string_offset = builder.CreateString<Offset64>();
+    //
+    // Either use a 64-bit aware builder, or don't try to create an Offset64
+    // return type.
+    //
+    // TODO(derekbailey): we can probably do more enable_if to avoid this
+    // looking like its possible to the user.
+    static_assert(Is64Aware, "cannot add 64-bit offset to a 32-bit builder");
+
+    // If you hit this assertion, you are attempting to add an 64-bit offset
+    // item after already serializing a 32-bit item. All 64-bit offsets have to
+    // added to the tail of the buffer before any 32-bit items can be added.
+    // Otherwise some items might not be addressable due to the maximum range of
+    // the 32-bit offset.
+    FLATBUFFERS_ASSERT(GetSize() == length_of_64_bit_region_);
+  }
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const char pointer to the data to be stored as a string.
+  /// @param[in] len The number of bytes that should be stored from `str`.
+  /// @return Returns the offset in the buffer where the string starts.
+  void CreateStringImpl(const char* str, size_t len) {
+    NotNested();
+    PreAlign<uoffset_t>(len + 1);  // Always 0-terminated.
+    buf_.fill(1);
+    PushBytes(reinterpret_cast<const uint8_t*>(str), len);
+    PushElement(static_cast<uoffset_t>(len));
+  }
+
+  // Allocates space for a vector of structures.
+  // Must be completed with EndVectorOfStructs().
+  template <typename T, template <typename> class OffsetT = Offset>
+  T* StartVectorOfStructs(size_t vector_size) {
+    StartVector<OffsetT>(vector_size, sizeof(T), AlignOf<T>());
+    return reinterpret_cast<T*>(buf_.make_space(vector_size * sizeof(T)));
+  }
+
+  // End the vector of structures in the flatbuffers.
+  // Vector should have previously be started with StartVectorOfStructs().
+  template <typename T, template <typename> class OffsetT = Offset>
+  OffsetT<Vector<const T*>> EndVectorOfStructs(size_t vector_size) {
+    return OffsetT<Vector<const T*>>(
+        EndVector<typename Vector<const T*>::size_type,
+                  typename OffsetT<Vector<const T*>>::offset_type>(
+            vector_size));
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_same<T, uoffset_t>::value, T>::type
+  CalculateOffset() {
+    // Default to the end of the 32-bit region. This may or may not be the end
+    // of the buffer, depending on if any 64-bit offsets have been added.
+    return GetSizeRelative32BitRegion();
+  }
+
+  // Specializations to handle the 64-bit CalculateOffset, which is relative to
+  // end of the buffer.
+  template <typename T>
+  typename std::enable_if<std::is_same<T, uoffset64_t>::value, T>::type
+  CalculateOffset() {
+    // This should never be compiled in when not using a 64-bit builder.
+    static_assert(Is64Aware, "invalid 64-bit offset in 32-bit builder");
+
+    // Store how big the 64-bit region of the buffer is, so we can determine
+    // where the 32/64 bit boundary is.
+    length_of_64_bit_region_ = GetSize();
+
+    return length_of_64_bit_region_;
+  }
+};
+/// @}
+
+// Hack to `FlatBufferBuilder` mean `FlatBufferBuilder<false>` or
+// `FlatBufferBuilder<>`, where the template < > syntax is required.
+using FlatBufferBuilder = FlatBufferBuilderImpl<false>;
+using FlatBufferBuilder64 = FlatBufferBuilderImpl<true>;
+
+// These are external due to GCC not allowing them in the class.
+// See: https://stackoverflow.com/q/8061456/868247
+template <>
+template <>
+inline Offset64<String> FlatBufferBuilder64::CreateString(const char* str,
+                                                          size_t len) {
+  CanAddOffset64();
+  CreateStringImpl(str, len);
+  return Offset64<String>(
+      CalculateOffset<typename Offset64<String>::offset_type>());
+}
+
+// Used to distinguish from real Offsets.
+template <typename T = void>
+struct EmptyOffset {};
+
+// TODO(derekbailey): it would be nice to combine these two methods.
+template <>
+template <>
+inline void FlatBufferBuilder64::StartVector<Offset64, uint32_t>(
+    size_t len, size_t elemsize, size_t alignment) {
+  CanAddOffset64();
+  StartVector<EmptyOffset, uint32_t>(len, elemsize, alignment);
+}
+
+template <>
+template <>
+inline void FlatBufferBuilder64::StartVector<Offset64, uint64_t>(
+    size_t len, size_t elemsize, size_t alignment) {
+  CanAddOffset64();
+  StartVector<EmptyOffset, uint64_t>(len, elemsize, alignment);
+}
+
+/// Helpers to get a typed pointer to objects that are currently being built.
+/// @warning Creating new objects will lead to reallocations and invalidates
+/// the pointer!
+template <typename T>
+T* GetMutableTemporaryPointer(FlatBufferBuilder& fbb, Offset<T> offset) {
+  return reinterpret_cast<T*>(fbb.GetCurrentBufferPointer() + fbb.GetSize() -
+                              offset.o);
+}
+
+template <typename T>
+const T* GetTemporaryPointer(const FlatBufferBuilder& fbb, Offset<T> offset) {
+  return reinterpret_cast<const T*>(fbb.GetCurrentBufferPointer() +
+                                    fbb.GetSize() - offset.o);
+}
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_FLATBUFFER_BUILDER_H_
diff --git a/external/flatbuffers/include/flatbuffers/flatbuffers.h b/external/flatbuffers/include/flatbuffers/flatbuffers.h
new file mode 100644
index 00000000..0d9b5cce
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/flatbuffers.h
@@ -0,0 +1,284 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_H_
+#define FLATBUFFERS_H_
+
+#include <algorithm>
+
+// TODO: These includes are for mitigating the pains of users editing their
+// source because they relied on flatbuffers.h to include everything for them.
+#include "flatbuffers/array.h"
+#include "flatbuffers/base.h"
+#include "flatbuffers/buffer.h"
+#include "flatbuffers/buffer_ref.h"
+#include "flatbuffers/detached_buffer.h"
+#include "flatbuffers/flatbuffer_builder.h"
+#include "flatbuffers/stl_emulation.h"
+#include "flatbuffers/string.h"
+#include "flatbuffers/struct.h"
+#include "flatbuffers/table.h"
+#include "flatbuffers/vector.h"
+#include "flatbuffers/vector_downward.h"
+#include "flatbuffers/verifier.h"
+
+namespace flatbuffers {
+
+/// @brief This can compute the start of a FlatBuffer from a root pointer, i.e.
+/// it is the opposite transformation of GetRoot().
+/// This may be useful if you want to pass on a root and have the recipient
+/// delete the buffer afterwards.
+inline const uint8_t* GetBufferStartFromRootPointer(const void* root) {
+  auto table = reinterpret_cast<const Table*>(root);
+  auto vtable = table->GetVTable();
+  // Either the vtable is before the root or after the root.
+  auto start = (std::min)(vtable, reinterpret_cast<const uint8_t*>(root));
+  // Align to at least sizeof(uoffset_t).
+  start = reinterpret_cast<const uint8_t*>(reinterpret_cast<uintptr_t>(start) &
+                                           ~(sizeof(uoffset_t) - 1));
+  // Additionally, there may be a file_identifier in the buffer, and the root
+  // offset. The buffer may have been aligned to any size between
+  // sizeof(uoffset_t) and FLATBUFFERS_MAX_ALIGNMENT (see "force_align").
+  // Sadly, the exact alignment is only known when constructing the buffer,
+  // since it depends on the presence of values with said alignment properties.
+  // So instead, we simply look at the next uoffset_t values (root,
+  // file_identifier, and alignment padding) to see which points to the root.
+  // None of the other values can "impersonate" the root since they will either
+  // be 0 or four ASCII characters.
+  static_assert(flatbuffers::kFileIdentifierLength == sizeof(uoffset_t),
+                "file_identifier is assumed to be the same size as uoffset_t");
+  for (auto possible_roots = FLATBUFFERS_MAX_ALIGNMENT / sizeof(uoffset_t) + 1;
+       possible_roots; possible_roots--) {
+    start -= sizeof(uoffset_t);
+    if (ReadScalar<uoffset_t>(start) + start ==
+        reinterpret_cast<const uint8_t*>(root))
+      return start;
+  }
+  // We didn't find the root, either the "root" passed isn't really a root,
+  // or the buffer is corrupt.
+  // Assert, because calling this function with bad data may cause reads
+  // outside of buffer boundaries.
+  FLATBUFFERS_ASSERT(false);
+  return nullptr;
+}
+
+/// @brief This return the prefixed size of a FlatBuffer.
+template <typename SizeT = uoffset_t>
+inline SizeT GetPrefixedSize(const uint8_t* buf) {
+  return ReadScalar<SizeT>(buf);
+}
+
+// Gets the total length of the buffer given a sized prefixed FlatBuffer.
+//
+// This includes the size of the prefix as well as the buffer:
+//
+//  [size prefix][flatbuffer]
+//  |---------length--------|
+template <typename SizeT = uoffset_t>
+inline SizeT GetSizePrefixedBufferLength(const uint8_t* const buf) {
+  return ReadScalar<SizeT>(buf) + sizeof(SizeT);
+}
+
+// Base class for native objects (FlatBuffer data de-serialized into native
+// C++ data structures).
+// Contains no functionality, purely documentative.
+struct NativeTable {};
+
+/// @brief Function types to be used with resolving hashes into objects and
+/// back again. The resolver gets a pointer to a field inside an object API
+/// object that is of the type specified in the schema using the attribute
+/// `cpp_type` (it is thus important whatever you write to this address
+/// matches that type). The value of this field is initially null, so you
+/// may choose to implement a delayed binding lookup using this function
+/// if you wish. The resolver does the opposite lookup, for when the object
+/// is being serialized again.
+typedef uint64_t hash_value_t;
+typedef std::function<void(void** pointer_adr, hash_value_t hash)>
+    resolver_function_t;
+typedef std::function<hash_value_t(void* pointer)> rehasher_function_t;
+
+// Helper function to test if a field is present, using any of the field
+// enums in the generated code.
+// `table` must be a generated table type. Since this is a template parameter,
+// this is not typechecked to be a subclass of Table, so beware!
+// Note: this function will return false for fields equal to the default
+// value, since they're not stored in the buffer (unless force_defaults was
+// used).
+template <typename T>
+bool IsFieldPresent(const T* table, typename T::FlatBuffersVTableOffset field) {
+  // Cast, since Table is a private baseclass of any table types.
+  return reinterpret_cast<const Table*>(table)->CheckField(
+      static_cast<voffset_t>(field));
+}
+
+// Utility function for reverse lookups on the EnumNames*() functions
+// (in the generated C++ code)
+// names must be NULL terminated.
+inline int LookupEnum(const char** names, const char* name) {
+  for (const char** p = names; *p; p++)
+    if (!strcmp(*p, name)) return static_cast<int>(p - names);
+  return -1;
+}
+
+// These macros allow us to layout a struct with a guarantee that they'll end
+// up looking the same on different compilers and platforms.
+// It does this by disallowing the compiler to do any padding, and then
+// does padding itself by inserting extra padding fields that make every
+// element aligned to its own size.
+// Additionally, it manually sets the alignment of the struct as a whole,
+// which is typically its largest element, or a custom size set in the schema
+// by the force_align attribute.
+// These are used in the generated code only.
+
+// clang-format off
+#if defined(_MSC_VER)
+  #define FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(alignment) \
+    __pragma(pack(1)) \
+    struct __declspec(align(alignment))
+  #define FLATBUFFERS_STRUCT_END(name, size) \
+    __pragma(pack()) \
+    static_assert(sizeof(name) == size, "compiler breaks packing rules")
+#elif defined(__GNUC__) || defined(__clang__) || defined(__ICCARM__)
+  #define FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(alignment) \
+    _Pragma("pack(1)") \
+    struct __attribute__((aligned(alignment)))
+  #define FLATBUFFERS_STRUCT_END(name, size) \
+    _Pragma("pack()") \
+    static_assert(sizeof(name) == size, "compiler breaks packing rules")
+#else
+  #error Unknown compiler, please define structure alignment macros
+#endif
+// clang-format on
+
+// Minimal reflection via code generation.
+// Besides full-fat reflection (see reflection.h) and parsing/printing by
+// loading schemas (see idl.h), we can also have code generation for minimal
+// reflection data which allows pretty-printing and other uses without needing
+// a schema or a parser.
+// Generate code with --reflect-types (types only) or --reflect-names (names
+// also) to enable.
+// See minireflect.h for utilities using this functionality.
+
+// These types are organized slightly differently as the ones in idl.h.
+enum SequenceType { ST_TABLE, ST_STRUCT, ST_UNION, ST_ENUM };
+
+// Scalars have the same order as in idl.h
+// clang-format off
+#define FLATBUFFERS_GEN_ELEMENTARY_TYPES(ET) \
+  ET(ET_UTYPE) \
+  ET(ET_BOOL) \
+  ET(ET_CHAR) \
+  ET(ET_UCHAR) \
+  ET(ET_SHORT) \
+  ET(ET_USHORT) \
+  ET(ET_INT) \
+  ET(ET_UINT) \
+  ET(ET_LONG) \
+  ET(ET_ULONG) \
+  ET(ET_FLOAT) \
+  ET(ET_DOUBLE) \
+  ET(ET_STRING) \
+  ET(ET_SEQUENCE)  // See SequenceType.
+
+enum ElementaryType {
+  #define FLATBUFFERS_ET(E) E,
+    FLATBUFFERS_GEN_ELEMENTARY_TYPES(FLATBUFFERS_ET)
+  #undef FLATBUFFERS_ET
+};
+
+inline const char * const *ElementaryTypeNames() {
+  static const char * const names[] = {
+    #define FLATBUFFERS_ET(E) #E,
+      FLATBUFFERS_GEN_ELEMENTARY_TYPES(FLATBUFFERS_ET)
+    #undef FLATBUFFERS_ET
+  };
+  return names;
+}
+// clang-format on
+
+// Basic type info cost just 16bits per field!
+// We're explicitly defining the signedness since the signedness of integer
+// bitfields is otherwise implementation-defined and causes warnings on older
+// GCC compilers.
+struct TypeCode {
+  // ElementaryType
+  unsigned short base_type : 4;
+  // Either vector (in table) or array (in struct)
+  unsigned short is_repeating : 1;
+  // Index into type_refs below, or -1 for none.
+  signed short sequence_ref : 11;
+};
+
+static_assert(sizeof(TypeCode) == 2, "TypeCode");
+
+struct TypeTable;
+
+// Signature of the static method present in each type.
+typedef const TypeTable* (*TypeFunction)();
+
+struct TypeTable {
+  SequenceType st;
+  size_t num_elems;  // of type_codes, values, names (but not type_refs).
+  const TypeCode* type_codes;     // num_elems count
+  const TypeFunction* type_refs;  // less than num_elems entries (see TypeCode).
+  const int16_t* array_sizes;     // less than num_elems entries (see TypeCode).
+  const int64_t* values;  // Only set for non-consecutive enum/union or structs.
+  const char* const* names;  // Only set if compiled with --reflect-names.
+};
+
+// String which identifies the current version of FlatBuffers.
+inline const char* flatbuffers_version_string() {
+  return "FlatBuffers " FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MAJOR) "."
+      FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MINOR) "."
+      FLATBUFFERS_STRING(FLATBUFFERS_VERSION_REVISION);
+}
+
+// clang-format off
+#define FLATBUFFERS_DEFINE_BITMASK_OPERATORS(E, T)\
+    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator | (E lhs, E rhs){\
+        return E(T(lhs) | T(rhs));\
+    }\
+    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator & (E lhs, E rhs){\
+        return E(T(lhs) & T(rhs));\
+    }\
+    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator ^ (E lhs, E rhs){\
+        return E(T(lhs) ^ T(rhs));\
+    }\
+    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator ~ (E lhs){\
+        return E(~T(lhs));\
+    }\
+    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator |= (E &lhs, E rhs){\
+        lhs = lhs | rhs;\
+        return lhs;\
+    }\
+    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator &= (E &lhs, E rhs){\
+        lhs = lhs & rhs;\
+        return lhs;\
+    }\
+    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator ^= (E &lhs, E rhs){\
+        lhs = lhs ^ rhs;\
+        return lhs;\
+    }\
+    inline FLATBUFFERS_CONSTEXPR_CPP11 bool operator !(E rhs) \
+    {\
+        return !bool(T(rhs)); \
+    }
+/// @endcond
+}  // namespace flatbuffers
+
+// clang-format on
+
+#endif  // FLATBUFFERS_H_
diff --git a/external/flatbuffers/include/flatbuffers/flatc.h b/external/flatbuffers/include/flatbuffers/flatc.h
new file mode 100644
index 00000000..da24762c
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/flatc.h
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_FLATC_H_
+#define FLATBUFFERS_FLATC_H_
+
+#include <functional>
+#include <limits>
+#include <list>
+#include <memory>
+#include <string>
+
+#include "flatbuffers/code_generator.h"
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/idl.h"
+#include "flatbuffers/util.h"
+
+namespace flatbuffers {
+
+extern void LogCompilerWarn(const std::string& warn);
+extern void LogCompilerError(const std::string& err);
+
+struct FlatCOptions {
+  IDLOptions opts;
+
+  std::string program_name;
+
+  std::string output_path;
+
+  std::vector<std::string> filenames;
+
+  std::list<std::string> include_directories_storage;
+  std::vector<const char*> include_directories;
+  std::vector<const char*> conform_include_directories;
+  std::vector<bool> generator_enabled;
+  size_t binary_files_from = std::numeric_limits<size_t>::max();
+  std::string conform_to_schema;
+  std::string annotate_schema;
+  bool annotate_include_vector_contents = true;
+  bool any_generator = false;
+  bool print_make_rules = false;
+  bool raw_binary = false;
+  bool schema_binary = false;
+  bool grpc_enabled = false;
+  bool requires_bfbs = false;
+  bool file_names_only = false;
+
+  std::vector<std::shared_ptr<CodeGenerator>> generators;
+};
+
+struct FlatCOption {
+  std::string short_opt;
+  std::string long_opt;
+  std::string parameter;
+  std::string description;
+};
+
+class FlatCompiler {
+ public:
+  typedef void (*WarnFn)(const FlatCompiler* flatc, const std::string& warn,
+                         bool show_exe_name);
+
+  typedef void (*ErrorFn)(const FlatCompiler* flatc, const std::string& err,
+                          bool usage, bool show_exe_name);
+
+  // Parameters required to initialize the FlatCompiler.
+  struct InitParams {
+    InitParams() : warn_fn(nullptr), error_fn(nullptr) {}
+
+    WarnFn warn_fn;
+    ErrorFn error_fn;
+  };
+
+  explicit FlatCompiler(const InitParams& params) : params_(params) {}
+
+  bool RegisterCodeGenerator(const FlatCOption& option,
+                             std::shared_ptr<CodeGenerator> code_generator);
+
+  int Compile(const FlatCOptions& options);
+
+  std::string GetShortUsageString(const std::string& program_name) const;
+  std::string GetUsageString(const std::string& program_name) const;
+
+  // Parse the FlatC options from command line arguments.
+  FlatCOptions ParseFromCommandLineArguments(int argc, const char** argv);
+
+ private:
+  void ParseFile(flatbuffers::Parser& parser, const std::string& filename,
+                 const std::string& contents,
+                 const std::vector<const char*>& include_directories) const;
+
+  void LoadBinarySchema(Parser& parser, const std::string& filename,
+                        const std::string& contents);
+
+  void Warn(const std::string& warn, bool show_exe_name = true) const;
+
+  void Error(const std::string& err, bool usage = true,
+             bool show_exe_name = true) const;
+
+  void AnnotateBinaries(const uint8_t* binary_schema,
+                        uint64_t binary_schema_size,
+                        const FlatCOptions& options);
+
+  void ValidateOptions(const FlatCOptions& options);
+
+  Parser GetConformParser(const FlatCOptions& options);
+
+  std::unique_ptr<Parser> GenerateCode(const FlatCOptions& options,
+                                       Parser& conform_parser);
+
+  std::map<std::string, std::shared_ptr<CodeGenerator>> code_generators_;
+
+  InitParams params_;
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_FLATC_H_
diff --git a/external/flatbuffers/include/flatbuffers/flex_flat_util.h b/external/flatbuffers/include/flatbuffers/flex_flat_util.h
new file mode 100644
index 00000000..70c0a458
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/flex_flat_util.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2022 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_FLEX_FLAT_UTIL_H_
+#define FLATBUFFERS_FLEX_FLAT_UTIL_H_
+
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/flexbuffers.h"
+
+namespace flexbuffers {
+
+// Verifies the `nested` flexbuffer within a flatbuffer vector is valid.
+template <bool B>
+inline bool VerifyNestedFlexBuffer(
+    const flatbuffers::Vector<uint8_t>* const nested,
+    flatbuffers::VerifierTemplate<B>& verifier) {
+  if (!nested) return true;
+  return verifier.Check(flexbuffers::VerifyBuffer(
+      nested->data(), nested->size(), verifier.GetFlexReuseTracker()));
+}
+
+}  // namespace flexbuffers
+
+#endif  // FLATBUFFERS_FLEX_FLAT_UTIL_H_
diff --git a/external/flatbuffers/include/flatbuffers/flexbuffers.h b/external/flatbuffers/include/flatbuffers/flexbuffers.h
new file mode 100644
index 00000000..5c42a7ed
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/flexbuffers.h
@@ -0,0 +1,2086 @@
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_FLEXBUFFERS_H_
+#define FLATBUFFERS_FLEXBUFFERS_H_
+
+#include <algorithm>
+#include <map>
+// Used to select STL variant.
+#include "flatbuffers/base.h"
+// We use the basic binary writing functions from the regular FlatBuffers.
+#include "flatbuffers/util.h"
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127)  // C4127: conditional expression is constant
+#endif
+
+namespace flexbuffers {
+
+class Reference;
+class Map;
+
+// These are used in the lower 2 bits of a type field to determine the size of
+// the elements (and or size field) of the item pointed to (e.g. vector).
+enum BitWidth {
+  BIT_WIDTH_8 = 0,
+  BIT_WIDTH_16 = 1,
+  BIT_WIDTH_32 = 2,
+  BIT_WIDTH_64 = 3,
+};
+
+// These are used as the upper 6 bits of a type field to indicate the actual
+// type.
+enum Type {
+  FBT_NULL = 0,
+  FBT_INT = 1,
+  FBT_UINT = 2,
+  FBT_FLOAT = 3,
+  // Types above stored inline, types below (except FBT_BOOL) store an offset.
+  FBT_KEY = 4,
+  FBT_STRING = 5,
+  FBT_INDIRECT_INT = 6,
+  FBT_INDIRECT_UINT = 7,
+  FBT_INDIRECT_FLOAT = 8,
+  FBT_MAP = 9,
+  FBT_VECTOR = 10,      // Untyped.
+  FBT_VECTOR_INT = 11,  // Typed any size (stores no type table).
+  FBT_VECTOR_UINT = 12,
+  FBT_VECTOR_FLOAT = 13,
+  FBT_VECTOR_KEY = 14,
+  // DEPRECATED, use FBT_VECTOR or FBT_VECTOR_KEY instead.
+  // Read test.cpp/FlexBuffersDeprecatedTest() for details on why.
+  FBT_VECTOR_STRING_DEPRECATED = 15,
+  FBT_VECTOR_INT2 = 16,  // Typed tuple (no type table, no size field).
+  FBT_VECTOR_UINT2 = 17,
+  FBT_VECTOR_FLOAT2 = 18,
+  FBT_VECTOR_INT3 = 19,  // Typed triple (no type table, no size field).
+  FBT_VECTOR_UINT3 = 20,
+  FBT_VECTOR_FLOAT3 = 21,
+  FBT_VECTOR_INT4 = 22,  // Typed quad (no type table, no size field).
+  FBT_VECTOR_UINT4 = 23,
+  FBT_VECTOR_FLOAT4 = 24,
+  FBT_BLOB = 25,
+  FBT_BOOL = 26,
+  FBT_VECTOR_BOOL =
+      36,  // To Allow the same type of conversion of type to vector type
+
+  FBT_MAX_TYPE = 37
+};
+
+inline bool IsInline(Type t) { return t <= FBT_FLOAT || t == FBT_BOOL; }
+
+inline bool IsTypedVectorElementType(Type t) {
+  return (t >= FBT_INT && t <= FBT_STRING) || t == FBT_BOOL;
+}
+
+inline bool IsTypedVector(Type t) {
+  return (t >= FBT_VECTOR_INT && t <= FBT_VECTOR_STRING_DEPRECATED) ||
+         t == FBT_VECTOR_BOOL;
+}
+
+inline bool IsFixedTypedVector(Type t) {
+  return t >= FBT_VECTOR_INT2 && t <= FBT_VECTOR_FLOAT4;
+}
+
+inline Type ToTypedVector(Type t, size_t fixed_len = 0) {
+  FLATBUFFERS_ASSERT(IsTypedVectorElementType(t));
+  switch (fixed_len) {
+    case 0:
+      return static_cast<Type>(t - FBT_INT + FBT_VECTOR_INT);
+    case 2:
+      return static_cast<Type>(t - FBT_INT + FBT_VECTOR_INT2);
+    case 3:
+      return static_cast<Type>(t - FBT_INT + FBT_VECTOR_INT3);
+    case 4:
+      return static_cast<Type>(t - FBT_INT + FBT_VECTOR_INT4);
+    default:
+      FLATBUFFERS_ASSERT(0);
+      return FBT_NULL;
+  }
+}
+
+inline Type ToTypedVectorElementType(Type t) {
+  FLATBUFFERS_ASSERT(IsTypedVector(t));
+  return static_cast<Type>(t - FBT_VECTOR_INT + FBT_INT);
+}
+
+inline Type ToFixedTypedVectorElementType(Type t, uint8_t* len) {
+  FLATBUFFERS_ASSERT(IsFixedTypedVector(t));
+  auto fixed_type = t - FBT_VECTOR_INT2;
+  *len = static_cast<uint8_t>(fixed_type / 3 +
+                              2);  // 3 types each, starting from length 2.
+  return static_cast<Type>(fixed_type % 3 + FBT_INT);
+}
+
+// TODO: implement proper support for 8/16bit floats, or decide not to
+// support them.
+typedef int16_t half;
+typedef int8_t quarter;
+
+// TODO: can we do this without conditionals using intrinsics or inline asm
+// on some platforms? Given branch prediction the method below should be
+// decently quick, but it is the most frequently executed function.
+// We could do an (unaligned) 64-bit read if we ifdef out the platforms for
+// which that doesn't work (or where we'd read into un-owned memory).
+template <typename R, typename T1, typename T2, typename T4, typename T8>
+R ReadSizedScalar(const uint8_t* data, uint8_t byte_width) {
+  return byte_width < 4
+             ? (byte_width < 2
+                    ? static_cast<R>(flatbuffers::ReadScalar<T1>(data))
+                    : static_cast<R>(flatbuffers::ReadScalar<T2>(data)))
+             : (byte_width < 8
+                    ? static_cast<R>(flatbuffers::ReadScalar<T4>(data))
+                    : static_cast<R>(flatbuffers::ReadScalar<T8>(data)));
+}
+
+inline int64_t ReadInt64(const uint8_t* data, uint8_t byte_width) {
+  return ReadSizedScalar<int64_t, int8_t, int16_t, int32_t, int64_t>(
+      data, byte_width);
+}
+
+inline uint64_t ReadUInt64(const uint8_t* data, uint8_t byte_width) {
+  // This is the "hottest" function (all offset lookups use this), so worth
+  // optimizing if possible.
+  // TODO: GCC apparently replaces memcpy by a rep movsb, but only if count is a
+  // constant, which here it isn't. Test if memcpy is still faster than
+  // the conditionals in ReadSizedScalar. Can also use inline asm.
+
+  // clang-format off
+  #if defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
+  // This is 64-bit Windows only, __movsb does not work on 32-bit Windows.
+    uint64_t u = 0;
+    __movsb(reinterpret_cast<uint8_t *>(&u),
+            reinterpret_cast<const uint8_t *>(data), byte_width);
+    return flatbuffers::EndianScalar(u);
+  #else
+    return ReadSizedScalar<uint64_t, uint8_t, uint16_t, uint32_t, uint64_t>(
+             data, byte_width);
+  #endif
+  // clang-format on
+}
+
+inline double ReadDouble(const uint8_t* data, uint8_t byte_width) {
+  return ReadSizedScalar<double, quarter, half, float, double>(data,
+                                                               byte_width);
+}
+
+inline const uint8_t* Indirect(const uint8_t* offset, uint8_t byte_width) {
+  return offset - ReadUInt64(offset, byte_width);
+}
+
+template <typename T>
+const uint8_t* Indirect(const uint8_t* offset) {
+  return offset - flatbuffers::ReadScalar<T>(offset);
+}
+
+inline BitWidth WidthU(uint64_t u) {
+#define FLATBUFFERS_GET_FIELD_BIT_WIDTH(value, width)                   \
+  {                                                                     \
+    if (!((u) & ~((1ULL << (width)) - 1ULL))) return BIT_WIDTH_##width; \
+  }
+  FLATBUFFERS_GET_FIELD_BIT_WIDTH(u, 8);
+  FLATBUFFERS_GET_FIELD_BIT_WIDTH(u, 16);
+  FLATBUFFERS_GET_FIELD_BIT_WIDTH(u, 32);
+#undef FLATBUFFERS_GET_FIELD_BIT_WIDTH
+  return BIT_WIDTH_64;
+}
+
+inline BitWidth WidthI(int64_t i) {
+  auto u = static_cast<uint64_t>(i) << 1;
+  return WidthU(i >= 0 ? u : ~u);
+}
+
+inline BitWidth WidthF(double f) {
+  return static_cast<double>(static_cast<float>(f)) == f ? BIT_WIDTH_32
+                                                         : BIT_WIDTH_64;
+}
+
+// Base class of all types below.
+// Points into the data buffer and allows access to one type.
+class Object {
+ public:
+  Object(const uint8_t* data, uint8_t byte_width)
+      : data_(data), byte_width_(byte_width) {}
+
+ protected:
+  const uint8_t* data_;
+  uint8_t byte_width_;
+};
+
+// Object that has a size, obtained either from size prefix, or elsewhere.
+class Sized : public Object {
+ public:
+  // Size prefix.
+  Sized(const uint8_t* data, uint8_t byte_width)
+      : Object(data, byte_width), size_(read_size()) {}
+  // Manual size.
+  Sized(const uint8_t* data, uint8_t byte_width, size_t sz)
+      : Object(data, byte_width), size_(sz) {}
+  size_t size() const { return size_; }
+  // Access size stored in `byte_width_` bytes before data_ pointer.
+  size_t read_size() const {
+    return static_cast<size_t>(ReadUInt64(data_ - byte_width_, byte_width_));
+  }
+
+ protected:
+  size_t size_;
+};
+
+class String : public Sized {
+ public:
+  // Size prefix.
+  String(const uint8_t* data, uint8_t byte_width) : Sized(data, byte_width) {}
+  // Manual size.
+  String(const uint8_t* data, uint8_t byte_width, size_t sz)
+      : Sized(data, byte_width, sz) {}
+
+  size_t length() const { return size(); }
+  const char* c_str() const { return reinterpret_cast<const char*>(data_); }
+  std::string str() const { return std::string(c_str(), size()); }
+
+  static String EmptyString() {
+    static const char* empty_string = "";
+    return String(reinterpret_cast<const uint8_t*>(empty_string), 1, 0);
+  }
+  bool IsTheEmptyString() const { return data_ == EmptyString().data_; }
+};
+
+class Blob : public Sized {
+ public:
+  Blob(const uint8_t* data_buf, uint8_t byte_width)
+      : Sized(data_buf, byte_width) {}
+
+  static Blob EmptyBlob() {
+    static const uint8_t empty_blob[] = {0 /*len*/};
+    return Blob(empty_blob + 1, 1);
+  }
+  bool IsTheEmptyBlob() const { return data_ == EmptyBlob().data_; }
+  const uint8_t* data() const { return data_; }
+};
+
+class Vector : public Sized {
+ public:
+  Vector(const uint8_t* data, uint8_t byte_width) : Sized(data, byte_width) {}
+
+  Reference operator[](size_t i) const;
+
+  static Vector EmptyVector() {
+    static const uint8_t empty_vector[] = {0 /*len*/};
+    return Vector(empty_vector + 1, 1);
+  }
+  bool IsTheEmptyVector() const { return data_ == EmptyVector().data_; }
+};
+
+class TypedVector : public Sized {
+ public:
+  TypedVector(const uint8_t* data, uint8_t byte_width, Type element_type)
+      : Sized(data, byte_width), type_(element_type) {}
+
+  Reference operator[](size_t i) const;
+
+  static TypedVector EmptyTypedVector() {
+    static const uint8_t empty_typed_vector[] = {0 /*len*/};
+    return TypedVector(empty_typed_vector + 1, 1, FBT_INT);
+  }
+  bool IsTheEmptyVector() const {
+    return data_ == TypedVector::EmptyTypedVector().data_;
+  }
+
+  Type ElementType() { return type_; }
+
+  friend Reference;
+
+ private:
+  Type type_;
+
+  friend Map;
+};
+
+class FixedTypedVector : public Object {
+ public:
+  FixedTypedVector(const uint8_t* data, uint8_t byte_width, Type element_type,
+                   uint8_t len)
+      : Object(data, byte_width), type_(element_type), len_(len) {}
+
+  Reference operator[](size_t i) const;
+
+  static FixedTypedVector EmptyFixedTypedVector() {
+    static const uint8_t fixed_empty_vector[] = {0 /* unused */};
+    return FixedTypedVector(fixed_empty_vector, 1, FBT_INT, 0);
+  }
+  bool IsTheEmptyFixedTypedVector() const {
+    return data_ == FixedTypedVector::EmptyFixedTypedVector().data_;
+  }
+
+  Type ElementType() const { return type_; }
+  uint8_t size() const { return len_; }
+
+ private:
+  Type type_;
+  uint8_t len_;
+};
+
+class Map : public Vector {
+ public:
+  Map(const uint8_t* data, uint8_t byte_width) : Vector(data, byte_width) {}
+
+  Reference operator[](const char* key) const;
+  Reference operator[](const std::string& key) const;
+
+  Vector Values() const { return Vector(data_, byte_width_); }
+
+  TypedVector Keys() const {
+    const size_t num_prefixed_fields = 3;
+    auto keys_offset = data_ - byte_width_ * num_prefixed_fields;
+    return TypedVector(Indirect(keys_offset, byte_width_),
+                       static_cast<uint8_t>(
+                           ReadUInt64(keys_offset + byte_width_, byte_width_)),
+                       FBT_KEY);
+  }
+
+  static Map EmptyMap() {
+    static const uint8_t empty_map[] = {
+        0 /*keys_len*/, 0 /*keys_offset*/, 1 /*keys_width*/, 0 /*len*/
+    };
+    return Map(empty_map + 4, 1);
+  }
+
+  bool IsTheEmptyMap() const { return data_ == EmptyMap().data_; }
+};
+
+inline void IndentString(std::string& s, int indent,
+                         const char* indent_string) {
+  for (int i = 0; i < indent; i++) s += indent_string;
+}
+
+template <typename T>
+void AppendToString(std::string& s, T&& v, bool keys_quoted, bool indented,
+                    int cur_indent, const char* indent_string,
+                    bool natural_utf8) {
+  s += "[";
+  s += indented ? "\n" : " ";
+  for (size_t i = 0; i < v.size(); i++) {
+    if (i) {
+      s += ",";
+      s += indented ? "\n" : " ";
+    }
+    if (indented) IndentString(s, cur_indent, indent_string);
+    v[i].ToString(true, keys_quoted, s, indented, cur_indent, indent_string,
+                  natural_utf8);
+  }
+  if (indented) {
+    s += "\n";
+    IndentString(s, cur_indent - 1, indent_string);
+  } else {
+    s += " ";
+  }
+  s += "]";
+}
+
+template <typename T>
+void AppendToString(std::string& s, T&& v, bool keys_quoted) {
+  AppendToString(s, v, keys_quoted);
+}
+
+class Reference {
+ public:
+  Reference()
+      : data_(nullptr), parent_width_(0), byte_width_(0), type_(FBT_NULL) {}
+
+  Reference(const uint8_t* data, uint8_t parent_width, uint8_t byte_width,
+            Type type)
+      : data_(data),
+        parent_width_(parent_width),
+        byte_width_(byte_width),
+        type_(type) {}
+
+  Reference(const uint8_t* data, uint8_t parent_width, uint8_t packed_type)
+      : data_(data),
+        parent_width_(parent_width),
+        byte_width_(static_cast<uint8_t>(1 << (packed_type & 3))),
+        type_(static_cast<Type>(packed_type >> 2)) {}
+
+  Type GetType() const { return type_; }
+
+  bool IsNull() const { return type_ == FBT_NULL; }
+  bool IsBool() const { return type_ == FBT_BOOL; }
+  bool IsInt() const { return type_ == FBT_INT || type_ == FBT_INDIRECT_INT; }
+  bool IsUInt() const {
+    return type_ == FBT_UINT || type_ == FBT_INDIRECT_UINT;
+  }
+  bool IsIntOrUint() const { return IsInt() || IsUInt(); }
+  bool IsFloat() const {
+    return type_ == FBT_FLOAT || type_ == FBT_INDIRECT_FLOAT;
+  }
+  bool IsNumeric() const { return IsIntOrUint() || IsFloat(); }
+  bool IsString() const { return type_ == FBT_STRING; }
+  bool IsKey() const { return type_ == FBT_KEY; }
+  bool IsVector() const { return type_ == FBT_VECTOR || type_ == FBT_MAP; }
+  bool IsUntypedVector() const { return type_ == FBT_VECTOR; }
+  bool IsTypedVector() const { return flexbuffers::IsTypedVector(type_); }
+  bool IsFixedTypedVector() const {
+    return flexbuffers::IsFixedTypedVector(type_);
+  }
+  bool IsAnyVector() const {
+    return (IsTypedVector() || IsFixedTypedVector() || IsVector());
+  }
+  bool IsMap() const { return type_ == FBT_MAP; }
+  bool IsBlob() const { return type_ == FBT_BLOB; }
+  bool AsBool() const {
+    return (type_ == FBT_BOOL ? ReadUInt64(data_, parent_width_)
+                              : AsUInt64()) != 0;
+  }
+
+  // Reads any type as a int64_t. Never fails, does most sensible conversion.
+  // Truncates floats, strings are attempted to be parsed for a number,
+  // vectors/maps return their size. Returns 0 if all else fails.
+  int64_t AsInt64() const {
+    if (type_ == FBT_INT) {
+      // A fast path for the common case.
+      return ReadInt64(data_, parent_width_);
+    } else
+      switch (type_) {
+        case FBT_INDIRECT_INT:
+          return ReadInt64(Indirect(), byte_width_);
+        case FBT_UINT:
+          return ReadUInt64(data_, parent_width_);
+        case FBT_INDIRECT_UINT:
+          return ReadUInt64(Indirect(), byte_width_);
+        case FBT_FLOAT:
+          return static_cast<int64_t>(ReadDouble(data_, parent_width_));
+        case FBT_INDIRECT_FLOAT:
+          return static_cast<int64_t>(ReadDouble(Indirect(), byte_width_));
+        case FBT_NULL:
+          return 0;
+        case FBT_STRING:
+          return flatbuffers::StringToInt(AsString().c_str());
+        case FBT_VECTOR:
+          return static_cast<int64_t>(AsVector().size());
+        case FBT_BOOL:
+          return ReadInt64(data_, parent_width_);
+        default:
+          // Convert other things to int.
+          return 0;
+      }
+  }
+
+  // TODO: could specialize these to not use AsInt64() if that saves
+  // extension ops in generated code, and use a faster op than ReadInt64.
+  int32_t AsInt32() const { return static_cast<int32_t>(AsInt64()); }
+  int16_t AsInt16() const { return static_cast<int16_t>(AsInt64()); }
+  int8_t AsInt8() const { return static_cast<int8_t>(AsInt64()); }
+
+  uint64_t AsUInt64() const {
+    if (type_ == FBT_UINT) {
+      // A fast path for the common case.
+      return ReadUInt64(data_, parent_width_);
+    } else
+      switch (type_) {
+        case FBT_INDIRECT_UINT:
+          return ReadUInt64(Indirect(), byte_width_);
+        case FBT_INT:
+          return ReadInt64(data_, parent_width_);
+        case FBT_INDIRECT_INT:
+          return ReadInt64(Indirect(), byte_width_);
+        case FBT_FLOAT:
+          return static_cast<uint64_t>(ReadDouble(data_, parent_width_));
+        case FBT_INDIRECT_FLOAT:
+          return static_cast<uint64_t>(ReadDouble(Indirect(), byte_width_));
+        case FBT_NULL:
+          return 0;
+        case FBT_STRING:
+          return flatbuffers::StringToUInt(AsString().c_str());
+        case FBT_VECTOR:
+          return static_cast<uint64_t>(AsVector().size());
+        case FBT_BOOL:
+          return ReadUInt64(data_, parent_width_);
+        default:
+          // Convert other things to uint.
+          return 0;
+      }
+  }
+
+  uint32_t AsUInt32() const { return static_cast<uint32_t>(AsUInt64()); }
+  uint16_t AsUInt16() const { return static_cast<uint16_t>(AsUInt64()); }
+  uint8_t AsUInt8() const { return static_cast<uint8_t>(AsUInt64()); }
+
+  double AsDouble() const {
+    if (type_ == FBT_FLOAT) {
+      // A fast path for the common case.
+      return ReadDouble(data_, parent_width_);
+    } else
+      switch (type_) {
+        case FBT_INDIRECT_FLOAT:
+          return ReadDouble(Indirect(), byte_width_);
+        case FBT_INT:
+          return static_cast<double>(ReadInt64(data_, parent_width_));
+        case FBT_UINT:
+          return static_cast<double>(ReadUInt64(data_, parent_width_));
+        case FBT_INDIRECT_INT:
+          return static_cast<double>(ReadInt64(Indirect(), byte_width_));
+        case FBT_INDIRECT_UINT:
+          return static_cast<double>(ReadUInt64(Indirect(), byte_width_));
+        case FBT_NULL:
+          return 0.0;
+        case FBT_STRING: {
+          double d;
+          flatbuffers::StringToNumber(AsString().c_str(), &d);
+          return d;
+        }
+        case FBT_VECTOR:
+          return static_cast<double>(AsVector().size());
+        case FBT_BOOL:
+          return static_cast<double>(ReadUInt64(data_, parent_width_));
+        default:
+          // Convert strings and other things to float.
+          return 0;
+      }
+  }
+
+  float AsFloat() const { return static_cast<float>(AsDouble()); }
+
+  const char* AsKey() const {
+    if (type_ == FBT_KEY || type_ == FBT_STRING) {
+      return reinterpret_cast<const char*>(Indirect());
+    } else {
+      return "";
+    }
+  }
+
+  // This function returns the empty string if you try to read something that
+  // is not a string or key.
+  String AsString() const {
+    if (type_ == FBT_STRING) {
+      return String(Indirect(), byte_width_);
+    } else if (type_ == FBT_KEY) {
+      auto key = Indirect();
+      return String(key, byte_width_,
+                    strlen(reinterpret_cast<const char*>(key)));
+    } else {
+      return String::EmptyString();
+    }
+  }
+
+  // Unlike AsString(), this will convert any type to a std::string.
+  std::string ToString() const {
+    std::string s;
+    ToString(false, false, s);
+    return s;
+  }
+
+  // Convert any type to a JSON-like string. strings_quoted determines if
+  // string values at the top level receive "" quotes (inside other values
+  // they always do). keys_quoted determines if keys are quoted, at any level.
+  void ToString(bool strings_quoted, bool keys_quoted, std::string& s) const {
+    ToString(strings_quoted, keys_quoted, s, false, 0, "", false);
+  }
+
+  // This version additionally allow you to specify if you want indentation.
+  void ToString(bool strings_quoted, bool keys_quoted, std::string& s,
+                bool indented, int cur_indent, const char* indent_string,
+                bool natural_utf8 = false) const {
+    if (type_ == FBT_STRING) {
+      String str(Indirect(), byte_width_);
+      if (strings_quoted) {
+        flatbuffers::EscapeString(str.c_str(), str.length(), &s, true,
+                                  natural_utf8);
+      } else {
+        s.append(str.c_str(), str.length());
+      }
+    } else if (IsKey()) {
+      auto str = AsKey();
+      if (keys_quoted) {
+        flatbuffers::EscapeString(str, strlen(str), &s, true, natural_utf8);
+      } else {
+        s += str;
+      }
+    } else if (IsInt()) {
+      s += flatbuffers::NumToString(AsInt64());
+    } else if (IsUInt()) {
+      s += flatbuffers::NumToString(AsUInt64());
+    } else if (IsFloat()) {
+      s += flatbuffers::NumToString(AsDouble());
+    } else if (IsNull()) {
+      s += "null";
+    } else if (IsBool()) {
+      s += AsBool() ? "true" : "false";
+    } else if (IsMap()) {
+      s += "{";
+      s += indented ? "\n" : " ";
+      auto m = AsMap();
+      auto keys = m.Keys();
+      auto vals = m.Values();
+      for (size_t i = 0; i < keys.size(); i++) {
+        bool kq = keys_quoted;
+        if (!kq) {
+          // FlexBuffers keys may contain arbitrary characters, only allow
+          // unquoted if it looks like an "identifier":
+          const char* p = keys[i].AsKey();
+          if (!flatbuffers::is_alpha(*p) && *p != '_') {
+            kq = true;
+          } else {
+            while (*++p) {
+              if (!flatbuffers::is_alnum(*p) && *p != '_') {
+                kq = true;
+                break;
+              }
+            }
+          }
+        }
+        if (indented) IndentString(s, cur_indent + 1, indent_string);
+        keys[i].ToString(true, kq, s);
+        s += ": ";
+        vals[i].ToString(true, keys_quoted, s, indented, cur_indent + 1,
+                         indent_string, natural_utf8);
+        if (i < keys.size() - 1) {
+          s += ",";
+          if (!indented) s += " ";
+        }
+        if (indented) s += "\n";
+      }
+      if (!indented) s += " ";
+      if (indented) IndentString(s, cur_indent, indent_string);
+      s += "}";
+    } else if (IsVector()) {
+      AppendToString<Vector>(s, AsVector(), keys_quoted, indented,
+                             cur_indent + 1, indent_string, natural_utf8);
+    } else if (IsTypedVector()) {
+      AppendToString<TypedVector>(s, AsTypedVector(), keys_quoted, indented,
+                                  cur_indent + 1, indent_string, natural_utf8);
+    } else if (IsFixedTypedVector()) {
+      AppendToString<FixedTypedVector>(s, AsFixedTypedVector(), keys_quoted,
+                                       indented, cur_indent + 1, indent_string,
+                                       natural_utf8);
+    } else if (IsBlob()) {
+      auto blob = AsBlob();
+      flatbuffers::EscapeString(reinterpret_cast<const char*>(blob.data()),
+                                blob.size(), &s, true, false);
+    } else {
+      s += "(?)";
+    }
+  }
+
+  // This function returns the empty blob if you try to read a not-blob.
+  // Strings can be viewed as blobs too.
+  Blob AsBlob() const {
+    if (type_ == FBT_BLOB || type_ == FBT_STRING) {
+      return Blob(Indirect(), byte_width_);
+    } else {
+      return Blob::EmptyBlob();
+    }
+  }
+
+  // This function returns the empty vector if you try to read a not-vector.
+  // Maps can be viewed as vectors too.
+  Vector AsVector() const {
+    if (type_ == FBT_VECTOR || type_ == FBT_MAP) {
+      return Vector(Indirect(), byte_width_);
+    } else {
+      return Vector::EmptyVector();
+    }
+  }
+
+  TypedVector AsTypedVector() const {
+    if (IsTypedVector()) {
+      auto tv =
+          TypedVector(Indirect(), byte_width_, ToTypedVectorElementType(type_));
+      if (tv.type_ == FBT_STRING) {
+        // These can't be accessed as strings, since we don't know the bit-width
+        // of the size field, see the declaration of
+        // FBT_VECTOR_STRING_DEPRECATED above for details.
+        // We change the type here to be keys, which are a subtype of strings,
+        // and will ignore the size field. This will truncate strings with
+        // embedded nulls.
+        tv.type_ = FBT_KEY;
+      }
+      return tv;
+    } else {
+      return TypedVector::EmptyTypedVector();
+    }
+  }
+
+  FixedTypedVector AsFixedTypedVector() const {
+    if (IsFixedTypedVector()) {
+      uint8_t len = 0;
+      auto vtype = ToFixedTypedVectorElementType(type_, &len);
+      return FixedTypedVector(Indirect(), byte_width_, vtype, len);
+    } else {
+      return FixedTypedVector::EmptyFixedTypedVector();
+    }
+  }
+
+  Map AsMap() const {
+    if (type_ == FBT_MAP) {
+      return Map(Indirect(), byte_width_);
+    } else {
+      return Map::EmptyMap();
+    }
+  }
+
+  template <typename T>
+  T As() const;
+
+  // Experimental: Mutation functions.
+  // These allow scalars in an already created buffer to be updated in-place.
+  // Since by default scalars are stored in the smallest possible space,
+  // the new value may not fit, in which case these functions return false.
+  // To avoid this, you can construct the values you intend to mutate using
+  // Builder::ForceMinimumBitWidth.
+  bool MutateInt(int64_t i) {
+    if (type_ == FBT_INT) {
+      return Mutate(data_, i, parent_width_, WidthI(i));
+    } else if (type_ == FBT_INDIRECT_INT) {
+      return Mutate(Indirect(), i, byte_width_, WidthI(i));
+    } else if (type_ == FBT_UINT) {
+      auto u = static_cast<uint64_t>(i);
+      return Mutate(data_, u, parent_width_, WidthU(u));
+    } else if (type_ == FBT_INDIRECT_UINT) {
+      auto u = static_cast<uint64_t>(i);
+      return Mutate(Indirect(), u, byte_width_, WidthU(u));
+    } else {
+      return false;
+    }
+  }
+
+  bool MutateBool(bool b) {
+    return type_ == FBT_BOOL && Mutate(data_, b, parent_width_, BIT_WIDTH_8);
+  }
+
+  bool MutateUInt(uint64_t u) {
+    if (type_ == FBT_UINT) {
+      return Mutate(data_, u, parent_width_, WidthU(u));
+    } else if (type_ == FBT_INDIRECT_UINT) {
+      return Mutate(Indirect(), u, byte_width_, WidthU(u));
+    } else if (type_ == FBT_INT) {
+      auto i = static_cast<int64_t>(u);
+      return Mutate(data_, i, parent_width_, WidthI(i));
+    } else if (type_ == FBT_INDIRECT_INT) {
+      auto i = static_cast<int64_t>(u);
+      return Mutate(Indirect(), i, byte_width_, WidthI(i));
+    } else {
+      return false;
+    }
+  }
+
+  bool MutateFloat(float f) {
+    if (type_ == FBT_FLOAT) {
+      return MutateF(data_, f, parent_width_, BIT_WIDTH_32);
+    } else if (type_ == FBT_INDIRECT_FLOAT) {
+      return MutateF(Indirect(), f, byte_width_, BIT_WIDTH_32);
+    } else {
+      return false;
+    }
+  }
+
+  bool MutateFloat(double d) {
+    if (type_ == FBT_FLOAT) {
+      return MutateF(data_, d, parent_width_, WidthF(d));
+    } else if (type_ == FBT_INDIRECT_FLOAT) {
+      return MutateF(Indirect(), d, byte_width_, WidthF(d));
+    } else {
+      return false;
+    }
+  }
+
+  bool MutateString(const char* str, size_t len) {
+    auto s = AsString();
+    if (s.IsTheEmptyString()) return false;
+    // This is very strict, could allow shorter strings, but that creates
+    // garbage.
+    if (s.length() != len) return false;
+    memcpy(const_cast<char*>(s.c_str()), str, len);
+    return true;
+  }
+  bool MutateString(const char* str) { return MutateString(str, strlen(str)); }
+  bool MutateString(const std::string& str) {
+    return MutateString(str.data(), str.length());
+  }
+
+ private:
+  const uint8_t* Indirect() const {
+    return flexbuffers::Indirect(data_, parent_width_);
+  }
+
+  template <typename T>
+  bool Mutate(const uint8_t* dest, T t, size_t byte_width,
+              BitWidth value_width) {
+    auto fits = static_cast<size_t>(static_cast<size_t>(1U) << value_width) <=
+                byte_width;
+    if (fits) {
+      t = flatbuffers::EndianScalar(t);
+      memcpy(const_cast<uint8_t*>(dest), &t, byte_width);
+    }
+    return fits;
+  }
+
+  template <typename T>
+  bool MutateF(const uint8_t* dest, T t, size_t byte_width,
+               BitWidth value_width) {
+    if (byte_width == sizeof(double))
+      return Mutate(dest, static_cast<double>(t), byte_width, value_width);
+    if (byte_width == sizeof(float))
+      return Mutate(dest, static_cast<float>(t), byte_width, value_width);
+    FLATBUFFERS_ASSERT(false);
+    return false;
+  }
+
+  friend class Verifier;
+
+  const uint8_t* data_;
+  uint8_t parent_width_;
+  uint8_t byte_width_;
+  Type type_;
+};
+
+// Template specialization for As().
+template <>
+inline bool Reference::As<bool>() const {
+  return AsBool();
+}
+
+template <>
+inline int8_t Reference::As<int8_t>() const {
+  return AsInt8();
+}
+template <>
+inline int16_t Reference::As<int16_t>() const {
+  return AsInt16();
+}
+template <>
+inline int32_t Reference::As<int32_t>() const {
+  return AsInt32();
+}
+template <>
+inline int64_t Reference::As<int64_t>() const {
+  return AsInt64();
+}
+
+template <>
+inline uint8_t Reference::As<uint8_t>() const {
+  return AsUInt8();
+}
+template <>
+inline uint16_t Reference::As<uint16_t>() const {
+  return AsUInt16();
+}
+template <>
+inline uint32_t Reference::As<uint32_t>() const {
+  return AsUInt32();
+}
+template <>
+inline uint64_t Reference::As<uint64_t>() const {
+  return AsUInt64();
+}
+
+template <>
+inline double Reference::As<double>() const {
+  return AsDouble();
+}
+template <>
+inline float Reference::As<float>() const {
+  return AsFloat();
+}
+
+template <>
+inline String Reference::As<String>() const {
+  return AsString();
+}
+template <>
+inline std::string Reference::As<std::string>() const {
+  return AsString().str();
+}
+
+template <>
+inline Blob Reference::As<Blob>() const {
+  return AsBlob();
+}
+template <>
+inline Vector Reference::As<Vector>() const {
+  return AsVector();
+}
+template <>
+inline TypedVector Reference::As<TypedVector>() const {
+  return AsTypedVector();
+}
+template <>
+inline FixedTypedVector Reference::As<FixedTypedVector>() const {
+  return AsFixedTypedVector();
+}
+template <>
+inline Map Reference::As<Map>() const {
+  return AsMap();
+}
+
+inline uint8_t PackedType(BitWidth bit_width, Type type) {
+  return static_cast<uint8_t>(bit_width | (type << 2));
+}
+
+inline uint8_t NullPackedType() { return PackedType(BIT_WIDTH_8, FBT_NULL); }
+
+// Vector accessors.
+// Note: if you try to access outside of bounds, you get a Null value back
+// instead. Normally this would be an assert, but since this is "dynamically
+// typed" data, you may not want that (someone sends you a 2d vector and you
+// wanted 3d).
+// The Null converts seamlessly into a default value for any other type.
+// TODO(wvo): Could introduce an #ifdef that makes this into an assert?
+inline Reference Vector::operator[](size_t i) const {
+  auto len = size();
+  if (i >= len) return Reference(nullptr, 1, NullPackedType());
+  auto packed_type = (data_ + len * byte_width_)[i];
+  auto elem = data_ + i * byte_width_;
+  return Reference(elem, byte_width_, packed_type);
+}
+
+inline Reference TypedVector::operator[](size_t i) const {
+  auto len = size();
+  if (i >= len) return Reference(nullptr, 1, NullPackedType());
+  auto elem = data_ + i * byte_width_;
+  return Reference(elem, byte_width_, 1, type_);
+}
+
+inline Reference FixedTypedVector::operator[](size_t i) const {
+  if (i >= len_) return Reference(nullptr, 1, NullPackedType());
+  auto elem = data_ + i * byte_width_;
+  return Reference(elem, byte_width_, 1, type_);
+}
+
+template <typename T>
+int KeyCompare(const void* key, const void* elem) {
+  auto str_elem = reinterpret_cast<const char*>(
+      Indirect<T>(reinterpret_cast<const uint8_t*>(elem)));
+  auto skey = reinterpret_cast<const char*>(key);
+  return strcmp(skey, str_elem);
+}
+
+inline Reference Map::operator[](const char* key) const {
+  auto keys = Keys();
+  // We can't pass keys.byte_width_ to the comparison function, so we have
+  // to pick the right one ahead of time.
+  int (*comp)(const void*, const void*) = nullptr;
+  switch (keys.byte_width_) {
+    case 1:
+      comp = KeyCompare<uint8_t>;
+      break;
+    case 2:
+      comp = KeyCompare<uint16_t>;
+      break;
+    case 4:
+      comp = KeyCompare<uint32_t>;
+      break;
+    case 8:
+      comp = KeyCompare<uint64_t>;
+      break;
+    default:
+      FLATBUFFERS_ASSERT(false);
+      return Reference();
+  }
+  auto res = std::bsearch(key, keys.data_, keys.size(), keys.byte_width_, comp);
+  if (!res) return Reference(nullptr, 1, NullPackedType());
+  auto i = (reinterpret_cast<uint8_t*>(res) - keys.data_) / keys.byte_width_;
+  return (*static_cast<const Vector*>(this))[i];
+}
+
+inline Reference Map::operator[](const std::string& key) const {
+  return (*this)[key.c_str()];
+}
+
+inline Reference GetRoot(const uint8_t* buffer, size_t size) {
+  // See Finish() below for the serialization counterpart of this.
+  // The root starts at the end of the buffer, so we parse backwards from there.
+  auto end = buffer + size;
+  auto byte_width = *--end;
+  auto packed_type = *--end;
+  end -= byte_width;  // The root data item.
+  return Reference(end, byte_width, packed_type);
+}
+
+inline Reference GetRoot(const std::vector<uint8_t>& buffer) {
+  return GetRoot(buffer.data(), buffer.size());
+}
+
+// Flags that configure how the Builder behaves.
+// The "Share" flags determine if the Builder automatically tries to pool
+// this type. Pooling can reduce the size of serialized data if there are
+// multiple maps of the same kind, at the expense of slightly slower
+// serialization (the cost of lookups) and more memory use (std::set).
+// By default this is on for keys, but off for strings.
+// Turn keys off if you have e.g. only one map.
+// Turn strings on if you expect many non-unique string values.
+// Additionally, sharing key vectors can save space if you have maps with
+// identical field populations.
+enum BuilderFlag {
+  BUILDER_FLAG_NONE = 0,
+  BUILDER_FLAG_SHARE_KEYS = 1,
+  BUILDER_FLAG_SHARE_STRINGS = 2,
+  BUILDER_FLAG_SHARE_KEYS_AND_STRINGS = 3,
+  BUILDER_FLAG_SHARE_KEY_VECTORS = 4,
+  BUILDER_FLAG_SHARE_ALL = 7,
+};
+
+class Builder FLATBUFFERS_FINAL_CLASS {
+ public:
+  Builder(size_t initial_size = 256,
+          BuilderFlag flags = BUILDER_FLAG_SHARE_KEYS)
+      : buf_(initial_size),
+        finished_(false),
+        has_duplicate_keys_(false),
+        flags_(flags),
+        force_min_bit_width_(BIT_WIDTH_8),
+        key_pool(KeyOffsetCompare(buf_)),
+        string_pool(StringOffsetCompare(buf_)) {
+    buf_.clear();
+  }
+
+#ifdef FLATBUFFERS_DEFAULT_DECLARATION
+  Builder(Builder&&) = default;
+  Builder& operator=(Builder&&) = default;
+#endif
+
+  /// @brief Get the serialized buffer (after you call `Finish()`).
+  /// @return Returns a vector owned by this class.
+  const std::vector<uint8_t>& GetBuffer() const {
+    Finished();
+    return buf_;
+  }
+
+  // Size of the buffer. Does not include unfinished values.
+  size_t GetSize() const { return buf_.size(); }
+
+  // Reset all state so we can re-use the buffer.
+  void Clear() {
+    buf_.clear();
+    stack_.clear();
+    finished_ = false;
+    // flags_ remains as-is;
+    force_min_bit_width_ = BIT_WIDTH_8;
+    key_pool.clear();
+    string_pool.clear();
+  }
+
+  // All value constructing functions below have two versions: one that
+  // takes a key (for placement inside a map) and one that doesn't (for inside
+  // vectors and elsewhere).
+
+  void Null() { stack_.push_back(Value()); }
+  void Null(const char* key) {
+    Key(key);
+    Null();
+  }
+
+  void Int(int64_t i) { stack_.push_back(Value(i, FBT_INT, WidthI(i))); }
+  void Int(const char* key, int64_t i) {
+    Key(key);
+    Int(i);
+  }
+
+  void UInt(uint64_t u) { stack_.push_back(Value(u, FBT_UINT, WidthU(u))); }
+  void UInt(const char* key, uint64_t u) {
+    Key(key);
+    UInt(u);
+  }
+
+  void Float(float f) { stack_.push_back(Value(f)); }
+  void Float(const char* key, float f) {
+    Key(key);
+    Float(f);
+  }
+
+  void Double(double f) { stack_.push_back(Value(f)); }
+  void Double(const char* key, double d) {
+    Key(key);
+    Double(d);
+  }
+
+  void Bool(bool b) { stack_.push_back(Value(b)); }
+  void Bool(const char* key, bool b) {
+    Key(key);
+    Bool(b);
+  }
+
+  void IndirectInt(int64_t i) { PushIndirect(i, FBT_INDIRECT_INT, WidthI(i)); }
+  void IndirectInt(const char* key, int64_t i) {
+    Key(key);
+    IndirectInt(i);
+  }
+
+  void IndirectUInt(uint64_t u) {
+    PushIndirect(u, FBT_INDIRECT_UINT, WidthU(u));
+  }
+  void IndirectUInt(const char* key, uint64_t u) {
+    Key(key);
+    IndirectUInt(u);
+  }
+
+  void IndirectFloat(float f) {
+    PushIndirect(f, FBT_INDIRECT_FLOAT, BIT_WIDTH_32);
+  }
+  void IndirectFloat(const char* key, float f) {
+    Key(key);
+    IndirectFloat(f);
+  }
+
+  void IndirectDouble(double f) {
+    PushIndirect(f, FBT_INDIRECT_FLOAT, WidthF(f));
+  }
+  void IndirectDouble(const char* key, double d) {
+    Key(key);
+    IndirectDouble(d);
+  }
+
+  size_t Key(const char* str, size_t len) {
+    auto sloc = buf_.size();
+    WriteBytes(str, len + 1);
+    if (flags_ & BUILDER_FLAG_SHARE_KEYS) {
+      auto it = key_pool.find(sloc);
+      if (it != key_pool.end()) {
+        // Already in the buffer. Remove key we just serialized, and use
+        // existing offset instead.
+        buf_.resize(sloc);
+        sloc = *it;
+      } else {
+        key_pool.insert(sloc);
+      }
+    }
+    stack_.push_back(Value(static_cast<uint64_t>(sloc), FBT_KEY, BIT_WIDTH_8));
+    return sloc;
+  }
+
+  size_t Key(const char* str) { return Key(str, strlen(str)); }
+  size_t Key(const std::string& str) { return Key(str.c_str(), str.size()); }
+
+  size_t String(const char* str, size_t len) {
+    auto reset_to = buf_.size();
+    auto sloc = CreateBlob(str, len, 1, FBT_STRING);
+    if (flags_ & BUILDER_FLAG_SHARE_STRINGS) {
+      StringOffset so(sloc, len);
+      auto it = string_pool.find(so);
+      if (it != string_pool.end()) {
+        // Already in the buffer. Remove string we just serialized, and use
+        // existing offset instead.
+        buf_.resize(reset_to);
+        sloc = it->first;
+        stack_.back().u_ = sloc;
+      } else {
+        string_pool.insert(so);
+      }
+    }
+    return sloc;
+  }
+  size_t String(const char* str) { return String(str, strlen(str)); }
+  size_t String(const std::string& str) {
+    return String(str.c_str(), str.size());
+  }
+  void String(const flexbuffers::String& str) {
+    String(str.c_str(), str.length());
+  }
+
+  void String(const char* key, const char* str) {
+    Key(key);
+    String(str);
+  }
+  void String(const char* key, const std::string& str) {
+    Key(key);
+    String(str);
+  }
+  void String(const char* key, const flexbuffers::String& str) {
+    Key(key);
+    String(str);
+  }
+
+  size_t AlignedBlob(const void* data, size_t len, BitWidth alignment) {
+    // The requested alignment must not be smaller than the one required to
+    // store the length.
+    return CreateAlignedBlob(data, len, 0, FBT_BLOB,
+                             std::max(alignment, WidthU(len)));
+  }
+  size_t AlignedBlob(const std::vector<uint8_t>& v, BitWidth alignment) {
+    return AlignedBlob(v.data(), v.size(), alignment);
+  }
+  size_t Blob(const void* data, size_t len) {
+    return CreateBlob(data, len, 0, FBT_BLOB);
+  }
+  size_t Blob(const std::vector<uint8_t>& v) {
+    return Blob(v.data(), v.size());
+  }
+
+  void Blob(const char* key, const void* data, size_t len) {
+    Key(key);
+    Blob(data, len);
+  }
+  void Blob(const char* key, const std::vector<uint8_t>& v) {
+    Key(key);
+    Blob(v);
+  }
+
+  // TODO(wvo): support all the FlexBuffer types (like flexbuffers::String),
+  // e.g. Vector etc. Also in overloaded versions.
+  // Also some FlatBuffers types?
+
+  size_t StartVector() { return stack_.size(); }
+  size_t StartVector(const char* key) {
+    Key(key);
+    return stack_.size();
+  }
+  size_t StartMap() { return stack_.size(); }
+  size_t StartMap(const char* key) {
+    Key(key);
+    return stack_.size();
+  }
+
+  // TODO(wvo): allow this to specify an alignment greater than the natural
+  // alignment.
+  size_t EndVector(size_t start, bool typed, bool fixed) {
+    auto vec = CreateVector(start, stack_.size() - start, 1, typed, fixed);
+    // Remove temp elements and return vector.
+    stack_.resize(start);
+    stack_.push_back(vec);
+    return static_cast<size_t>(vec.u_);
+  }
+
+  size_t EndMap(size_t start) {
+    // We should have interleaved keys and values on the stack.
+    auto len = MapElementCount(start);
+    // Make sure keys are all strings:
+    for (auto key = start; key < stack_.size(); key += 2) {
+      FLATBUFFERS_ASSERT(stack_[key].type_ == FBT_KEY);
+    }
+    // Now sort values, so later we can do a binary search lookup.
+    // We want to sort 2 array elements at a time.
+    struct TwoValue {
+      Value key;
+      Value val;
+    };
+    // TODO(wvo): strict aliasing?
+    // TODO(wvo): allow the caller to indicate the data is already sorted
+    // for maximum efficiency? With an assert to check sortedness to make sure
+    // we're not breaking binary search.
+    // Or, we can track if the map is sorted as keys are added which would be
+    // be quite cheap (cheaper than checking it here), so we can skip this
+    // step automatically when appliccable, and encourage people to write in
+    // sorted fashion.
+    // std::sort is typically already a lot faster on sorted data though.
+    auto dict = reinterpret_cast<TwoValue*>(stack_.data() + start);
+    std::sort(dict, dict + len,
+              [&](const TwoValue& a, const TwoValue& b) -> bool {
+                auto as = reinterpret_cast<const char*>(buf_.data() + a.key.u_);
+                auto bs = reinterpret_cast<const char*>(buf_.data() + b.key.u_);
+                auto comp = strcmp(as, bs);
+                // We want to disallow duplicate keys, since this results in a
+                // map where values cannot be found.
+                // But we can't assert here (since we don't want to fail on
+                // random JSON input) or have an error mechanism.
+                // Instead, we set has_duplicate_keys_ in the builder to
+                // signal this.
+                // TODO: Have to check for pointer equality, as some sort
+                // implementation apparently call this function with the same
+                // element?? Why?
+                if (!comp && &a != &b) has_duplicate_keys_ = true;
+                return comp < 0;
+              });
+    // First create a vector out of all keys.
+    // TODO(wvo): if kBuilderFlagShareKeyVectors is true, see if we can share
+    // the first vector.
+    auto keys = CreateVector(start, len, 2, true, false);
+    auto vec = CreateVector(start + 1, len, 2, false, false, &keys);
+    // Remove temp elements and return map.
+    stack_.resize(start);
+    stack_.push_back(vec);
+    return static_cast<size_t>(vec.u_);
+  }
+
+  // Call this after EndMap to see if the map had any duplicate keys.
+  // Any map with such keys won't be able to retrieve all values.
+  bool HasDuplicateKeys() const { return has_duplicate_keys_; }
+
+  template <typename F>
+  size_t Vector(F f) {
+    auto start = StartVector();
+    f();
+    return EndVector(start, false, false);
+  }
+  template <typename F, typename T>
+  size_t Vector(F f, T& state) {
+    auto start = StartVector();
+    f(state);
+    return EndVector(start, false, false);
+  }
+  template <typename F>
+  size_t Vector(const char* key, F f) {
+    auto start = StartVector(key);
+    f();
+    return EndVector(start, false, false);
+  }
+  template <typename F, typename T>
+  size_t Vector(const char* key, F f, T& state) {
+    auto start = StartVector(key);
+    f(state);
+    return EndVector(start, false, false);
+  }
+
+  template <typename T>
+  void Vector(const T* elems, size_t len) {
+    if (flatbuffers::is_scalar<T>::value) {
+      // This path should be a lot quicker and use less space.
+      ScalarVector(elems, len, false);
+    } else {
+      auto start = StartVector();
+      for (size_t i = 0; i < len; i++) Add(elems[i]);
+      EndVector(start, false, false);
+    }
+  }
+  template <typename T>
+  void Vector(const char* key, const T* elems, size_t len) {
+    Key(key);
+    Vector(elems, len);
+  }
+  template <typename T>
+  void Vector(const std::vector<T>& vec) {
+    Vector(vec.data(), vec.size());
+  }
+
+  template <typename F>
+  size_t TypedVector(F f) {
+    auto start = StartVector();
+    f();
+    return EndVector(start, true, false);
+  }
+  template <typename F, typename T>
+  size_t TypedVector(F f, T& state) {
+    auto start = StartVector();
+    f(state);
+    return EndVector(start, true, false);
+  }
+  template <typename F>
+  size_t TypedVector(const char* key, F f) {
+    auto start = StartVector(key);
+    f();
+    return EndVector(start, true, false);
+  }
+  template <typename F, typename T>
+  size_t TypedVector(const char* key, F f, T& state) {
+    auto start = StartVector(key);
+    f(state);
+    return EndVector(start, true, false);
+  }
+
+  template <typename T>
+  size_t FixedTypedVector(const T* elems, size_t len) {
+    // We only support a few fixed vector lengths. Anything bigger use a
+    // regular typed vector.
+    FLATBUFFERS_ASSERT(len >= 2 && len <= 4);
+    // And only scalar values.
+    static_assert(flatbuffers::is_scalar<T>::value, "Unrelated types");
+    return ScalarVector(elems, len, true);
+  }
+
+  template <typename T>
+  size_t FixedTypedVector(const char* key, const T* elems, size_t len) {
+    Key(key);
+    return FixedTypedVector(elems, len);
+  }
+
+  template <typename F>
+  size_t Map(F f) {
+    auto start = StartMap();
+    f();
+    return EndMap(start);
+  }
+  template <typename F, typename T>
+  size_t Map(F f, T& state) {
+    auto start = StartMap();
+    f(state);
+    return EndMap(start);
+  }
+  template <typename F>
+  size_t Map(const char* key, F f) {
+    auto start = StartMap(key);
+    f();
+    return EndMap(start);
+  }
+  template <typename F, typename T>
+  size_t Map(const char* key, F f, T& state) {
+    auto start = StartMap(key);
+    f(state);
+    return EndMap(start);
+  }
+  template <typename T>
+  void Map(const std::map<std::string, T>& map) {
+    auto start = StartMap();
+    for (auto it = map.begin(); it != map.end(); ++it)
+      Add(it->first.c_str(), it->second);
+    EndMap(start);
+  }
+
+  size_t MapElementCount(size_t start) {
+    // Make sure it is an even number:
+    auto len = stack_.size() - start;
+    FLATBUFFERS_ASSERT(!(len & 1));
+    len /= 2;
+    return len;
+  }
+
+  // If you wish to share a value explicitly (a value not shared automatically
+  // through one of the BUILDER_FLAG_SHARE_* flags) you can do so with these
+  // functions. Or if you wish to turn those flags off for performance reasons
+  // and still do some explicit sharing. For example:
+  // builder.IndirectDouble(M_PI);
+  // auto id = builder.LastValue();  // Remember where we stored it.
+  // .. more code goes here ..
+  // builder.ReuseValue(id);  // Refers to same double by offset.
+  // LastValue works regardless of whether the value has a key or not.
+  // Works on any data type.
+  struct Value;
+  Value LastValue() { return stack_.back(); }
+  void ReuseValue(Value v) { stack_.push_back(v); }
+  void ReuseValue(const char* key, Value v) {
+    Key(key);
+    ReuseValue(v);
+  }
+
+  // Undo the last element serialized. Call once for a value and once for a
+  // key.
+  void Undo() { stack_.pop_back(); }
+
+  // Overloaded Add that tries to call the correct function above.
+  void Add(int8_t i) { Int(i); }
+  void Add(int16_t i) { Int(i); }
+  void Add(int32_t i) { Int(i); }
+  void Add(int64_t i) { Int(i); }
+  void Add(uint8_t u) { UInt(u); }
+  void Add(uint16_t u) { UInt(u); }
+  void Add(uint32_t u) { UInt(u); }
+  void Add(uint64_t u) { UInt(u); }
+  void Add(float f) { Float(f); }
+  void Add(double d) { Double(d); }
+  void Add(bool b) { Bool(b); }
+  void Add(const char* str) { String(str); }
+  void Add(const std::string& str) { String(str); }
+  void Add(const flexbuffers::String& str) { String(str); }
+
+  template <typename T>
+  void Add(const std::vector<T>& vec) {
+    Vector(vec);
+  }
+
+  template <typename T>
+  void Add(const char* key, const T& t) {
+    Key(key);
+    Add(t);
+  }
+
+  template <typename T>
+  void Add(const std::map<std::string, T>& map) {
+    Map(map);
+  }
+
+  template <typename T>
+  void operator+=(const T& t) {
+    Add(t);
+  }
+
+  // This function is useful in combination with the Mutate* functions above.
+  // It forces elements of vectors and maps to have a minimum size, such that
+  // they can later be updated without failing.
+  // Call with no arguments to reset.
+  void ForceMinimumBitWidth(BitWidth bw = BIT_WIDTH_8) {
+    force_min_bit_width_ = bw;
+  }
+
+  void Finish() {
+    // If you hit this assert, you likely have objects that were never included
+    // in a parent. You need to have exactly one root to finish a buffer.
+    // Check your Start/End calls are matched, and all objects are inside
+    // some other object.
+    FLATBUFFERS_ASSERT(stack_.size() == 1);
+
+    // Write root value.
+    auto byte_width = Align(stack_[0].ElemWidth(buf_.size(), 0));
+    WriteAny(stack_[0], byte_width);
+    // Write root type.
+    Write(stack_[0].StoredPackedType(), 1);
+    // Write root size. Normally determined by parent, but root has no parent :)
+    Write(byte_width, 1);
+
+    finished_ = true;
+  }
+
+ private:
+  void Finished() const {
+    // If you get this assert, you're attempting to get access a buffer
+    // which hasn't been finished yet. Be sure to call
+    // Builder::Finish with your root object.
+    FLATBUFFERS_ASSERT(finished_);
+  }
+
+  // Align to prepare for writing a scalar with a certain size.
+  uint8_t Align(BitWidth alignment) {
+    auto byte_width = 1U << alignment;
+    buf_.insert(buf_.end(), flatbuffers::PaddingBytes(buf_.size(), byte_width),
+                0);
+    return static_cast<uint8_t>(byte_width);
+  }
+
+  void WriteBytes(const void* val, size_t size) {
+    buf_.insert(buf_.end(), reinterpret_cast<const uint8_t*>(val),
+                reinterpret_cast<const uint8_t*>(val) + size);
+  }
+
+  template <typename T>
+  void Write(T val, size_t byte_width) {
+    FLATBUFFERS_ASSERT(sizeof(T) >= byte_width);
+    val = flatbuffers::EndianScalar(val);
+    WriteBytes(&val, byte_width);
+  }
+
+  void WriteDouble(double f, uint8_t byte_width) {
+    switch (byte_width) {
+      case 8:
+        Write(f, byte_width);
+        break;
+      case 4:
+        Write(static_cast<float>(f), byte_width);
+        break;
+      // case 2: Write(static_cast<half>(f), byte_width); break;
+      // case 1: Write(static_cast<quarter>(f), byte_width); break;
+      default:
+        FLATBUFFERS_ASSERT(0);
+    }
+  }
+
+  void WriteOffset(uint64_t o, uint8_t byte_width) {
+    auto reloff = buf_.size() - o;
+    FLATBUFFERS_ASSERT(byte_width == 8 || reloff < 1ULL << (byte_width * 8));
+    Write(reloff, byte_width);
+  }
+
+  template <typename T>
+  void PushIndirect(T val, Type type, BitWidth bit_width) {
+    auto byte_width = Align(bit_width);
+    auto iloc = buf_.size();
+    Write(val, byte_width);
+    stack_.push_back(Value(static_cast<uint64_t>(iloc), type, bit_width));
+  }
+
+  static BitWidth WidthB(size_t byte_width) {
+    switch (byte_width) {
+      case 1:
+        return BIT_WIDTH_8;
+      case 2:
+        return BIT_WIDTH_16;
+      case 4:
+        return BIT_WIDTH_32;
+      case 8:
+        return BIT_WIDTH_64;
+      default:
+        FLATBUFFERS_ASSERT(false);
+        return BIT_WIDTH_64;
+    }
+  }
+
+  template <typename T>
+  static Type GetScalarType() {
+    static_assert(flatbuffers::is_scalar<T>::value, "Unrelated types");
+    return flatbuffers::is_floating_point<T>::value ? FBT_FLOAT
+           : flatbuffers::is_same<T, bool>::value
+               ? FBT_BOOL
+               : (flatbuffers::is_unsigned<T>::value ? FBT_UINT : FBT_INT);
+  }
+
+ public:
+  // This was really intended to be private, except for LastValue/ReuseValue.
+  struct Value {
+    union {
+      int64_t i_;
+      uint64_t u_;
+      double f_;
+    };
+
+    Type type_;
+
+    // For scalars: of itself, for vector: of its elements, for string: length.
+    BitWidth min_bit_width_;
+
+    Value() : i_(0), type_(FBT_NULL), min_bit_width_(BIT_WIDTH_8) {}
+
+    Value(bool b)
+        : u_(static_cast<uint64_t>(b)),
+          type_(FBT_BOOL),
+          min_bit_width_(BIT_WIDTH_8) {}
+
+    Value(int64_t i, Type t, BitWidth bw)
+        : i_(i), type_(t), min_bit_width_(bw) {}
+    Value(uint64_t u, Type t, BitWidth bw)
+        : u_(u), type_(t), min_bit_width_(bw) {}
+
+    Value(float f)
+        : f_(static_cast<double>(f)),
+          type_(FBT_FLOAT),
+          min_bit_width_(BIT_WIDTH_32) {}
+    Value(double f) : f_(f), type_(FBT_FLOAT), min_bit_width_(WidthF(f)) {}
+
+    uint8_t StoredPackedType(BitWidth parent_bit_width_ = BIT_WIDTH_8) const {
+      return PackedType(StoredWidth(parent_bit_width_), type_);
+    }
+
+    BitWidth ElemWidth(size_t buf_size, size_t elem_index) const {
+      if (IsInline(type_)) {
+        return min_bit_width_;
+      } else {
+        // We have an absolute offset, but want to store a relative offset
+        // elem_index elements beyond the current buffer end. Since whether
+        // the relative offset fits in a certain byte_width depends on
+        // the size of the elements before it (and their alignment), we have
+        // to test for each size in turn.
+        for (size_t byte_width = 1;
+             byte_width <= sizeof(flatbuffers::largest_scalar_t);
+             byte_width *= 2) {
+          // Where are we going to write this offset?
+          auto offset_loc = buf_size +
+                            flatbuffers::PaddingBytes(buf_size, byte_width) +
+                            elem_index * byte_width;
+          // Compute relative offset.
+          auto offset = offset_loc - u_;
+          // Does it fit?
+          auto bit_width = WidthU(offset);
+          if (static_cast<size_t>(static_cast<size_t>(1U) << bit_width) ==
+              byte_width)
+            return bit_width;
+        }
+        FLATBUFFERS_ASSERT(false);  // Must match one of the sizes above.
+        return BIT_WIDTH_64;
+      }
+    }
+
+    BitWidth StoredWidth(BitWidth parent_bit_width_ = BIT_WIDTH_8) const {
+      if (IsInline(type_)) {
+        return (std::max)(min_bit_width_, parent_bit_width_);
+      } else {
+        return min_bit_width_;
+      }
+    }
+  };
+
+ private:
+  void WriteAny(const Value& val, uint8_t byte_width) {
+    switch (val.type_) {
+      case FBT_NULL:
+      case FBT_INT:
+        Write(val.i_, byte_width);
+        break;
+      case FBT_BOOL:
+      case FBT_UINT:
+        Write(val.u_, byte_width);
+        break;
+      case FBT_FLOAT:
+        WriteDouble(val.f_, byte_width);
+        break;
+      default:
+        WriteOffset(val.u_, byte_width);
+        break;
+    }
+  }
+
+  size_t CreateBlob(const void* data, size_t len, size_t trailing, Type type) {
+    auto bit_width = WidthU(len);
+    return CreateAlignedBlob(data, len, trailing, type, bit_width);
+  }
+
+  size_t CreateAlignedBlob(const void* data, size_t len, size_t trailing,
+                           Type type, BitWidth alignment) {
+    auto byte_width = Align(alignment);
+    Write<uint64_t>(len, byte_width);
+    auto sloc = buf_.size();
+    WriteBytes(data, len + trailing);
+    stack_.push_back(Value(static_cast<uint64_t>(sloc), type, alignment));
+    return sloc;
+  }
+
+  template <typename T>
+  size_t ScalarVector(const T* elems, size_t len, bool fixed) {
+    auto vector_type = GetScalarType<T>();
+    auto byte_width = sizeof(T);
+    auto bit_width = WidthB(byte_width);
+    // If you get this assert, you're trying to write a vector with a size
+    // field that is bigger than the scalars you're trying to write (e.g. a
+    // byte vector > 255 elements). For such types, write a "blob" instead.
+    // TODO: instead of asserting, could write vector with larger elements
+    // instead, though that would be wasteful.
+    FLATBUFFERS_ASSERT(WidthU(len) <= bit_width);
+    Align(bit_width);
+    if (!fixed) Write<uint64_t>(len, byte_width);
+    auto vloc = buf_.size();
+    for (size_t i = 0; i < len; i++) Write(elems[i], byte_width);
+    stack_.push_back(Value(static_cast<uint64_t>(vloc),
+                           ToTypedVector(vector_type, fixed ? len : 0),
+                           bit_width));
+    return vloc;
+  }
+
+  Value CreateVector(size_t start, size_t vec_len, size_t step, bool typed,
+                     bool fixed, const Value* keys = nullptr) {
+    FLATBUFFERS_ASSERT(
+        !fixed ||
+        typed);  // typed=false, fixed=true combination is not supported.
+    // Figure out smallest bit width we can store this vector with.
+    auto bit_width = (std::max)(force_min_bit_width_, WidthU(vec_len));
+    auto prefix_elems = 1;
+    if (keys) {
+      // If this vector is part of a map, we will pre-fix an offset to the keys
+      // to this vector.
+      bit_width = (std::max)(bit_width, keys->ElemWidth(buf_.size(), 0));
+      prefix_elems += 2;
+    }
+    Type vector_type = FBT_KEY;
+    // Check bit widths and types for all elements.
+    for (size_t i = start; i < stack_.size(); i += step) {
+      auto elem_width =
+          stack_[i].ElemWidth(buf_.size(), i - start + prefix_elems);
+      bit_width = (std::max)(bit_width, elem_width);
+      if (typed) {
+        if (i == start) {
+          vector_type = stack_[i].type_;
+        } else {
+          // If you get this assert, you are writing a typed vector with
+          // elements that are not all the same type.
+          FLATBUFFERS_ASSERT(vector_type == stack_[i].type_);
+        }
+      }
+    }
+    // If you get this assert, your typed types are not one of:
+    // Int / UInt / Float / Key.
+    FLATBUFFERS_ASSERT(!typed || IsTypedVectorElementType(vector_type));
+    auto byte_width = Align(bit_width);
+    // Write vector. First the keys width/offset if available, and size.
+    if (keys) {
+      WriteOffset(keys->u_, byte_width);
+      Write<uint64_t>(1ULL << keys->min_bit_width_, byte_width);
+    }
+    if (!fixed) Write<uint64_t>(vec_len, byte_width);
+    // Then the actual data.
+    auto vloc = buf_.size();
+    for (size_t i = start; i < stack_.size(); i += step) {
+      WriteAny(stack_[i], byte_width);
+    }
+    // Then the types.
+    if (!typed) {
+      for (size_t i = start; i < stack_.size(); i += step) {
+        buf_.push_back(stack_[i].StoredPackedType(bit_width));
+      }
+    }
+    return Value(static_cast<uint64_t>(vloc),
+                 keys ? FBT_MAP
+                      : (typed ? ToTypedVector(vector_type, fixed ? vec_len : 0)
+                               : FBT_VECTOR),
+                 bit_width);
+  }
+
+  // You shouldn't really be copying instances of this class.
+  Builder(const Builder&);
+  Builder& operator=(const Builder&);
+
+  std::vector<uint8_t> buf_;
+  std::vector<Value> stack_;
+
+  bool finished_;
+  bool has_duplicate_keys_;
+
+  BuilderFlag flags_;
+
+  BitWidth force_min_bit_width_;
+
+  struct KeyOffsetCompare {
+    explicit KeyOffsetCompare(const std::vector<uint8_t>& buf) : buf_(&buf) {}
+    bool operator()(size_t a, size_t b) const {
+      auto stra = reinterpret_cast<const char*>(buf_->data() + a);
+      auto strb = reinterpret_cast<const char*>(buf_->data() + b);
+      return strcmp(stra, strb) < 0;
+    }
+    const std::vector<uint8_t>* buf_;
+  };
+
+  typedef std::pair<size_t, size_t> StringOffset;
+  struct StringOffsetCompare {
+    explicit StringOffsetCompare(const std::vector<uint8_t>& buf)
+        : buf_(&buf) {}
+    bool operator()(const StringOffset& a, const StringOffset& b) const {
+      auto stra = buf_->data() + a.first;
+      auto strb = buf_->data() + b.first;
+      auto cr = memcmp(stra, strb, (std::min)(a.second, b.second) + 1);
+      return cr < 0 || (cr == 0 && a.second < b.second);
+    }
+    const std::vector<uint8_t>* buf_;
+  };
+
+  typedef std::set<size_t, KeyOffsetCompare> KeyOffsetMap;
+  typedef std::set<StringOffset, StringOffsetCompare> StringOffsetMap;
+
+  KeyOffsetMap key_pool;
+  StringOffsetMap string_pool;
+
+  friend class Verifier;
+};
+
+// Helper class to verify the integrity of a FlexBuffer
+class Verifier FLATBUFFERS_FINAL_CLASS {
+ public:
+  Verifier(const uint8_t* buf, size_t buf_len,
+           // Supplying this vector likely results in faster verification
+           // of larger buffers with many shared keys/strings, but
+           // comes at the cost of using additional memory the same size of
+           // the buffer being verified, so it is by default off.
+           std::vector<uint8_t>* reuse_tracker = nullptr,
+           bool _check_alignment = true, size_t max_depth = 64)
+      : buf_(buf),
+        size_(buf_len),
+        depth_(0),
+        max_depth_(max_depth),
+        num_vectors_(0),
+        max_vectors_(buf_len),
+        check_alignment_(_check_alignment),
+        reuse_tracker_(reuse_tracker) {
+    FLATBUFFERS_ASSERT(static_cast<int32_t>(size_) <
+                       FLATBUFFERS_MAX_BUFFER_SIZE);
+    if (reuse_tracker_) {
+      reuse_tracker_->clear();
+      reuse_tracker_->resize(size_, PackedType(BIT_WIDTH_8, FBT_NULL));
+    }
+  }
+
+ private:
+  // Central location where any verification failures register.
+  bool Check(bool ok) const {
+    // clang-format off
+    #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
+      FLATBUFFERS_ASSERT(ok);
+    #endif
+    // clang-format on
+    return ok;
+  }
+
+  // Verify any range within the buffer.
+  bool VerifyFrom(size_t elem, size_t elem_len) const {
+    return Check(elem_len < size_ && elem <= size_ - elem_len);
+  }
+  bool VerifyBefore(size_t elem, size_t elem_len) const {
+    return Check(elem_len <= elem);
+  }
+
+  bool VerifyFromPointer(const uint8_t* p, size_t len) {
+    auto o = static_cast<size_t>(p - buf_);
+    return VerifyFrom(o, len);
+  }
+  bool VerifyBeforePointer(const uint8_t* p, size_t len) {
+    auto o = static_cast<size_t>(p - buf_);
+    return VerifyBefore(o, len);
+  }
+
+  bool VerifyByteWidth(size_t width) {
+    return Check(width == 1 || width == 2 || width == 4 || width == 8);
+  }
+
+  bool VerifyType(int type) { return Check(type >= 0 && type < FBT_MAX_TYPE); }
+
+  bool VerifyOffset(uint64_t off, const uint8_t* p) {
+    return Check(off <= static_cast<uint64_t>(size_)) &&
+           off <= static_cast<uint64_t>(p - buf_);
+  }
+
+  bool VerifyAlignment(const uint8_t* p, size_t size) const {
+    auto o = static_cast<size_t>(p - buf_);
+    return Check((o & (size - 1)) == 0 || !check_alignment_);
+  }
+
+// Macro, since we want to escape from parent function & use lazy args.
+#define FLEX_CHECK_VERIFIED(P, PACKED_TYPE)                     \
+  if (reuse_tracker_) {                                         \
+    auto packed_type = PACKED_TYPE;                             \
+    auto existing = (*reuse_tracker_)[P - buf_];                \
+    if (existing == packed_type) return true;                   \
+    /* Fail verification if already set with different type! */ \
+    if (!Check(existing == 0)) return false;                    \
+    (*reuse_tracker_)[P - buf_] = packed_type;                  \
+  }
+
+  bool VerifyVector(Reference r, const uint8_t* p, Type elem_type) {
+    // Any kind of nesting goes thru this function, so guard against that
+    // here, both with simple nesting checks, and the reuse tracker if on.
+    depth_++;
+    num_vectors_++;
+    if (!Check(depth_ <= max_depth_ && num_vectors_ <= max_vectors_))
+      return false;
+    auto size_byte_width = r.byte_width_;
+    if (!VerifyBeforePointer(p, size_byte_width)) return false;
+    FLEX_CHECK_VERIFIED(p - size_byte_width,
+                        PackedType(Builder::WidthB(size_byte_width), r.type_));
+    auto sized = Sized(p, size_byte_width);
+    auto num_elems = sized.size();
+    auto elem_byte_width = r.type_ == FBT_STRING || r.type_ == FBT_BLOB
+                               ? uint8_t(1)
+                               : r.byte_width_;
+    auto max_elems = SIZE_MAX / elem_byte_width;
+    if (!Check(num_elems < max_elems))
+      return false;  // Protect against byte_size overflowing.
+    auto byte_size = num_elems * elem_byte_width;
+    if (!VerifyFromPointer(p, byte_size)) return false;
+    if (elem_type == FBT_NULL) {
+      // Verify type bytes after the vector.
+      if (!VerifyFromPointer(p + byte_size, num_elems)) return false;
+      auto v = Vector(p, size_byte_width);
+      for (size_t i = 0; i < num_elems; i++)
+        if (!VerifyRef(v[i])) return false;
+    } else if (elem_type == FBT_KEY) {
+      auto v = TypedVector(p, elem_byte_width, FBT_KEY);
+      for (size_t i = 0; i < num_elems; i++)
+        if (!VerifyRef(v[i])) return false;
+    } else {
+      FLATBUFFERS_ASSERT(IsInline(elem_type));
+    }
+    depth_--;
+    return true;
+  }
+
+  bool VerifyKeys(const uint8_t* p, uint8_t byte_width) {
+    // The vector part of the map has already been verified.
+    const size_t num_prefixed_fields = 3;
+    if (!VerifyBeforePointer(p, byte_width * num_prefixed_fields)) return false;
+    p -= byte_width * num_prefixed_fields;
+    auto off = ReadUInt64(p, byte_width);
+    if (!VerifyOffset(off, p)) return false;
+    auto key_byte_with =
+        static_cast<uint8_t>(ReadUInt64(p + byte_width, byte_width));
+    if (!VerifyByteWidth(key_byte_with)) return false;
+    return VerifyVector(Reference(p, byte_width, key_byte_with, FBT_VECTOR_KEY),
+                        p - off, FBT_KEY);
+  }
+
+  bool VerifyKey(const uint8_t* p) {
+    FLEX_CHECK_VERIFIED(p, PackedType(BIT_WIDTH_8, FBT_KEY));
+    while (p < buf_ + size_)
+      if (!*p++) return true;
+    return false;
+  }
+
+#undef FLEX_CHECK_VERIFIED
+
+  bool VerifyTerminator(const String& s) {
+    return VerifyFromPointer(reinterpret_cast<const uint8_t*>(s.c_str()),
+                             s.size() + 1);
+  }
+
+  bool VerifyRef(Reference r) {
+    // r.parent_width_ and r.data_ already verified.
+    if (!VerifyByteWidth(r.byte_width_) || !VerifyType(r.type_)) {
+      return false;
+    }
+    if (IsInline(r.type_)) {
+      // Inline scalars, don't require further verification.
+      return true;
+    }
+    // All remaining types are an offset.
+    auto off = ReadUInt64(r.data_, r.parent_width_);
+    if (!VerifyOffset(off, r.data_)) return false;
+    auto p = r.Indirect();
+    if (!VerifyAlignment(p, r.byte_width_)) return false;
+    switch (r.type_) {
+      case FBT_INDIRECT_INT:
+      case FBT_INDIRECT_UINT:
+      case FBT_INDIRECT_FLOAT:
+        return VerifyFromPointer(p, r.byte_width_);
+      case FBT_KEY:
+        return VerifyKey(p);
+      case FBT_MAP:
+        return VerifyVector(r, p, FBT_NULL) && VerifyKeys(p, r.byte_width_);
+      case FBT_VECTOR:
+        return VerifyVector(r, p, FBT_NULL);
+      case FBT_VECTOR_INT:
+        return VerifyVector(r, p, FBT_INT);
+      case FBT_VECTOR_BOOL:
+      case FBT_VECTOR_UINT:
+        return VerifyVector(r, p, FBT_UINT);
+      case FBT_VECTOR_FLOAT:
+        return VerifyVector(r, p, FBT_FLOAT);
+      case FBT_VECTOR_KEY:
+        return VerifyVector(r, p, FBT_KEY);
+      case FBT_VECTOR_STRING_DEPRECATED:
+        // Use of FBT_KEY here intentional, see elsewhere.
+        return VerifyVector(r, p, FBT_KEY);
+      case FBT_BLOB:
+        return VerifyVector(r, p, FBT_UINT);
+      case FBT_STRING:
+        return VerifyVector(r, p, FBT_UINT) &&
+               VerifyTerminator(String(p, r.byte_width_));
+      case FBT_VECTOR_INT2:
+      case FBT_VECTOR_UINT2:
+      case FBT_VECTOR_FLOAT2:
+      case FBT_VECTOR_INT3:
+      case FBT_VECTOR_UINT3:
+      case FBT_VECTOR_FLOAT3:
+      case FBT_VECTOR_INT4:
+      case FBT_VECTOR_UINT4:
+      case FBT_VECTOR_FLOAT4: {
+        uint8_t len = 0;
+        auto vtype = ToFixedTypedVectorElementType(r.type_, &len);
+        if (!VerifyType(vtype)) return false;
+        return VerifyFromPointer(p, static_cast<size_t>(r.byte_width_) * len);
+      }
+      default:
+        return false;
+    }
+  }
+
+ public:
+  bool VerifyBuffer() {
+    if (!Check(size_ >= 3)) return false;
+    auto end = buf_ + size_;
+    auto byte_width = *--end;
+    auto packed_type = *--end;
+    return VerifyByteWidth(byte_width) && Check(end - buf_ >= byte_width) &&
+           VerifyRef(Reference(end - byte_width, byte_width, packed_type));
+  }
+
+ private:
+  const uint8_t* buf_;
+  size_t size_;
+  size_t depth_;
+  const size_t max_depth_;
+  size_t num_vectors_;
+  const size_t max_vectors_;
+  bool check_alignment_;
+  std::vector<uint8_t>* reuse_tracker_;
+};
+
+// Utility function that constructs the Verifier for you, see above for
+// parameters.
+inline bool VerifyBuffer(const uint8_t* buf, size_t buf_len,
+                         std::vector<uint8_t>* reuse_tracker = nullptr) {
+  Verifier verifier(buf, buf_len, reuse_tracker);
+  return verifier.VerifyBuffer();
+}
+
+}  // namespace flexbuffers
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#endif  // FLATBUFFERS_FLEXBUFFERS_H_
diff --git a/external/flatbuffers/include/flatbuffers/grpc.h b/external/flatbuffers/include/flatbuffers/grpc.h
new file mode 100644
index 00000000..74633fd6
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/grpc.h
@@ -0,0 +1,303 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_GRPC_H_
+#define FLATBUFFERS_GRPC_H_
+
+// Helper functionality to glue FlatBuffers and GRPC.
+
+#include "flatbuffers/flatbuffers.h"
+#include "grpcpp/support/byte_buffer.h"
+#include "grpcpp/support/slice.h"
+
+namespace flatbuffers {
+namespace grpc {
+
+// Message is a typed wrapper around a buffer that manages the underlying
+// `grpc_slice` and also provides flatbuffers-specific helpers such as `Verify`
+// and `GetRoot`. Since it is backed by a `grpc_slice`, the underlying buffer
+// is refcounted and ownership is be managed automatically.
+template <class T>
+class Message {
+ public:
+  Message() {}
+
+  Message(::grpc::Slice slice) : slice_(slice) {}
+
+  Message& operator=(const Message& other) = delete;
+
+  Message(Message&& other) = default;
+
+  Message(const Message& other) = delete;
+
+  Message& operator=(Message&& other) = default;
+
+  const uint8_t* mutable_data() const { return slice_.begin(); }
+
+  const uint8_t* data() const { return slice_.begin(); }
+
+  size_t size() const { return slice_.size(); }
+
+  bool Verify() const {
+    Verifier verifier(data(), size());
+    return verifier.VerifyBuffer<T>(nullptr);
+  }
+
+  T* GetMutableRoot() { return flatbuffers::GetMutableRoot<T>(mutable_data()); }
+
+  const T* GetRoot() const { return flatbuffers::GetRoot<T>(data()); }
+
+  // This is only intended for serializer use, or if you know what you're doing
+  const ::grpc::Slice& BorrowSlice() const { return slice_; }
+
+ private:
+  ::grpc::Slice slice_;
+};
+
+class MessageBuilder;
+
+// SliceAllocator is a gRPC-specific allocator that uses the `grpc_slice`
+// refcounted slices to manage memory ownership. This makes it easy and
+// efficient to transfer buffers to gRPC.
+class SliceAllocator : public Allocator {
+ public:
+  SliceAllocator() {}
+
+  SliceAllocator(const SliceAllocator& other) = delete;
+  SliceAllocator& operator=(const SliceAllocator& other) = delete;
+
+  SliceAllocator(SliceAllocator&& other) {
+    // default-construct and swap idiom
+    swap(other);
+  }
+
+  SliceAllocator& operator=(SliceAllocator&& other) {
+    // move-construct and swap idiom
+    SliceAllocator temp(std::move(other));
+    swap(temp);
+    return *this;
+  }
+
+  void swap(SliceAllocator& other) {
+    using std::swap;
+    swap(slice_, other.slice_);
+  }
+
+  virtual ~SliceAllocator() {}
+
+  virtual uint8_t* allocate(size_t size) override {
+    FLATBUFFERS_ASSERT(slice_.size() == 0);
+    slice_ = ::grpc::Slice(size);
+    return const_cast<uint8_t*>(slice_.begin());
+  }
+
+  virtual void deallocate(uint8_t* p, size_t size) override {
+    FLATBUFFERS_ASSERT(p == slice_.begin());
+    FLATBUFFERS_ASSERT(size == slice_.size());
+    slice_ = ::grpc::Slice();
+  }
+
+  virtual uint8_t* reallocate_downward(uint8_t* old_p, size_t old_size,
+                                       size_t new_size, size_t in_use_back,
+                                       size_t in_use_front) override {
+    FLATBUFFERS_ASSERT(old_p == slice_.begin());
+    FLATBUFFERS_ASSERT(old_size == slice_.size());
+    FLATBUFFERS_ASSERT(new_size > old_size);
+    ::grpc::Slice old_slice = slice_;
+    ::grpc::Slice new_slice = ::grpc::Slice(new_size);
+    uint8_t* new_p = const_cast<uint8_t*>(new_slice.begin());
+    memcpy_downward(old_p, old_size, new_p, new_size, in_use_back,
+                    in_use_front);
+    slice_ = new_slice;
+    return const_cast<uint8_t*>(slice_.begin());
+  }
+
+ private:
+  ::grpc::Slice& get_slice(uint8_t* p, size_t size) {
+    FLATBUFFERS_ASSERT(p == slice_.begin());
+    FLATBUFFERS_ASSERT(size == slice_.size());
+    return slice_;
+  }
+
+  ::grpc::Slice slice_;
+
+  friend class MessageBuilder;
+};
+
+// SliceAllocatorMember is a hack to ensure that the MessageBuilder's
+// slice_allocator_ member is constructed before the FlatBufferBuilder, since
+// the allocator is used in the FlatBufferBuilder ctor.
+namespace detail {
+struct SliceAllocatorMember {
+  SliceAllocator slice_allocator_;
+};
+}  // namespace detail
+
+// MessageBuilder is a gRPC-specific FlatBufferBuilder that uses SliceAllocator
+// to allocate gRPC buffers.
+class MessageBuilder : private detail::SliceAllocatorMember,
+                       public FlatBufferBuilder {
+ public:
+  explicit MessageBuilder(uoffset_t initial_size = 1024)
+      : FlatBufferBuilder(initial_size, &slice_allocator_, false) {}
+
+  MessageBuilder(const MessageBuilder& other) = delete;
+  MessageBuilder& operator=(const MessageBuilder& other) = delete;
+
+  MessageBuilder(MessageBuilder&& other)
+      : FlatBufferBuilder(1024, &slice_allocator_, false) {
+    // Default construct and swap idiom.
+    Swap(other);
+  }
+
+  /// Create a MessageBuilder from a FlatBufferBuilder.
+  explicit MessageBuilder(FlatBufferBuilder&& src,
+                          void (*dealloc)(void*,
+                                          size_t) = &DefaultAllocator::dealloc)
+      : FlatBufferBuilder(1024, &slice_allocator_, false) {
+    src.Swap(*this);
+    src.SwapBufAllocator(*this);
+    if (buf_.capacity()) {
+      uint8_t* buf = buf_.scratch_data();  // pointer to memory
+      size_t capacity = buf_.capacity();   // size of memory
+      slice_allocator_.slice_ = ::grpc::Slice(buf, capacity, dealloc);
+    } else {
+      slice_allocator_.slice_ = ::grpc::Slice();
+    }
+  }
+
+  /// Move-assign a FlatBufferBuilder to a MessageBuilder.
+  /// Only FlatBufferBuilder with default allocator (basically, nullptr) is
+  /// supported.
+  MessageBuilder& operator=(FlatBufferBuilder&& src) {
+    // Move construct a temporary and swap
+    MessageBuilder temp(std::move(src));
+    Swap(temp);
+    return *this;
+  }
+
+  MessageBuilder& operator=(MessageBuilder&& other) {
+    // Move construct a temporary and swap
+    MessageBuilder temp(std::move(other));
+    Swap(temp);
+    return *this;
+  }
+
+  void Swap(MessageBuilder& other) {
+    slice_allocator_.swap(other.slice_allocator_);
+    FlatBufferBuilder::Swap(other);
+    // After swapping the FlatBufferBuilder, we swap back the allocator, which
+    // restores the original allocator back in place. This is necessary because
+    // MessageBuilder's allocator is its own member (SliceAllocatorMember). The
+    // allocator passed to FlatBufferBuilder::vector_downward must point to this
+    // member.
+    buf_.swap_allocator(other.buf_);
+  }
+
+  // Releases the ownership of the buffer pointer.
+  // Returns the size, offset, and the original grpc_slice that
+  // allocated the buffer. Also see grpc_slice_unref().
+  uint8_t* ReleaseRaw(size_t& size, size_t& offset, ::grpc::Slice& slice) {
+    uint8_t* buf = FlatBufferBuilder::ReleaseRaw(size, offset);
+    slice = slice_allocator_.slice_;
+    slice_allocator_.slice_ = ::grpc::Slice();
+    return buf;
+  }
+
+  ~MessageBuilder() {}
+
+  // GetMessage extracts the subslice of the buffer corresponding to the
+  // flatbuffers-encoded region and wraps it in a `Message<T>` to handle buffer
+  // ownership.
+  template <class T>
+  Message<T> GetMessage() {
+    auto buf_data = buf_.scratch_data();  // pointer to memory
+    auto buf_size = buf_.capacity();      // size of memory
+    auto msg_data = buf_.data();          // pointer to msg
+    auto msg_size = buf_.size();          // size of msg
+    // Do some sanity checks on data/size
+    FLATBUFFERS_ASSERT(msg_data);
+    FLATBUFFERS_ASSERT(msg_size);
+    FLATBUFFERS_ASSERT(msg_data >= buf_data);
+    FLATBUFFERS_ASSERT(msg_data + msg_size <= buf_data + buf_size);
+    // Calculate offsets from the buffer start
+    auto begin = msg_data - buf_data;
+    auto end = begin + msg_size;
+    // Get the slice we are working with (no refcount change)
+    ::grpc::Slice slice = slice_allocator_.get_slice(buf_data, buf_size);
+    // Extract a subslice of the existing slice (increment refcount)
+    ::grpc::Slice subslice = slice.sub(begin, end);
+    // Wrap the subslice in a `Message<T>`, but don't increment refcount
+    Message<T> msg(subslice);
+    return msg;
+  }
+
+  template <class T>
+  Message<T> ReleaseMessage() {
+    Message<T> msg = GetMessage<T>();
+    Reset();
+    return msg;
+  }
+
+ private:
+  // SliceAllocator slice_allocator_;  // part of SliceAllocatorMember
+};
+
+}  // namespace grpc
+}  // namespace flatbuffers
+
+namespace grpc {
+
+template <class T>
+class SerializationTraits<flatbuffers::grpc::Message<T>> {
+ public:
+  static grpc::Status Serialize(const flatbuffers::grpc::Message<T>& msg,
+                                ByteBuffer* buffer, bool* own_buffer) {
+    // Package the single slice into a `ByteBuffer`,
+    // incrementing the refcount in the process.
+    *buffer = ByteBuffer(&msg.BorrowSlice(), 1);
+    *own_buffer = true;
+    return grpc::Status::OK;
+  }
+
+  // Deserialize by pulling the
+  static grpc::Status Deserialize(ByteBuffer* buf,
+                                  flatbuffers::grpc::Message<T>* msg) {
+    Slice slice;
+    if (!buf->TrySingleSlice(&slice).ok()) {
+      if (!buf->DumpToSingleSlice(&slice).ok()) {
+        buf->Clear();
+        return ::grpc::Status(::grpc::StatusCode::INTERNAL, "No payload");
+      }
+    }
+    *msg = flatbuffers::grpc::Message<T>(slice);
+    buf->Clear();
+#if FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION
+    return ::grpc::Status::OK;
+#else
+    if (msg->Verify()) {
+      return ::grpc::Status::OK;
+    } else {
+      return ::grpc::Status(::grpc::StatusCode::INTERNAL,
+                            "Message verification failed");
+    }
+#endif
+  }
+};
+
+}  // namespace grpc
+
+#endif  // FLATBUFFERS_GRPC_H_
diff --git a/external/flatbuffers/include/flatbuffers/hash.h b/external/flatbuffers/include/flatbuffers/hash.h
new file mode 100644
index 00000000..2e92c09a
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/hash.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2015 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_HASH_H_
+#define FLATBUFFERS_HASH_H_
+
+#include <cstdint>
+#include <cstring>
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace flatbuffers {
+
+template <typename T>
+struct FnvTraits {
+  static const T kFnvPrime;
+  static const T kOffsetBasis;
+};
+
+template <>
+struct FnvTraits<uint32_t> {
+  static const uint32_t kFnvPrime = 0x01000193;
+  static const uint32_t kOffsetBasis = 0x811C9DC5;
+};
+
+template <>
+struct FnvTraits<uint64_t> {
+  static const uint64_t kFnvPrime = 0x00000100000001b3ULL;
+  static const uint64_t kOffsetBasis = 0xcbf29ce484222645ULL;
+};
+
+template <typename T>
+T HashFnv1(const char* input) {
+  T hash = FnvTraits<T>::kOffsetBasis;
+  for (const char* c = input; *c; ++c) {
+    hash *= FnvTraits<T>::kFnvPrime;
+    hash ^= static_cast<unsigned char>(*c);
+  }
+  return hash;
+}
+
+template <typename T>
+T HashFnv1a(const char* input) {
+  T hash = FnvTraits<T>::kOffsetBasis;
+  for (const char* c = input; *c; ++c) {
+    hash ^= static_cast<unsigned char>(*c);
+    hash *= FnvTraits<T>::kFnvPrime;
+  }
+  return hash;
+}
+
+template <>
+inline uint16_t HashFnv1<uint16_t>(const char* input) {
+  uint32_t hash = HashFnv1<uint32_t>(input);
+  return (hash >> 16) ^ (hash & 0xffff);
+}
+
+template <>
+inline uint16_t HashFnv1a<uint16_t>(const char* input) {
+  uint32_t hash = HashFnv1a<uint32_t>(input);
+  return (hash >> 16) ^ (hash & 0xffff);
+}
+
+template <typename T>
+struct NamedHashFunction {
+  const char* name;
+
+  typedef T (*HashFunction)(const char*);
+  HashFunction function;
+};
+
+const NamedHashFunction<uint16_t> kHashFunctions16[] = {
+    {"fnv1_16", HashFnv1<uint16_t>},
+    {"fnv1a_16", HashFnv1a<uint16_t>},
+};
+
+const NamedHashFunction<uint32_t> kHashFunctions32[] = {
+    {"fnv1_32", HashFnv1<uint32_t>},
+    {"fnv1a_32", HashFnv1a<uint32_t>},
+};
+
+const NamedHashFunction<uint64_t> kHashFunctions64[] = {
+    {"fnv1_64", HashFnv1<uint64_t>},
+    {"fnv1a_64", HashFnv1a<uint64_t>},
+};
+
+inline NamedHashFunction<uint16_t>::HashFunction FindHashFunction16(
+    const char* name) {
+  std::size_t size = sizeof(kHashFunctions16) / sizeof(kHashFunctions16[0]);
+  for (std::size_t i = 0; i < size; ++i) {
+    if (std::strcmp(name, kHashFunctions16[i].name) == 0) {
+      return kHashFunctions16[i].function;
+    }
+  }
+  return nullptr;
+}
+
+inline NamedHashFunction<uint32_t>::HashFunction FindHashFunction32(
+    const char* name) {
+  std::size_t size = sizeof(kHashFunctions32) / sizeof(kHashFunctions32[0]);
+  for (std::size_t i = 0; i < size; ++i) {
+    if (std::strcmp(name, kHashFunctions32[i].name) == 0) {
+      return kHashFunctions32[i].function;
+    }
+  }
+  return nullptr;
+}
+
+inline NamedHashFunction<uint64_t>::HashFunction FindHashFunction64(
+    const char* name) {
+  std::size_t size = sizeof(kHashFunctions64) / sizeof(kHashFunctions64[0]);
+  for (std::size_t i = 0; i < size; ++i) {
+    if (std::strcmp(name, kHashFunctions64[i].name) == 0) {
+      return kHashFunctions64[i].function;
+    }
+  }
+  return nullptr;
+}
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_HASH_H_
diff --git a/external/flatbuffers/include/flatbuffers/idl.h b/external/flatbuffers/include/flatbuffers/idl.h
new file mode 100644
index 00000000..9e58d4be
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/idl.h
@@ -0,0 +1,1329 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_IDL_H_
+#define FLATBUFFERS_IDL_H_
+
+#include <algorithm>
+#include <functional>
+#include <map>
+#include <memory>
+#include <stack>
+#include <vector>
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/file_manager.h"
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/flexbuffers.h"
+#include "flatbuffers/hash.h"
+#include "flatbuffers/reflection.h"
+
+// This file defines the data types representing a parsed IDL (Interface
+// Definition Language) / schema file.
+
+// Limits maximum depth of nested objects.
+// Prevents stack overflow while parse scheme, or json, or flexbuffer.
+#if !defined(FLATBUFFERS_MAX_PARSING_DEPTH)
+#define FLATBUFFERS_MAX_PARSING_DEPTH 64
+#endif
+
+namespace flatbuffers {
+
+// The order of these matters for Is*() functions below.
+// Additionally, Parser::ParseType assumes bool..string is a contiguous range
+// of type tokens.
+// clang-format off
+#define FLATBUFFERS_GEN_TYPES_SCALAR(TD) \
+  TD(NONE,     "",       uint8_t,  byte,   byte,    byte,   uint8,   u8,   UByte, UInt8, 0) \
+  TD(UTYPE,    "",       uint8_t,  byte,   byte,    byte,   uint8,   u8,   UByte, UInt8, 1) /* begin scalar/int */ \
+  TD(BOOL,     "bool",   uint8_t,  boolean,bool,    bool,   bool,    bool, Boolean, Bool, 2) \
+  TD(CHAR,     "byte",   int8_t,   byte,   int8,    sbyte,  int8,    i8,   Byte, Int8, 3) \
+  TD(UCHAR,    "ubyte",  uint8_t,  byte,   byte,    byte,   uint8,   u8,   UByte, UInt8, 4) \
+  TD(SHORT,    "short",  int16_t,  short,  int16,   short,  int16,   i16,  Short, Int16, 5) \
+  TD(USHORT,   "ushort", uint16_t, short,  uint16,  ushort, uint16,  u16,  UShort, UInt16, 6) \
+  TD(INT,      "int",    int32_t,  int,    int32,   int,    int32,   i32,  Int, Int32, 7) \
+  TD(UINT,     "uint",   uint32_t, int,    uint32,  uint,   uint32,  u32,  UInt, UInt32, 8) \
+  TD(LONG,     "long",   int64_t,  long,   int64,   long,   int64,   i64,  Long, Int64, 9) \
+  TD(ULONG,    "ulong",  uint64_t, long,   uint64,  ulong,  uint64,  u64,  ULong, UInt64, 10) /* end int */ \
+  TD(FLOAT,    "float",  float,    float,  float32, float,  float32, f32,  Float, Float32, 11) /* begin float */ \
+  TD(DOUBLE,   "double", double,   double, float64, double, float64, f64,  Double, Double, 12) /* end float/scalar */
+#define FLATBUFFERS_GEN_TYPES_POINTER(TD) \
+  TD(STRING,   "string", Offset<void>,   int, int, StringOffset, int, unused, Int, Offset<String>, 13) \
+  TD(VECTOR,   "",       Offset<void>,   int, int, VectorOffset, int, unused, Int, Offset<UOffset>, 14) \
+  TD(VECTOR64, "",       Offset64<void>, int, int, VectorOffset, int, unused, Int, Offset<UOffset>, 18) \
+  TD(STRUCT,   "",       Offset<void>,   int, int, int,          int, unused, Int, Offset<UOffset>, 15) \
+  TD(UNION,    "",       Offset<void>,   int, int, int,          int, unused, Int, Offset<UOffset>, 16)
+#define FLATBUFFERS_GEN_TYPE_ARRAY(TD) \
+  TD(ARRAY,    "",       int,            int, int, int,          int, unused, Int, Offset<UOffset>, 17)
+// The fields are:
+// - enum
+// - FlatBuffers schema type.
+// - C++ type.
+// - Java type.
+// - Go type.
+// - C# / .Net type.
+// - Python type.
+// - Kotlin type.
+// - Rust type.
+// - Swift type.
+// - enum value (matches the reflected values)
+
+// using these macros, we can now write code dealing with types just once, e.g.
+
+/*
+switch (type) {
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, \
+                         RTYPE, KTYPE, STYPE, ...) \
+    case BASE_TYPE_ ## ENUM: \
+      // do something specific to CTYPE here
+    FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
+  #undef FLATBUFFERS_TD
+}
+*/
+
+// If not all FLATBUFFERS_GEN_() arguments are necessary for implementation
+// of FLATBUFFERS_TD, you can use a variadic macro (with __VA_ARGS__ if needed).
+// In the above example, only CTYPE is used to generate the code, it can be rewritten:
+
+/*
+switch (type) {
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
+    case BASE_TYPE_ ## ENUM: \
+      // do something specific to CTYPE here
+    FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
+  #undef FLATBUFFERS_TD
+}
+*/
+
+#define FLATBUFFERS_GEN_TYPES(TD) \
+        FLATBUFFERS_GEN_TYPES_SCALAR(TD) \
+        FLATBUFFERS_GEN_TYPES_POINTER(TD) \
+        FLATBUFFERS_GEN_TYPE_ARRAY(TD)
+
+// Create an enum for all the types above.
+#ifdef __GNUC__
+__extension__  // Stop GCC complaining about trailing comma with -Wpendantic.
+#endif
+enum BaseType {
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, \
+              CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE, STYPE, ENUM_VALUE) \
+    BASE_TYPE_ ## ENUM = ENUM_VALUE,
+    FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
+  #undef FLATBUFFERS_TD
+};
+
+#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
+  static_assert(sizeof(CTYPE) <= sizeof(largest_scalar_t), \
+                "define largest_scalar_t as " #CTYPE);
+  FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
+#undef FLATBUFFERS_TD
+
+inline bool IsScalar (BaseType t) { return t >= BASE_TYPE_UTYPE &&
+                                           t <= BASE_TYPE_DOUBLE; }
+inline bool IsInteger(BaseType t) { return t >= BASE_TYPE_UTYPE &&
+                                           t <= BASE_TYPE_ULONG; }
+inline bool IsFloat  (BaseType t) { return t == BASE_TYPE_FLOAT ||
+                                           t == BASE_TYPE_DOUBLE; }
+inline bool IsLong   (BaseType t) { return t == BASE_TYPE_LONG ||
+                                           t == BASE_TYPE_ULONG; }
+inline bool IsBool   (BaseType t) { return t == BASE_TYPE_BOOL; }
+inline bool IsOneByte(BaseType t) { return t >= BASE_TYPE_UTYPE &&
+                                           t <= BASE_TYPE_UCHAR; }
+inline bool IsVector (BaseType t) { return t == BASE_TYPE_VECTOR ||
+                                           t == BASE_TYPE_VECTOR64; }
+
+inline bool IsUnsigned(BaseType t) {
+  return (t == BASE_TYPE_UTYPE)  || (t == BASE_TYPE_UCHAR) ||
+         (t == BASE_TYPE_USHORT) || (t == BASE_TYPE_UINT)  ||
+         (t == BASE_TYPE_ULONG);
+}
+
+inline size_t SizeOf(const BaseType t) {
+  switch (t) {
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
+    case BASE_TYPE_##ENUM: return sizeof(CTYPE);
+      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
+  #undef FLATBUFFERS_TD
+    default: FLATBUFFERS_ASSERT(0);
+  }
+  return 0;
+}
+
+inline const char* TypeName(const BaseType t) {
+  switch (t) {
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, ...) \
+    case BASE_TYPE_##ENUM: return IDLTYPE;
+      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
+  #undef FLATBUFFERS_TD
+    default: FLATBUFFERS_ASSERT(0);
+  }
+  return nullptr;
+}
+
+inline const char* StringOf(const BaseType t) {
+  switch (t) {
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
+    case BASE_TYPE_##ENUM: return #CTYPE;
+      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
+  #undef FLATBUFFERS_TD
+    default: FLATBUFFERS_ASSERT(0);
+  }
+  return "";
+}
+
+// clang-format on
+
+struct StructDef;
+struct EnumDef;
+class Parser;
+
+// Represents any type in the IDL, which is a combination of the BaseType
+// and additional information for vectors/structs_.
+struct Type {
+  explicit Type(BaseType _base_type = BASE_TYPE_NONE, StructDef* _sd = nullptr,
+                EnumDef* _ed = nullptr, uint16_t _fixed_length = 0)
+      : base_type(_base_type),
+        element(BASE_TYPE_NONE),
+        struct_def(_sd),
+        enum_def(_ed),
+        fixed_length(_fixed_length) {}
+
+  bool operator==(const Type& o) const {
+    return base_type == o.base_type && element == o.element &&
+           struct_def == o.struct_def && enum_def == o.enum_def;
+  }
+
+  Type VectorType() const {
+    return Type(element, struct_def, enum_def, fixed_length);
+  }
+
+  Offset<reflection::Type> Serialize(FlatBufferBuilder* builder) const;
+
+  bool Deserialize(const Parser& parser, const reflection::Type* type);
+
+  BaseType base_type;
+  BaseType element;       // only set if t == BASE_TYPE_VECTOR or
+                          // BASE_TYPE_VECTOR64
+  StructDef* struct_def;  // only set if t or element == BASE_TYPE_STRUCT
+  EnumDef* enum_def;      // set if t == BASE_TYPE_UNION / BASE_TYPE_UTYPE,
+                          // or for an integral type derived from an enum.
+  uint16_t fixed_length;  // only set if t == BASE_TYPE_ARRAY
+};
+
+// Represents a parsed scalar value, its type, and field offset.
+struct Value {
+  Value()
+      : constant("0"),
+        offset(static_cast<voffset_t>(~(static_cast<voffset_t>(0U)))) {}
+  Type type;
+  std::string constant;
+  voffset_t offset;
+};
+
+// Helper class that retains the original order of a set of identifiers and
+// also provides quick lookup.
+template <typename T>
+class SymbolTable {
+ public:
+  ~SymbolTable() {
+    for (auto it = vec.begin(); it != vec.end(); ++it) {
+      delete *it;
+    }
+  }
+
+  bool Add(const std::string& name, T* e) {
+    vec.emplace_back(e);
+    auto it = dict.find(name);
+    if (it != dict.end()) return true;
+    dict[name] = e;
+    return false;
+  }
+
+  void Move(const std::string& oldname, const std::string& newname) {
+    auto it = dict.find(oldname);
+    if (it != dict.end()) {
+      auto obj = it->second;
+      dict.erase(it);
+      dict[newname] = obj;
+    } else {
+      FLATBUFFERS_ASSERT(false);
+    }
+  }
+
+  T* Lookup(const std::string& name) const {
+    auto it = dict.find(name);
+    return it == dict.end() ? nullptr : it->second;
+  }
+
+ public:
+  std::map<std::string, T*> dict;  // quick lookup
+  std::vector<T*> vec;             // Used to iterate in order of insertion
+};
+
+// A name space, as set in the schema.
+struct Namespace {
+  Namespace() : from_table(0) {}
+
+  // Given a (potentially unqualified) name, return the "fully qualified" name
+  // which has a full namespaced descriptor.
+  // With max_components you can request less than the number of components
+  // the current namespace has.
+  std::string GetFullyQualifiedName(const std::string& name,
+                                    size_t max_components = 1000) const;
+
+  std::vector<std::string> components;
+  size_t from_table;  // Part of the namespace corresponds to a message/table.
+};
+
+inline bool operator<(const Namespace& a, const Namespace& b) {
+  size_t min_size = std::min(a.components.size(), b.components.size());
+  for (size_t i = 0; i < min_size; ++i) {
+    if (a.components[i] != b.components[i])
+      return a.components[i] < b.components[i];
+  }
+  return a.components.size() < b.components.size();
+}
+
+// Base class for all definition types (fields, structs_, enums_).
+struct Definition {
+  Definition()
+      : generated(false),
+        defined_namespace(nullptr),
+        serialized_location(0),
+        index(-1),
+        refcount(1),
+        declaration_file(nullptr) {}
+
+  flatbuffers::Offset<
+      flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>>
+  SerializeAttributes(FlatBufferBuilder* builder, const Parser& parser) const;
+
+  bool DeserializeAttributes(Parser& parser,
+                             const Vector<Offset<reflection::KeyValue>>* attrs);
+
+  std::string name;
+  std::string file;
+  std::vector<std::string> doc_comment;
+  SymbolTable<Value> attributes;
+  bool generated;  // did we already output code for this definition?
+  Namespace* defined_namespace;  // Where it was defined.
+
+  // For use with Serialize()
+  uoffset_t serialized_location;
+  int index;  // Inside the vector it is stored.
+  int refcount;
+  const std::string* declaration_file;
+};
+
+struct FieldDef : public Definition {
+  FieldDef()
+      : deprecated(false),
+        key(false),
+        shared(false),
+        native_inline(false),
+        flexbuffer(false),
+        offset64(false),
+        presence(kDefault),
+        nested_flatbuffer(nullptr),
+        padding(0),
+        sibling_union_field(nullptr) {}
+
+  Offset<reflection::Field> Serialize(FlatBufferBuilder* builder, uint16_t id,
+                                      const Parser& parser) const;
+
+  bool Deserialize(Parser& parser, const reflection::Field* field);
+
+  bool IsScalarOptional() const { return IsScalar() && IsOptional(); }
+  bool IsScalar() const {
+    return ::flatbuffers::IsScalar(value.type.base_type);
+  }
+  bool IsOptional() const { return presence == kOptional; }
+  bool IsRequired() const { return presence == kRequired; }
+  bool IsDefault() const { return presence == kDefault; }
+
+  Value value;
+  bool deprecated;  // Field is allowed to be present in old data, but can't be.
+                    // written in new data nor accessed in new code.
+  bool key;         // Field functions as a key for creating sorted vectors.
+  bool shared;  // Field will be using string pooling (i.e. CreateSharedString)
+                // as default serialization behavior if field is a string.
+  bool native_inline;  // Field will be defined inline (instead of as a pointer)
+                       // for native tables if field is a struct.
+  bool flexbuffer;     // This field contains FlexBuffer data.
+  bool offset64;       // If the field uses 64-bit offsets.
+
+  enum Presence {
+    // Field must always be present.
+    kRequired,
+    // Non-presence should be signalled to and controlled by users.
+    kOptional,
+    // Non-presence is hidden from users.
+    // Implementations may omit writing default values.
+    kDefault,
+  };
+  Presence static MakeFieldPresence(bool optional, bool required) {
+    FLATBUFFERS_ASSERT(!(required && optional));
+    // clang-format off
+    return required ? FieldDef::kRequired
+         : optional ? FieldDef::kOptional
+                    : FieldDef::kDefault;
+    // clang-format on
+  }
+  Presence presence;
+
+  StructDef* nested_flatbuffer;  // This field contains nested FlatBuffer data.
+  size_t padding;                // Bytes to always pad after this field.
+
+  // sibling_union_field is always set to nullptr. The only exception is
+  // when FieldDef is a union field or an union type field. Therefore,
+  // sibling_union_field on a union field points to the union type field
+  // and vice-versa.
+  FieldDef* sibling_union_field;
+};
+
+struct StructDef : public Definition {
+  enum class CycleStatus {
+    NotChecked,
+    InProgress,
+    Checked,
+  };
+
+  StructDef()
+      : fixed(false),
+        predecl(true),
+        sortbysize(true),
+        has_key(false),
+        minalign(1),
+        bytesize(0),
+        cycle_status{CycleStatus::NotChecked} {}
+
+  void PadLastField(size_t min_align) {
+    auto padding = PaddingBytes(bytesize, min_align);
+    bytesize += padding;
+    if (fields.vec.size()) fields.vec.back()->padding = padding;
+  }
+
+  Offset<reflection::Object> Serialize(FlatBufferBuilder* builder,
+                                       const Parser& parser) const;
+
+  bool Deserialize(Parser& parser, const reflection::Object* object);
+
+  SymbolTable<FieldDef> fields;
+
+  bool fixed;       // If it's struct, not a table.
+  bool predecl;     // If it's used before it was defined.
+  bool sortbysize;  // Whether fields come in the declaration or size order.
+  bool has_key;     // It has a key field.
+  size_t minalign;  // What the whole object needs to be aligned to.
+  size_t bytesize;  // Size if fixed.
+
+  CycleStatus cycle_status;  // used for determining if we have circular references
+
+  flatbuffers::unique_ptr<std::string> original_location;
+  std::vector<voffset_t> reserved_ids;
+};
+
+struct EnumDef;
+struct EnumValBuilder;
+
+struct EnumVal {
+  Offset<reflection::EnumVal> Serialize(FlatBufferBuilder* builder,
+                                        const Parser& parser) const;
+
+  bool Deserialize(Parser& parser, const reflection::EnumVal* val);
+
+  flatbuffers::Offset<
+      flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>>
+  SerializeAttributes(FlatBufferBuilder* builder, const Parser& parser) const;
+
+  bool DeserializeAttributes(Parser& parser,
+                             const Vector<Offset<reflection::KeyValue>>* attrs);
+
+  uint64_t GetAsUInt64() const { return static_cast<uint64_t>(value); }
+  int64_t GetAsInt64() const { return value; }
+  bool IsZero() const { return 0 == value; }
+  bool IsNonZero() const { return !IsZero(); }
+
+  std::string name;
+  std::vector<std::string> doc_comment;
+  Type union_type;
+  SymbolTable<Value> attributes;
+
+ private:
+  friend EnumDef;
+  friend EnumValBuilder;
+  friend bool operator==(const EnumVal& lhs, const EnumVal& rhs);
+
+  EnumVal(const std::string& _name, int64_t _val) : name(_name), value(_val) {}
+  EnumVal() : value(0) {}
+
+  int64_t value;
+};
+
+struct EnumDef : public Definition {
+  EnumDef() : is_union(false), uses_multiple_type_instances(false) {}
+
+  Offset<reflection::Enum> Serialize(FlatBufferBuilder* builder,
+                                     const Parser& parser) const;
+
+  bool Deserialize(Parser& parser, const reflection::Enum* values);
+
+  template <typename T>
+  void ChangeEnumValue(EnumVal* ev, T new_val);
+  void SortByValue();
+  void RemoveDuplicates();
+
+  std::string AllFlags() const;
+  const EnumVal* MinValue() const;
+  const EnumVal* MaxValue() const;
+  // Returns the number of integer steps from v1 to v2.
+  uint64_t Distance(const EnumVal* v1, const EnumVal* v2) const;
+  // Returns the number of integer steps from Min to Max.
+  uint64_t Distance() const { return Distance(MinValue(), MaxValue()); }
+
+  EnumVal* ReverseLookup(int64_t enum_idx,
+                         bool skip_union_default = false) const;
+  EnumVal* FindByValue(const std::string& constant) const;
+
+  std::string ToString(const EnumVal& ev) const {
+    return IsUInt64() ? NumToString(ev.GetAsUInt64())
+                      : NumToString(ev.GetAsInt64());
+  }
+
+  size_t size() const { return vals.vec.size(); }
+
+  const std::vector<EnumVal*>& Vals() const { return vals.vec; }
+
+  const EnumVal* Lookup(const std::string& enum_name) const {
+    return vals.Lookup(enum_name);
+  }
+
+  bool is_union;
+  // Type is a union which uses type aliases where at least one type is
+  // available under two different names.
+  bool uses_multiple_type_instances;
+  Type underlying_type;
+
+ private:
+  bool IsUInt64() const {
+    return (BASE_TYPE_ULONG == underlying_type.base_type);
+  }
+
+  friend EnumValBuilder;
+  SymbolTable<EnumVal> vals;
+};
+
+inline bool IsString(const Type& type) {
+  return type.base_type == BASE_TYPE_STRING;
+}
+
+inline bool IsStruct(const Type& type) {
+  return type.base_type == BASE_TYPE_STRUCT && type.struct_def->fixed;
+}
+
+inline bool IsIncompleteStruct(const Type& type) {
+  return type.base_type == BASE_TYPE_STRUCT && type.struct_def->predecl;
+}
+
+inline bool IsTable(const Type& type) {
+  return type.base_type == BASE_TYPE_STRUCT && !type.struct_def->fixed;
+}
+
+inline bool IsUnion(const Type& type) {
+  return type.enum_def != nullptr && type.enum_def->is_union;
+}
+
+inline bool IsUnionType(const Type& type) {
+  return IsUnion(type) && IsInteger(type.base_type);
+}
+
+inline bool IsVector(const Type& type) { return IsVector(type.base_type); }
+
+inline bool IsVectorOfStruct(const Type& type) {
+  return IsVector(type) && IsStruct(type.VectorType());
+}
+
+inline bool IsVectorOfTable(const Type& type) {
+  return IsVector(type) && IsTable(type.VectorType());
+}
+
+inline bool IsArray(const Type& type) {
+  return type.base_type == BASE_TYPE_ARRAY;
+}
+
+inline bool IsSeries(const Type& type) {
+  return IsVector(type) || IsArray(type);
+}
+
+inline bool IsEnum(const Type& type) {
+  return type.enum_def != nullptr && IsInteger(type.base_type);
+}
+
+inline size_t InlineSize(const Type& type) {
+  return IsStruct(type)
+             ? type.struct_def->bytesize
+             : (IsArray(type)
+                    ? InlineSize(type.VectorType()) * type.fixed_length
+                    : SizeOf(type.base_type));
+}
+
+inline size_t InlineAlignment(const Type& type) {
+  if (IsStruct(type)) {
+    return type.struct_def->minalign;
+  } else if (IsArray(type)) {
+    return IsStruct(type.VectorType()) ? type.struct_def->minalign
+                                       : SizeOf(type.element);
+  } else {
+    return SizeOf(type.base_type);
+  }
+}
+inline bool operator==(const EnumVal& lhs, const EnumVal& rhs) {
+  return lhs.value == rhs.value;
+}
+inline bool operator!=(const EnumVal& lhs, const EnumVal& rhs) {
+  return !(lhs == rhs);
+}
+
+inline bool EqualByName(const Type& a, const Type& b) {
+  return a.base_type == b.base_type && a.element == b.element &&
+         (a.struct_def == b.struct_def ||
+          (a.struct_def != nullptr && b.struct_def != nullptr &&
+           a.struct_def->name == b.struct_def->name)) &&
+         (a.enum_def == b.enum_def ||
+          (a.enum_def != nullptr && b.enum_def != nullptr &&
+           a.enum_def->name == b.enum_def->name));
+}
+
+struct RPCCall : public Definition {
+  Offset<reflection::RPCCall> Serialize(FlatBufferBuilder* builder,
+                                        const Parser& parser) const;
+
+  bool Deserialize(Parser& parser, const reflection::RPCCall* call);
+
+  StructDef *request, *response;
+};
+
+struct ServiceDef : public Definition {
+  Offset<reflection::Service> Serialize(FlatBufferBuilder* builder,
+                                        const Parser& parser) const;
+  bool Deserialize(Parser& parser, const reflection::Service* service);
+
+  SymbolTable<RPCCall> calls;
+};
+
+struct IncludedFile {
+  // The name of the schema file being included, as defined in the .fbs file.
+  // This includes the prefix (e.g., include "foo/bar/baz.fbs" would mean this
+  // value is "foo/bar/baz.fbs").
+  std::string schema_name;
+
+  // The filename of where the included file was found, after searching the
+  // relative paths plus any other paths included with `flatc -I ...`. Note,
+  // while this is sometimes the same as schema_name, it is not always, since it
+  // can be defined relative to where flatc was invoked.
+  std::string filename;
+};
+
+// Since IncludedFile is contained within a std::set, need to provide ordering.
+inline bool operator<(const IncludedFile& a, const IncludedFile& b) {
+  return a.filename < b.filename;
+}
+
+// Container of options that may apply to any of the source/text generators.
+struct IDLOptions {
+  // file saver
+  // shared pointer since this object gets copied and modified.
+  FileSaver* file_saver = nullptr;
+
+  // field case style options for C++
+  enum CaseStyle { CaseStyle_Unchanged = 0, CaseStyle_Upper, CaseStyle_Lower };
+  enum class ProtoIdGapAction { NO_OP, WARNING, ERROR };
+  bool gen_jvmstatic;
+  // Use flexbuffers instead for binary and text generation
+  bool use_flexbuffers;
+  bool strict_json;
+  bool output_default_scalars_in_json;
+  int indent_step;
+  bool cpp_minify_enums;
+  bool output_enum_identifiers;
+  bool prefixed_enums;
+  bool scoped_enums;
+  bool emit_min_max_enum_values;
+  bool swift_implementation_only;
+  bool include_dependence_headers;
+  bool mutable_buffer;
+  bool one_file;
+  bool proto_mode;
+  bool proto_oneof_union;
+  bool generate_all;
+  bool skip_unexpected_fields_in_json;
+  bool generate_name_strings;
+  bool generate_object_based_api;
+  bool gen_compare;
+  bool gen_absl_hash;
+  std::string cpp_object_api_pointer_type;
+  std::string cpp_object_api_string_type;
+  bool cpp_object_api_string_flexible_constructor;
+  CaseStyle cpp_object_api_field_case_style;
+  bool cpp_direct_copy;
+  bool gen_nullable;
+  std::string java_package_prefix;
+  bool java_checkerframework;
+  bool gen_generated;
+  bool gen_json_coders;
+  std::string object_prefix;
+  std::string object_suffix;
+  bool union_value_namespacing;
+  bool allow_non_utf8;
+  bool natural_utf8;
+  std::string include_prefix;
+  bool keep_prefix;
+  bool binary_schema_comments;
+  bool binary_schema_builtins;
+  bool binary_schema_gen_embed;
+  bool binary_schema_absolute_paths;
+  std::string go_import;
+  std::string go_namespace;
+  std::string go_module_name;
+  bool protobuf_ascii_alike;
+  bool size_prefixed;
+  std::string root_type;
+  bool force_defaults;
+  bool java_primitive_has_method;
+  bool cs_gen_json_serializer;
+  std::vector<std::string> cpp_includes;
+  std::string cpp_std;
+  bool cpp_static_reflection;
+  std::string proto_namespace_suffix;
+  std::string filename_suffix;
+  std::string filename_extension;
+  bool no_warnings;
+  bool warnings_as_errors;
+  std::string project_root;
+  bool cs_global_alias;
+  bool json_nested_flatbuffers;
+  bool json_nested_flexbuffers;
+  bool json_nested_legacy_flatbuffers;
+  bool ts_no_import_ext;
+  bool no_leak_private_annotations;
+  bool require_json_eof;
+  bool keep_proto_id;
+
+  /********************************** Python **********************************/
+  bool python_no_type_prefix_suffix;
+  bool python_typing;
+  bool python_decode_obj_api_strings = false;
+
+  // The target Python version. Can be one of the following:
+  // -  "0"
+  // -  "2"
+  // -  "3"
+  // -  "2.<minor>"
+  // -  "3.<minor>"
+  // -  "2.<minor>.<micro>"
+  // -  "3.<minor>.<micro>"
+  //
+  // https://docs.python.org/3/faq/general.html#how-does-the-python-version-numbering-scheme-work
+  std::string python_version;
+
+  // Whether to generate numpy helpers.
+  bool python_gen_numpy;
+
+  bool ts_omit_entrypoint;
+  bool ts_undefined_for_optionals;
+  ProtoIdGapAction proto_id_gap_action;
+
+  // Possible options for the more general generator below.
+  enum Language {
+    kJava = 1 << 0,
+    kCSharp = 1 << 1,
+    kGo = 1 << 2,
+    kCpp = 1 << 3,
+    kPython = 1 << 5,
+    kPhp = 1 << 6,
+    kJson = 1 << 7,
+    kBinary = 1 << 8,
+    kTs = 1 << 9,
+    kJsonSchema = 1 << 10,
+    kDart = 1 << 11,
+    kLua = 1 << 12,
+    kLobster = 1 << 13,
+    kRust = 1 << 14,
+    kKotlin = 1 << 15,
+    kSwift = 1 << 16,
+    kNim = 1 << 17,
+    kProto = 1 << 18,
+    kKotlinKmp = 1 << 19,
+    kMAX
+  };
+
+  enum MiniReflect { kNone, kTypes, kTypesAndNames };
+
+  MiniReflect mini_reflect;
+
+  // If set, require all fields in a table to be explicitly numbered.
+  bool require_explicit_ids;
+
+  // If set, implement serde::Serialize for generated Rust types
+  bool rust_serialize;
+
+  // If set, generate rust types in individual files with a root module file.
+  bool rust_module_root_file;
+
+  // The corresponding language bit will be set if a language is included
+  // for code generation.
+  unsigned long lang_to_generate;
+
+  // If set (default behavior), empty string fields will be set to nullptr to
+  // make the flatbuffer more compact.
+  bool set_empty_strings_to_null;
+
+  // If set (default behavior), empty vector fields will be set to nullptr to
+  // make the flatbuffer more compact.
+  bool set_empty_vectors_to_null;
+
+  /*********************************** gRPC ***********************************/
+  std::string grpc_filename_suffix;
+  bool grpc_use_system_headers;
+  std::string grpc_search_path;
+  std::vector<std::string> grpc_additional_headers;
+  // Generate C++ gRPC Callback API (modern async API) service code when used
+  // together with --grpc. This is an additive, opt-in feature.
+  bool grpc_callback_api;
+
+  /******************************* Python gRPC ********************************/
+  bool grpc_python_typed_handlers;
+
+  IDLOptions()
+      : gen_jvmstatic(false),
+        use_flexbuffers(false),
+        strict_json(false),
+        output_default_scalars_in_json(false),
+        indent_step(2),
+        cpp_minify_enums(false),
+        output_enum_identifiers(true),
+        prefixed_enums(true),
+        scoped_enums(false),
+        emit_min_max_enum_values(true),
+        swift_implementation_only(false),
+        include_dependence_headers(true),
+        mutable_buffer(false),
+        one_file(false),
+        proto_mode(false),
+        proto_oneof_union(false),
+        generate_all(false),
+        skip_unexpected_fields_in_json(false),
+        generate_name_strings(false),
+        generate_object_based_api(false),
+        gen_compare(false),
+        gen_absl_hash(false),
+        cpp_object_api_pointer_type("std::unique_ptr"),
+        cpp_object_api_string_flexible_constructor(false),
+        cpp_object_api_field_case_style(CaseStyle_Unchanged),
+        cpp_direct_copy(true),
+        gen_nullable(false),
+        java_checkerframework(false),
+        gen_generated(false),
+        gen_json_coders(false),
+        object_suffix("T"),
+        union_value_namespacing(true),
+        allow_non_utf8(false),
+        natural_utf8(false),
+        keep_prefix(false),
+        binary_schema_comments(false),
+        binary_schema_builtins(false),
+        binary_schema_gen_embed(false),
+        binary_schema_absolute_paths(false),
+        protobuf_ascii_alike(false),
+        size_prefixed(false),
+        force_defaults(false),
+        java_primitive_has_method(false),
+        cs_gen_json_serializer(false),
+        cpp_static_reflection(false),
+        filename_suffix("_generated"),
+        filename_extension(),
+        no_warnings(false),
+        warnings_as_errors(false),
+        project_root(""),
+        cs_global_alias(false),
+        json_nested_flatbuffers(true),
+        json_nested_flexbuffers(true),
+        json_nested_legacy_flatbuffers(false),
+        ts_no_import_ext(false),
+        no_leak_private_annotations(false),
+        require_json_eof(true),
+        keep_proto_id(false),
+        python_no_type_prefix_suffix(false),
+        python_typing(false),
+        python_gen_numpy(true),
+        ts_omit_entrypoint(false),
+        ts_undefined_for_optionals(false),
+        proto_id_gap_action(ProtoIdGapAction::WARNING),
+        mini_reflect(IDLOptions::kNone),
+        require_explicit_ids(false),
+        rust_serialize(false),
+        rust_module_root_file(false),
+        lang_to_generate(0),
+        set_empty_strings_to_null(true),
+        set_empty_vectors_to_null(true),
+        grpc_filename_suffix(".fb"),
+        grpc_use_system_headers(true),
+        grpc_callback_api(false),
+        grpc_python_typed_handlers(false) {}
+};
+
+// This encapsulates where the parser is in the current source file.
+struct ParserState {
+  ParserState()
+      : prev_cursor_(nullptr),
+        cursor_(nullptr),
+        line_start_(nullptr),
+        line_(0),
+        token_(-1),
+        attr_is_trivial_ascii_string_(true) {}
+
+ protected:
+  void ResetState(const char* source) {
+    prev_cursor_ = source;
+    cursor_ = source;
+    line_ = 0;
+    MarkNewLine();
+  }
+
+  void MarkNewLine() {
+    line_start_ = cursor_;
+    line_ += 1;
+  }
+
+  int64_t CursorPosition() const {
+    FLATBUFFERS_ASSERT(cursor_ && line_start_ && cursor_ >= line_start_);
+    return static_cast<int64_t>(cursor_ - line_start_);
+  }
+
+  const char* prev_cursor_;
+  const char* cursor_;
+  const char* line_start_;
+  int line_;  // the current line being parsed
+  int token_;
+
+  // Flag: text in attribute_ is true ASCII string without escape
+  // sequences. Only printable ASCII (without [\t\r\n]).
+  // Used for number-in-string (and base64 string in future).
+  bool attr_is_trivial_ascii_string_;
+  std::string attribute_;
+  std::vector<std::string> doc_comment_;
+};
+
+// A way to make error propagation less error prone by requiring values to be
+// checked.
+// Once you create a value of this type you must either:
+// - Call Check() on it.
+// - Copy or assign it to another value.
+// Failure to do so leads to an assert.
+// This guarantees that this as return value cannot be ignored.
+class CheckedError {
+ public:
+  explicit CheckedError(bool error)
+      : is_error_(error), has_been_checked_(false) {}
+
+  CheckedError& operator=(const CheckedError& other) {
+    is_error_ = other.is_error_;
+    has_been_checked_ = false;
+    other.has_been_checked_ = true;
+    return *this;
+  }
+
+  CheckedError(const CheckedError& other) {
+    *this = other;  // Use assignment operator.
+  }
+
+  ~CheckedError() { FLATBUFFERS_ASSERT(has_been_checked_); }
+
+  bool Check() {
+    has_been_checked_ = true;
+    return is_error_;
+  }
+
+ private:
+  bool is_error_;
+  mutable bool has_been_checked_;
+};
+
+// Additionally, in GCC we can get these errors statically, for additional
+// assurance:
+// clang-format off
+#ifdef __GNUC__
+#define FLATBUFFERS_CHECKED_ERROR CheckedError \
+          __attribute__((warn_unused_result))
+#else
+#define FLATBUFFERS_CHECKED_ERROR CheckedError
+#endif
+// clang-format on
+
+class Parser : public ParserState {
+ public:
+  explicit Parser(const IDLOptions& options = IDLOptions())
+      : current_namespace_(nullptr),
+        empty_namespace_(nullptr),
+        flex_builder_(256, flexbuffers::BUILDER_FLAG_SHARE_ALL),
+        root_struct_def_(nullptr),
+        opts(options),
+        uses_flexbuffers_(false),
+        has_warning_(false),
+        advanced_features_(0),
+        source_(nullptr),
+        anonymous_counter_(0),
+        parse_depth_counter_(0) {
+    if (opts.force_defaults) {
+      builder_.ForceDefaults(true);
+    }
+    // Start out with the empty namespace being current.
+    empty_namespace_ = new Namespace();
+    namespaces_.push_back(empty_namespace_);
+    current_namespace_ = empty_namespace_;
+    known_attributes_["deprecated"] = true;
+    known_attributes_["required"] = true;
+    known_attributes_["key"] = true;
+    known_attributes_["shared"] = true;
+    known_attributes_["hash"] = true;
+    known_attributes_["id"] = true;
+    known_attributes_["force_align"] = true;
+    known_attributes_["bit_flags"] = true;
+    known_attributes_["original_order"] = true;
+    known_attributes_["nested_flatbuffer"] = true;
+    known_attributes_["csharp_partial"] = true;
+    known_attributes_["streaming"] = true;
+    known_attributes_["idempotent"] = true;
+    known_attributes_["cpp_type"] = true;
+    known_attributes_["cpp_ptr_type"] = true;
+    known_attributes_["cpp_ptr_type_get"] = true;
+    known_attributes_["cpp_str_type"] = true;
+    known_attributes_["cpp_str_flex_ctor"] = true;
+    known_attributes_["native_inline"] = true;
+    known_attributes_["native_custom_alloc"] = true;
+    known_attributes_["native_type"] = true;
+    known_attributes_["native_type_pack_name"] = true;
+    known_attributes_["native_default"] = true;
+    known_attributes_["flexbuffer"] = true;
+    known_attributes_["private"] = true;
+
+    // An attribute added to a field to indicate that is uses 64-bit addressing.
+    known_attributes_["offset64"] = true;
+
+    // An attribute added to a vector field to indicate that it uses 64-bit
+    // addressing and it has a 64-bit length.
+    known_attributes_["vector64"] = true;
+  }
+
+  // Copying is not allowed
+  Parser(const Parser&) = delete;
+  Parser& operator=(const Parser&) = delete;
+
+  Parser(Parser&&) = default;
+  Parser& operator=(Parser&&) = default;
+
+  ~Parser() {
+    for (auto it = namespaces_.begin(); it != namespaces_.end(); ++it) {
+      delete *it;
+    }
+  }
+
+  // Parse the string containing either schema or JSON data, which will
+  // populate the SymbolTable's or the FlatBufferBuilder above.
+  // include_paths is used to resolve any include statements, and typically
+  // should at least include the project path (where you loaded source_ from).
+  // include_paths must be nullptr terminated if specified.
+  // If include_paths is nullptr, it will attempt to load from the current
+  // directory.
+  // If the source was loaded from a file and isn't an include file,
+  // supply its name in source_filename.
+  // All paths specified in this call must be in posix format, if you accept
+  // paths from user input, please call PosixPath on them first.
+  bool Parse(const char* _source, const char** include_paths = nullptr,
+             const char* source_filename = nullptr);
+
+  bool ParseJson(const char* json, const char* json_filename = nullptr);
+
+  // Returns the number of characters were consumed when parsing a JSON string.
+  std::ptrdiff_t BytesConsumed() const;
+
+  // Set the root type. May override the one set in the schema.
+  bool SetRootType(const char* name);
+
+  // Mark all definitions as already having code generated.
+  void MarkGenerated();
+
+  // Get the files recursively included by the given file. The returned
+  // container will have at least the given file.
+  std::set<std::string> GetIncludedFilesRecursive(
+      const std::string& file_name) const;
+
+  // Fills builder_ with a binary version of the schema parsed.
+  // See reflection/reflection.fbs
+  void Serialize();
+
+  // Deserialize a schema buffer
+  bool Deserialize(const uint8_t* buf, const size_t size);
+
+  // Fills internal structure as if the schema passed had been loaded by parsing
+  // with Parse except that included filenames will not be populated.
+  bool Deserialize(const reflection::Schema* schema);
+
+  Type* DeserializeType(const reflection::Type* type);
+
+  // Checks that the schema represented by this parser is a safe evolution
+  // of the schema provided. Returns non-empty error on any problems.
+  std::string ConformTo(const Parser& base);
+
+  // Similar to Parse(), but now only accepts JSON to be parsed into a
+  // FlexBuffer.
+  bool ParseFlexBuffer(const char* source, const char* source_filename,
+                       flexbuffers::Builder* builder);
+
+  StructDef* LookupStruct(const std::string& id) const;
+  StructDef* LookupStructThruParentNamespaces(const std::string& id) const;
+
+  std::string UnqualifiedName(const std::string& fullQualifiedName);
+
+  FLATBUFFERS_CHECKED_ERROR Error(const std::string& msg);
+
+  // @brief Verify that any of 'opts.lang_to_generate' supports Optional scalars
+  // in a schema.
+  // @param opts Options used to parce a schema and generate code.
+  static bool SupportsOptionalScalars(const flatbuffers::IDLOptions& opts);
+
+  // Get the set of included files that are directly referenced by the file
+  // being parsed. This does not include files that are transitively included by
+  // others includes.
+  std::vector<IncludedFile> GetIncludedFiles() const;
+
+  bool HasCircularStructDependency();
+
+ private:
+  class ParseDepthGuard;
+
+  void Message(const std::string& msg);
+  void Warning(const std::string& msg);
+  FLATBUFFERS_CHECKED_ERROR ParseHexNum(int nibbles, uint64_t* val);
+  FLATBUFFERS_CHECKED_ERROR Next();
+  FLATBUFFERS_CHECKED_ERROR SkipByteOrderMark();
+  bool Is(int t) const;
+  bool IsIdent(const char* id) const;
+  FLATBUFFERS_CHECKED_ERROR Expect(int t);
+  std::string TokenToStringId(int t) const;
+  EnumDef* LookupEnum(const std::string& id);
+  FLATBUFFERS_CHECKED_ERROR ParseNamespacing(std::string* id,
+                                             std::string* last);
+  FLATBUFFERS_CHECKED_ERROR ParseTypeIdent(Type& type);
+  FLATBUFFERS_CHECKED_ERROR ParseType(Type& type);
+  FLATBUFFERS_CHECKED_ERROR AddField(StructDef& struct_def,
+                                     const std::string& name, const Type& type,
+                                     FieldDef** dest);
+  FLATBUFFERS_CHECKED_ERROR ParseField(StructDef& struct_def);
+  FLATBUFFERS_CHECKED_ERROR ParseString(Value& val, bool use_string_pooling);
+  FLATBUFFERS_CHECKED_ERROR ParseComma();
+  FLATBUFFERS_CHECKED_ERROR ParseAnyValue(Value& val, FieldDef* field,
+                                          size_t parent_fieldn,
+                                          const StructDef* parent_struct_def,
+                                          size_t count,
+                                          bool inside_vector = false);
+  template <typename F>
+  FLATBUFFERS_CHECKED_ERROR ParseTableDelimiters(size_t& fieldn,
+                                                 const StructDef* struct_def,
+                                                 F body);
+  FLATBUFFERS_CHECKED_ERROR ParseTable(const StructDef& struct_def,
+                                       std::string* value, uoffset_t* ovalue);
+  void SerializeStruct(const StructDef& struct_def, const Value& val);
+  void SerializeStruct(FlatBufferBuilder& builder, const StructDef& struct_def,
+                       const Value& val);
+  template <typename F>
+  FLATBUFFERS_CHECKED_ERROR ParseVectorDelimiters(size_t& count, F body);
+  FLATBUFFERS_CHECKED_ERROR ParseVector(const Type& type, uoffset_t* ovalue,
+                                        FieldDef* field, size_t fieldn);
+  FLATBUFFERS_CHECKED_ERROR ParseArray(Value& array);
+  FLATBUFFERS_CHECKED_ERROR ParseNestedFlatbuffer(
+      Value& val, FieldDef* field, size_t fieldn,
+      const StructDef* parent_struct_def);
+  FLATBUFFERS_CHECKED_ERROR ParseMetaData(SymbolTable<Value>* attributes);
+  FLATBUFFERS_CHECKED_ERROR TryTypedValue(const std::string* name, int dtoken,
+                                          bool check, Value& e, BaseType req,
+                                          bool* destmatch);
+  FLATBUFFERS_CHECKED_ERROR ParseHash(Value& e, FieldDef* field);
+  FLATBUFFERS_CHECKED_ERROR TokenError();
+  FLATBUFFERS_CHECKED_ERROR ParseSingleValue(const std::string* name, Value& e,
+                                             bool check_now);
+  FLATBUFFERS_CHECKED_ERROR ParseFunction(const std::string* name, Value& e);
+  FLATBUFFERS_CHECKED_ERROR ParseEnumFromString(const Type& type,
+                                                std::string* result);
+  StructDef* LookupCreateStruct(const std::string& name,
+                                bool create_if_new = true,
+                                bool definition = false);
+  FLATBUFFERS_CHECKED_ERROR ParseEnum(bool is_union, EnumDef** dest,
+                                      const char* filename);
+  FLATBUFFERS_CHECKED_ERROR ParseNamespace();
+  FLATBUFFERS_CHECKED_ERROR StartStruct(const std::string& name,
+                                        StructDef** dest);
+  FLATBUFFERS_CHECKED_ERROR StartEnum(const std::string& name, bool is_union,
+                                      EnumDef** dest);
+  FLATBUFFERS_CHECKED_ERROR ParseDecl(const char* filename);
+  FLATBUFFERS_CHECKED_ERROR ParseService(const char* filename);
+  FLATBUFFERS_CHECKED_ERROR ParseProtoFields(StructDef* struct_def,
+                                             bool isextend, bool inside_oneof);
+  FLATBUFFERS_CHECKED_ERROR ParseProtoMapField(StructDef* struct_def);
+  FLATBUFFERS_CHECKED_ERROR ParseProtoOption();
+  FLATBUFFERS_CHECKED_ERROR ParseProtoKey();
+  FLATBUFFERS_CHECKED_ERROR ParseProtoDecl();
+  FLATBUFFERS_CHECKED_ERROR ParseProtoCurliesOrIdent();
+  FLATBUFFERS_CHECKED_ERROR ParseTypeFromProtoType(Type* type);
+  FLATBUFFERS_CHECKED_ERROR SkipAnyJsonValue();
+  FLATBUFFERS_CHECKED_ERROR ParseFlexBufferNumericConstant(
+      flexbuffers::Builder* builder);
+  FLATBUFFERS_CHECKED_ERROR ParseFlexBufferValue(flexbuffers::Builder* builder);
+  FLATBUFFERS_CHECKED_ERROR StartParseFile(const char* source,
+                                           const char* source_filename);
+  FLATBUFFERS_CHECKED_ERROR ParseRoot(const char* _source,
+                                      const char** include_paths,
+                                      const char* source_filename);
+  FLATBUFFERS_CHECKED_ERROR CheckPrivateLeak();
+  FLATBUFFERS_CHECKED_ERROR CheckPrivatelyLeakedFields(
+      const Definition& def, const Definition& value_type);
+  FLATBUFFERS_CHECKED_ERROR DoParse(const char* _source,
+                                    const char** include_paths,
+                                    const char* source_filename,
+                                    const char* include_filename);
+  FLATBUFFERS_CHECKED_ERROR DoParseJson();
+  FLATBUFFERS_CHECKED_ERROR CheckClash(std::vector<FieldDef*>& fields,
+                                       StructDef* struct_def,
+                                       const char* suffix, BaseType baseType);
+  FLATBUFFERS_CHECKED_ERROR ParseAlignAttribute(
+      const std::string& align_constant, size_t min_align, size_t* align);
+
+  bool SupportsAdvancedUnionFeatures() const;
+  bool SupportsAdvancedArrayFeatures() const;
+  bool SupportsOptionalScalars() const;
+  bool SupportsDefaultVectorsAndStrings() const;
+  bool Supports64BitOffsets() const;
+  bool SupportsUnionUnderlyingType() const;
+  Namespace* UniqueNamespace(Namespace* ns);
+
+  FLATBUFFERS_CHECKED_ERROR RecurseError();
+  template <typename F>
+  CheckedError Recurse(F f);
+
+  const std::string& GetPooledString(const std::string& s) const;
+
+ public:
+  SymbolTable<Type> types_;
+  SymbolTable<StructDef> structs_;
+  SymbolTable<EnumDef> enums_;
+  SymbolTable<ServiceDef> services_;
+  std::vector<Namespace*> namespaces_;
+  Namespace* current_namespace_;
+  Namespace* empty_namespace_;
+  std::string error_;  // User readable error_ if Parse() == false
+
+  FlatBufferBuilder builder_;  // any data contained in the file
+  flexbuffers::Builder flex_builder_;
+  flexbuffers::Reference flex_root_;
+  StructDef* root_struct_def_;
+  std::string file_identifier_;
+  std::string file_extension_;
+
+  std::map<uint64_t, std::string> included_files_;
+  std::map<std::string, std::set<IncludedFile>> files_included_per_file_;
+  std::vector<std::string> native_included_files_;
+
+  std::map<std::string, bool> known_attributes_;
+
+  IDLOptions opts;
+  bool uses_flexbuffers_;
+  bool has_warning_;
+
+  uint64_t advanced_features_;
+
+  std::string file_being_parsed_;
+
+ private:
+  const char* source_;
+
+  std::vector<std::pair<Value, FieldDef*>> field_stack_;
+
+  // TODO(cneo): Refactor parser to use string_cache more often to save
+  // on memory usage.
+  mutable std::set<std::string> string_cache_;
+
+  int anonymous_counter_;
+  int parse_depth_counter_;  // stack-overflow guard
+};
+
+// Utility functions for multiple generators:
+
+// Generate text (JSON) from a given FlatBuffer, and a given Parser
+// object that has been populated with the corresponding schema.
+// If ident_step is 0, no indentation will be generated. Additionally,
+// if it is less than 0, no linefeeds will be generated either.
+// See idl_gen_text.cpp.
+// strict_json adds "quotes" around field names if true.
+// These functions return nullptr on success, or an error string,
+// which may happen if the flatbuffer cannot be encoded in JSON (e.g.,
+// it contains non-UTF-8 byte arrays in String values).
+extern bool GenerateTextFromTable(const Parser& parser, const void* table,
+                                  const std::string& tablename,
+                                  std::string* text);
+extern const char* GenerateText(const Parser& parser, const void* flatbuffer,
+                                std::string* text);
+extern const char* GenerateTextFile(const Parser& parser,
+                                    const std::string& path,
+                                    const std::string& file_name);
+
+extern const char* GenTextFromTable(const Parser& parser, const void* table,
+                                    const std::string& tablename,
+                                    std::string* text);
+extern const char* GenText(const Parser& parser, const void* flatbuffer,
+                           std::string* text);
+extern const char* GenTextFile(const Parser& parser, const std::string& path,
+                               const std::string& file_name);
+
+// Generate GRPC Cpp interfaces.
+// See idl_gen_grpc.cpp.
+bool GenerateCppGRPC(const Parser& parser, const std::string& path,
+                     const std::string& file_name);
+
+// Generate GRPC Go interfaces.
+// See idl_gen_grpc.cpp.
+bool GenerateGoGRPC(const Parser& parser, const std::string& path,
+                    const std::string& file_name);
+
+// Generate GRPC Java classes.
+// See idl_gen_grpc.cpp
+bool GenerateJavaGRPC(const Parser& parser, const std::string& path,
+                      const std::string& file_name);
+
+// Generate GRPC Python interfaces.
+// See idl_gen_grpc.cpp.
+bool GeneratePythonGRPC(const Parser& parser, const std::string& path,
+                        const std::string& file_name);
+
+// Generate GRPC Swift interfaces.
+// See idl_gen_grpc.cpp.
+extern bool GenerateSwiftGRPC(const Parser& parser, const std::string& path,
+                              const std::string& file_name);
+
+extern bool GenerateTSGRPC(const Parser& parser, const std::string& path,
+                           const std::string& file_name);
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_IDL_H_
diff --git a/external/flatbuffers/include/flatbuffers/minireflect.h b/external/flatbuffers/include/flatbuffers/minireflect.h
new file mode 100644
index 00000000..77be5165
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/minireflect.h
@@ -0,0 +1,441 @@
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_MINIREFLECT_H_
+#define FLATBUFFERS_MINIREFLECT_H_
+
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/util.h"
+
+namespace flatbuffers {
+
+// Utilities that can be used with the "mini reflection" tables present
+// in generated code with --reflect-types (only types) or --reflect-names
+// (also names).
+// This allows basic reflection functionality such as pretty-printing
+// that does not require the use of the schema parser or loading of binary
+// schema files at runtime (reflection.h).
+
+// For any of the functions below that take `const TypeTable *`, you pass
+// `FooTypeTable()` if the type of the root is `Foo`.
+
+// First, a generic iterator that can be used by multiple algorithms.
+
+struct IterationVisitor {
+  // These mark the scope of a table or struct.
+  virtual void StartSequence() {}
+  virtual void EndSequence() {}
+  // Called for each field regardless of whether it is present or not.
+  // If not present, val == nullptr. set_idx is the index of all set fields.
+  virtual void Field(size_t /*field_idx*/, size_t /*set_idx*/,
+                     ElementaryType /*type*/, bool /*is_vector*/,
+                     const TypeTable* /*type_table*/, const char* /*name*/,
+                     const uint8_t* /*val*/) {}
+  // Called for a value that is actually present, after a field, or as part
+  // of a vector.
+  virtual void UType(uint8_t, const char*) {}
+  virtual void Bool(bool) {}
+  virtual void Char(int8_t, const char*) {}
+  virtual void UChar(uint8_t, const char*) {}
+  virtual void Short(int16_t, const char*) {}
+  virtual void UShort(uint16_t, const char*) {}
+  virtual void Int(int32_t, const char*) {}
+  virtual void UInt(uint32_t, const char*) {}
+  virtual void Long(int64_t) {}
+  virtual void ULong(uint64_t) {}
+  virtual void Float(float) {}
+  virtual void Double(double) {}
+  virtual void String(const String*) {}
+  virtual void Unknown(const uint8_t*) {}  // From a future version.
+  // These mark the scope of a vector.
+  virtual void StartVector() {}
+  virtual void EndVector() {}
+  virtual void Element(size_t /*i*/, ElementaryType /*type*/,
+                       const TypeTable* /*type_table*/,
+                       const uint8_t* /*val*/) {}
+  virtual ~IterationVisitor() {}
+};
+
+inline size_t InlineSize(ElementaryType type, const TypeTable* type_table) {
+  switch (type) {
+    case ET_UTYPE:
+    case ET_BOOL:
+    case ET_CHAR:
+    case ET_UCHAR:
+      return 1;
+    case ET_SHORT:
+    case ET_USHORT:
+      return 2;
+    case ET_INT:
+    case ET_UINT:
+    case ET_FLOAT:
+    case ET_STRING:
+      return 4;
+    case ET_LONG:
+    case ET_ULONG:
+    case ET_DOUBLE:
+      return 8;
+    case ET_SEQUENCE:
+      switch (type_table->st) {
+        case ST_TABLE:
+        case ST_UNION:
+          return 4;
+        case ST_STRUCT:
+          return static_cast<size_t>(type_table->values[type_table->num_elems]);
+        default:
+          FLATBUFFERS_ASSERT(false);
+          return 1;
+      }
+    default:
+      FLATBUFFERS_ASSERT(false);
+      return 1;
+  }
+}
+
+inline int64_t LookupEnum(int64_t enum_val, const int64_t* values,
+                          size_t num_values) {
+  if (!values) return enum_val;
+  for (size_t i = 0; i < num_values; i++) {
+    if (enum_val == values[i]) return static_cast<int64_t>(i);
+  }
+  return -1;  // Unknown enum value.
+}
+
+template <typename T>
+const char* EnumName(T tval, const TypeTable* type_table) {
+  if (!type_table || !type_table->names) return nullptr;
+  auto i = LookupEnum(static_cast<int64_t>(tval), type_table->values,
+                      type_table->num_elems);
+  if (i >= 0 && i < static_cast<int64_t>(type_table->num_elems)) {
+    return type_table->names[i];
+  }
+  return nullptr;
+}
+
+void IterateObject(const uint8_t* obj, const TypeTable* type_table,
+                   IterationVisitor* visitor);
+
+inline void IterateValue(ElementaryType type, const uint8_t* val,
+                         const TypeTable* type_table, const uint8_t* prev_val,
+                         soffset_t vector_index, IterationVisitor* visitor) {
+  switch (type) {
+    case ET_UTYPE: {
+      auto tval = ReadScalar<uint8_t>(val);
+      visitor->UType(tval, EnumName(tval, type_table));
+      break;
+    }
+    case ET_BOOL: {
+      visitor->Bool(ReadScalar<uint8_t>(val) != 0);
+      break;
+    }
+    case ET_CHAR: {
+      auto tval = ReadScalar<int8_t>(val);
+      visitor->Char(tval, EnumName(tval, type_table));
+      break;
+    }
+    case ET_UCHAR: {
+      auto tval = ReadScalar<uint8_t>(val);
+      visitor->UChar(tval, EnumName(tval, type_table));
+      break;
+    }
+    case ET_SHORT: {
+      auto tval = ReadScalar<int16_t>(val);
+      visitor->Short(tval, EnumName(tval, type_table));
+      break;
+    }
+    case ET_USHORT: {
+      auto tval = ReadScalar<uint16_t>(val);
+      visitor->UShort(tval, EnumName(tval, type_table));
+      break;
+    }
+    case ET_INT: {
+      auto tval = ReadScalar<int32_t>(val);
+      visitor->Int(tval, EnumName(tval, type_table));
+      break;
+    }
+    case ET_UINT: {
+      auto tval = ReadScalar<uint32_t>(val);
+      visitor->UInt(tval, EnumName(tval, type_table));
+      break;
+    }
+    case ET_LONG: {
+      visitor->Long(ReadScalar<int64_t>(val));
+      break;
+    }
+    case ET_ULONG: {
+      visitor->ULong(ReadScalar<uint64_t>(val));
+      break;
+    }
+    case ET_FLOAT: {
+      visitor->Float(ReadScalar<float>(val));
+      break;
+    }
+    case ET_DOUBLE: {
+      visitor->Double(ReadScalar<double>(val));
+      break;
+    }
+    case ET_STRING: {
+      val += ReadScalar<uoffset_t>(val);
+      visitor->String(reinterpret_cast<const String*>(val));
+      break;
+    }
+    case ET_SEQUENCE: {
+      switch (type_table->st) {
+        case ST_TABLE:
+          val += ReadScalar<uoffset_t>(val);
+          IterateObject(val, type_table, visitor);
+          break;
+        case ST_STRUCT:
+          IterateObject(val, type_table, visitor);
+          break;
+        case ST_UNION: {
+          val += ReadScalar<uoffset_t>(val);
+          FLATBUFFERS_ASSERT(prev_val);
+          auto union_type = *prev_val;  // Always a uint8_t.
+          if (vector_index >= 0) {
+            auto type_vec = reinterpret_cast<const Vector<uint8_t>*>(prev_val);
+            union_type = type_vec->Get(static_cast<uoffset_t>(vector_index));
+          }
+          auto type_code_idx =
+              LookupEnum(union_type, type_table->values, type_table->num_elems);
+          if (type_code_idx >= 0 &&
+              type_code_idx < static_cast<int32_t>(type_table->num_elems)) {
+            auto type_code = type_table->type_codes[type_code_idx];
+            switch (type_code.base_type) {
+              case ET_SEQUENCE: {
+                auto ref = type_table->type_refs[type_code.sequence_ref]();
+                IterateObject(val, ref, visitor);
+                break;
+              }
+              case ET_STRING:
+                visitor->String(reinterpret_cast<const String*>(val));
+                break;
+              default:
+                visitor->Unknown(val);
+            }
+          } else {
+            visitor->Unknown(val);
+          }
+          break;
+        }
+        case ST_ENUM:
+          FLATBUFFERS_ASSERT(false);
+          break;
+      }
+      break;
+    }
+    default: {
+      visitor->Unknown(val);
+      break;
+    }
+  }
+}
+
+inline void IterateObject(const uint8_t* obj, const TypeTable* type_table,
+                          IterationVisitor* visitor) {
+  visitor->StartSequence();
+  const uint8_t* prev_val = nullptr;
+  size_t set_idx = 0;
+  size_t array_idx = 0;
+  for (size_t i = 0; i < type_table->num_elems; i++) {
+    auto type_code = type_table->type_codes[i];
+    auto type = static_cast<ElementaryType>(type_code.base_type);
+    auto is_repeating = type_code.is_repeating != 0;
+    auto ref_idx = type_code.sequence_ref;
+    const TypeTable* ref = nullptr;
+    if (ref_idx >= 0) {
+      ref = type_table->type_refs[ref_idx]();
+    }
+    auto name = type_table->names ? type_table->names[i] : nullptr;
+    const uint8_t* val = nullptr;
+    if (type_table->st == ST_TABLE) {
+      val = reinterpret_cast<const Table*>(obj)->GetAddressOf(
+          FieldIndexToOffset(static_cast<voffset_t>(i)));
+    } else {
+      val = obj + type_table->values[i];
+    }
+    visitor->Field(i, set_idx, type, is_repeating, ref, name, val);
+    if (val) {
+      set_idx++;
+      if (is_repeating) {
+        auto elem_ptr = val;
+        size_t size = 0;
+        if (type_table->st == ST_TABLE) {
+          // variable length vector
+          val += ReadScalar<uoffset_t>(val);
+          auto vec = reinterpret_cast<const Vector<uint8_t>*>(val);
+          elem_ptr = vec->Data();
+          size = vec->size();
+        } else {
+          // otherwise fixed size array
+          size = type_table->array_sizes[array_idx];
+          ++array_idx;
+        }
+        visitor->StartVector();
+        for (size_t j = 0; j < size; j++) {
+          visitor->Element(j, type, ref, elem_ptr);
+          IterateValue(type, elem_ptr, ref, prev_val, static_cast<soffset_t>(j),
+                       visitor);
+          elem_ptr += InlineSize(type, ref);
+        }
+        visitor->EndVector();
+      } else {
+        IterateValue(type, val, ref, prev_val, -1, visitor);
+      }
+    }
+    prev_val = val;
+  }
+  visitor->EndSequence();
+}
+
+inline void IterateFlatBuffer(const uint8_t* buffer,
+                              const TypeTable* type_table,
+                              IterationVisitor* callback) {
+  IterateObject(GetRoot<uint8_t>(buffer), type_table, callback);
+}
+
+// Outputting a Flatbuffer to a string. Tries to conform as close to JSON /
+// the output generated by idl_gen_text.cpp.
+
+struct ToStringVisitor : public IterationVisitor {
+  std::string s;
+  std::string d;
+  bool q;
+  std::string in;
+  size_t indent_level;
+  bool vector_delimited;
+  ToStringVisitor(std::string delimiter, bool quotes, std::string indent,
+                  bool vdelimited = true)
+      : d(delimiter),
+        q(quotes),
+        in(indent),
+        indent_level(0),
+        vector_delimited(vdelimited) {}
+  ToStringVisitor(std::string delimiter)
+      : d(delimiter),
+        q(false),
+        in(""),
+        indent_level(0),
+        vector_delimited(true) {}
+
+  void append_indent() {
+    for (size_t i = 0; i < indent_level; i++) {
+      s += in;
+    }
+  }
+
+  void StartSequence() {
+    s += "{";
+    s += d;
+    indent_level++;
+  }
+  void EndSequence() {
+    s += d;
+    indent_level--;
+    append_indent();
+    s += "}";
+  }
+  void Field(size_t /*field_idx*/, size_t set_idx, ElementaryType /*type*/,
+             bool /*is_vector*/, const TypeTable* /*type_table*/,
+             const char* name, const uint8_t* val) {
+    if (!val) return;
+    if (set_idx) {
+      s += ",";
+      s += d;
+    }
+    append_indent();
+    if (name) {
+      if (q) s += "\"";
+      s += name;
+      if (q) s += "\"";
+      s += ": ";
+    }
+  }
+  template <typename T>
+  void Named(T x, const char* name) {
+    if (name) {
+      if (q) s += "\"";
+      s += name;
+      if (q) s += "\"";
+    } else {
+      s += NumToString(x);
+    }
+  }
+  void UType(uint8_t x, const char* name) { Named(x, name); }
+  void Bool(bool x) { s += x ? "true" : "false"; }
+  void Char(int8_t x, const char* name) { Named(x, name); }
+  void UChar(uint8_t x, const char* name) { Named(x, name); }
+  void Short(int16_t x, const char* name) { Named(x, name); }
+  void UShort(uint16_t x, const char* name) { Named(x, name); }
+  void Int(int32_t x, const char* name) { Named(x, name); }
+  void UInt(uint32_t x, const char* name) { Named(x, name); }
+  void Long(int64_t x) { s += NumToString(x); }
+  void ULong(uint64_t x) { s += NumToString(x); }
+  void Float(float x) { s += NumToString(x); }
+  void Double(double x) { s += NumToString(x); }
+  void String(const struct String* str) {
+    EscapeString(str->c_str(), str->size(), &s, true, false);
+  }
+  void Unknown(const uint8_t*) { s += "(?)"; }
+  void StartVector() {
+    s += "[";
+    if (vector_delimited) {
+      s += d;
+      indent_level++;
+      append_indent();
+    } else {
+      s += " ";
+    }
+  }
+  void EndVector() {
+    if (vector_delimited) {
+      s += d;
+      indent_level--;
+      append_indent();
+    } else {
+      s += " ";
+    }
+    s += "]";
+  }
+  void Element(size_t i, ElementaryType /*type*/,
+               const TypeTable* /*type_table*/, const uint8_t* /*val*/) {
+    if (i) {
+      s += ",";
+      if (vector_delimited) {
+        s += d;
+        append_indent();
+      } else {
+        s += " ";
+      }
+    }
+  }
+};
+
+inline std::string FlatBufferToString(const uint8_t* buffer,
+                                      const TypeTable* type_table,
+                                      bool multi_line = false,
+                                      bool vector_delimited = true,
+                                      const std::string& indent = "",
+                                      bool quotes = false) {
+  ToStringVisitor tostring_visitor(multi_line ? "\n" : " ", quotes, indent,
+                                   vector_delimited);
+  IterateFlatBuffer(buffer, type_table, &tostring_visitor);
+  return tostring_visitor.s;
+}
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_MINIREFLECT_H_
diff --git a/external/flatbuffers/include/flatbuffers/pch/flatc_pch.h b/external/flatbuffers/include/flatbuffers/pch/flatc_pch.h
new file mode 100644
index 00000000..abdfdedb
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/pch/flatc_pch.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_FLATC_PCH_H_
+#define FLATBUFFERS_FLATC_PCH_H_
+
+// stl
+#include <cassert>
+#include <cmath>
+#include <functional>
+#include <iostream>
+#include <iterator>
+#include <set>
+#include <sstream>
+#include <tuple>
+#include <unordered_map>
+#include <unordered_set>
+
+// flatbuffers
+#include "flatbuffers/code_generators.h"
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/flexbuffers.h"
+#include "flatbuffers/idl.h"
+#include "flatbuffers/pch/pch.h"
+
+#endif  // FLATBUFFERS_FLATC_PCH_H_
diff --git a/external/flatbuffers/include/flatbuffers/pch/pch.h b/external/flatbuffers/include/flatbuffers/pch/pch.h
new file mode 100644
index 00000000..a7c48ea7
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/pch/pch.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_PCH_H_
+#define FLATBUFFERS_PCH_H_
+
+// stl
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <limits>
+#include <list>
+#include <map>
+#include <memory>
+#include <stack>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+// flatbuffers
+#include "flatbuffers/util.h"
+
+#endif  // FLATBUFFERS_PCH_H_
diff --git a/external/flatbuffers/include/flatbuffers/reflection.h b/external/flatbuffers/include/flatbuffers/reflection.h
new file mode 100644
index 00000000..bc8c2a92
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/reflection.h
@@ -0,0 +1,530 @@
+/*
+ * Copyright 2015 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_REFLECTION_H_
+#define FLATBUFFERS_REFLECTION_H_
+
+// This is somewhat of a circular dependency because flatc (and thus this
+// file) is needed to generate this header in the first place.
+// Should normally not be a problem since it can be generated by the
+// previous version of flatc whenever this code needs to change.
+// See scripts/generate_code.py for generation.
+#include "flatbuffers/reflection_generated.h"
+
+// Helper functionality for reflection.
+
+namespace flatbuffers {
+
+// ------------------------- GETTERS -------------------------
+
+constexpr bool IsScalar(reflection::BaseType t) {
+  return t >= reflection::UType && t <= reflection::Double;
+}
+constexpr bool IsInteger(reflection::BaseType t) {
+  return t >= reflection::UType && t <= reflection::ULong;
+}
+constexpr bool IsFloat(reflection::BaseType t) {
+  return t == reflection::Float || t == reflection::Double;
+}
+constexpr bool IsLong(reflection::BaseType t) {
+  return t == reflection::Long || t == reflection::ULong;
+}
+
+// This needs to correspond to the BaseType enum.
+constexpr size_t kBaseTypeSize[] = {
+    0,  // None
+    1,  // UType
+    1,  // Bool
+    1,  // Byte
+    1,  // UByte
+    2,  // Short
+    2,  // UShort
+    4,  // Int
+    4,  // UInt
+    8,  // Long
+    8,  // ULong
+    4,  // Float
+    8,  // Double
+    4,  // String
+    4,  // Vector
+    4,  // Obj
+    4,  // Union
+    0,  // Array. Only used in structs. 0 was chosen to prevent out-of-bounds
+        // errors.
+    8,  // Vector64
+
+    0  // MaxBaseType. This must be kept the last entry in this array.
+};
+static_assert(sizeof(kBaseTypeSize) / sizeof(size_t) ==
+                  reflection::MaxBaseType + 1,
+              "Size of sizes[] array does not match the count of BaseType "
+              "enum values.");
+
+// Size of a basic type, don't use with structs.
+constexpr size_t GetTypeSize(reflection::BaseType base_type) {
+  return kBaseTypeSize[base_type];
+}
+
+// Same as above, but now correctly returns the size of a struct if
+// the field (or vector element) is a struct.
+inline size_t GetTypeSizeInline(reflection::BaseType base_type, int type_index,
+                                const reflection::Schema& schema) {
+  if (base_type == reflection::Obj &&
+      schema.objects()->Get(type_index)->is_struct()) {
+    return schema.objects()->Get(type_index)->bytesize();
+  } else {
+    return GetTypeSize(base_type);
+  }
+}
+
+// Get the root, regardless of what type it is.
+inline Table* GetAnyRoot(uint8_t* const flatbuf) {
+  return GetMutableRoot<Table>(flatbuf);
+}
+
+inline const Table* GetAnyRoot(const uint8_t* const flatbuf) {
+  return GetRoot<Table>(flatbuf);
+}
+
+inline Table* GetAnySizePrefixedRoot(uint8_t* const flatbuf) {
+  return GetMutableSizePrefixedRoot<Table>(flatbuf);
+}
+
+inline const Table* GetAnySizePrefixedRoot(const uint8_t* const flatbuf) {
+  return GetSizePrefixedRoot<Table>(flatbuf);
+}
+
+// Get a field's default, if you know it's an integer, and its exact type.
+template <typename T>
+T GetFieldDefaultI(const reflection::Field& field) {
+  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
+  return static_cast<T>(field.default_integer());
+}
+
+// Get a field's default, if you know it's floating point and its exact type.
+template <typename T>
+T GetFieldDefaultF(const reflection::Field& field) {
+  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
+  return static_cast<T>(field.default_real());
+}
+
+// Get a field, if you know it's an integer, and its exact type.
+template <typename T>
+T GetFieldI(const Table& table, const reflection::Field& field) {
+  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
+  return table.GetField<T>(field.offset(),
+                           static_cast<T>(field.default_integer()));
+}
+
+// Get a field, if you know it's floating point and its exact type.
+template <typename T>
+T GetFieldF(const Table& table, const reflection::Field& field) {
+  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
+  return table.GetField<T>(field.offset(),
+                           static_cast<T>(field.default_real()));
+}
+
+// Get a field, if you know it's a string.
+inline const String* GetFieldS(const Table& table,
+                               const reflection::Field& field) {
+  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::String);
+  return table.GetPointer<const String*>(field.offset());
+}
+
+// Get a field, if you know it's a vector.
+template <typename T>
+Vector<T>* GetFieldV(const Table& table, const reflection::Field& field) {
+  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Vector &&
+                     sizeof(T) == GetTypeSize(field.type()->element()));
+  return table.GetPointer<Vector<T>*>(field.offset());
+}
+
+// Get a field, if you know it's a vector, generically.
+// To actually access elements, use the return value together with
+// field.type()->element() in any of GetAnyVectorElemI below etc.
+inline VectorOfAny* GetFieldAnyV(const Table& table,
+                                 const reflection::Field& field) {
+  return table.GetPointer<VectorOfAny*>(field.offset());
+}
+
+// Get a field, if you know it's a table.
+inline Table* GetFieldT(const Table& table, const reflection::Field& field) {
+  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj ||
+                     field.type()->base_type() == reflection::Union);
+  return table.GetPointer<Table*>(field.offset());
+}
+
+// Get a field, if you know it's a struct.
+inline const Struct* GetFieldStruct(const Table& table,
+                                    const reflection::Field& field) {
+  // TODO: This does NOT check if the field is a table or struct, but we'd need
+  // access to the schema to check the is_struct flag.
+  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj);
+  return table.GetStruct<const Struct*>(field.offset());
+}
+
+// Get a structure's field, if you know it's a struct.
+inline const Struct* GetFieldStruct(const Struct& structure,
+                                    const reflection::Field& field) {
+  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj);
+  return structure.GetStruct<const Struct*>(field.offset());
+}
+
+// Raw helper functions used below: get any value in memory as a 64bit int, a
+// double or a string.
+// All scalars get static_cast to an int64_t, strings use strtoull, every other
+// data type returns 0.
+int64_t GetAnyValueI(reflection::BaseType type, const uint8_t* data);
+// All scalars static cast to double, strings use strtod, every other data
+// type is 0.0.
+double GetAnyValueF(reflection::BaseType type, const uint8_t* data);
+// All scalars converted using stringstream, strings as-is, and all other
+// data types provide some level of debug-pretty-printing.
+std::string GetAnyValueS(reflection::BaseType type, const uint8_t* data,
+                         const reflection::Schema* schema, int type_index);
+
+// Get any table field as a 64bit int, regardless of what type it is.
+inline int64_t GetAnyFieldI(const Table& table,
+                            const reflection::Field& field) {
+  auto field_ptr = table.GetAddressOf(field.offset());
+  return field_ptr ? GetAnyValueI(field.type()->base_type(), field_ptr)
+                   : field.default_integer();
+}
+
+// Get any table field as a double, regardless of what type it is.
+inline double GetAnyFieldF(const Table& table, const reflection::Field& field) {
+  auto field_ptr = table.GetAddressOf(field.offset());
+  return field_ptr ? GetAnyValueF(field.type()->base_type(), field_ptr)
+                   : field.default_real();
+}
+
+// Get any table field as a string, regardless of what type it is.
+// You may pass nullptr for the schema if you don't care to have fields that
+// are of table type pretty-printed.
+inline std::string GetAnyFieldS(const Table& table,
+                                const reflection::Field& field,
+                                const reflection::Schema* schema) {
+  auto field_ptr = table.GetAddressOf(field.offset());
+  return field_ptr ? GetAnyValueS(field.type()->base_type(), field_ptr, schema,
+                                  field.type()->index())
+                   : "";
+}
+
+// Get any struct field as a 64bit int, regardless of what type it is.
+inline int64_t GetAnyFieldI(const Struct& st, const reflection::Field& field) {
+  return GetAnyValueI(field.type()->base_type(),
+                      st.GetAddressOf(field.offset()));
+}
+
+// Get any struct field as a double, regardless of what type it is.
+inline double GetAnyFieldF(const Struct& st, const reflection::Field& field) {
+  return GetAnyValueF(field.type()->base_type(),
+                      st.GetAddressOf(field.offset()));
+}
+
+// Get any struct field as a string, regardless of what type it is.
+inline std::string GetAnyFieldS(const Struct& st,
+                                const reflection::Field& field) {
+  return GetAnyValueS(field.type()->base_type(),
+                      st.GetAddressOf(field.offset()), nullptr, -1);
+}
+
+// Get any vector element as a 64bit int, regardless of what type it is.
+inline int64_t GetAnyVectorElemI(const VectorOfAny* vec,
+                                 reflection::BaseType elem_type, size_t i) {
+  return GetAnyValueI(elem_type, vec->Data() + GetTypeSize(elem_type) * i);
+}
+
+// Get any vector element as a double, regardless of what type it is.
+inline double GetAnyVectorElemF(const VectorOfAny* vec,
+                                reflection::BaseType elem_type, size_t i) {
+  return GetAnyValueF(elem_type, vec->Data() + GetTypeSize(elem_type) * i);
+}
+
+// Get any vector element as a string, regardless of what type it is.
+inline std::string GetAnyVectorElemS(const VectorOfAny* vec,
+                                     reflection::BaseType elem_type, size_t i) {
+  return GetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i,
+                      nullptr, -1);
+}
+
+// Get a vector element that's a table/string/vector from a generic vector.
+// Pass Table/String/VectorOfAny as template parameter.
+// Warning: does no typechecking.
+template <typename T>
+T* GetAnyVectorElemPointer(const VectorOfAny* vec, size_t i) {
+  auto elem_ptr = vec->Data() + sizeof(uoffset_t) * i;
+  return reinterpret_cast<T*>(elem_ptr + ReadScalar<uoffset_t>(elem_ptr));
+}
+
+// Get the inline-address of a vector element. Useful for Structs (pass Struct
+// as template arg), or being able to address a range of scalars in-line.
+// Get elem_size from GetTypeSizeInline().
+// Note: little-endian data on all platforms, use EndianScalar() instead of
+// raw pointer access with scalars).
+template <typename T>
+T* GetAnyVectorElemAddressOf(const VectorOfAny* vec, size_t i,
+                             size_t elem_size) {
+  return reinterpret_cast<T*>(vec->Data() + elem_size * i);
+}
+
+// Similarly, for elements of tables.
+template <typename T>
+T* GetAnyFieldAddressOf(const Table& table, const reflection::Field& field) {
+  return reinterpret_cast<T*>(table.GetAddressOf(field.offset()));
+}
+
+// Similarly, for elements of structs.
+template <typename T>
+T* GetAnyFieldAddressOf(const Struct& st, const reflection::Field& field) {
+  return reinterpret_cast<T*>(st.GetAddressOf(field.offset()));
+}
+
+// Loop over all the fields of the provided `object` and call `func` on each one
+// in increasing order by their field->id(). If `reverse` is true, `func` is
+// called in descending order
+void ForAllFields(const reflection::Object* object, bool reverse,
+                  std::function<void(const reflection::Field*)> func);
+
+// ------------------------- SETTERS -------------------------
+
+// Set any scalar field, if you know its exact type.
+template <typename T>
+bool SetField(Table* table, const reflection::Field& field, T val) {
+  reflection::BaseType type = field.type()->base_type();
+  if (!IsScalar(type)) {
+    return false;
+  }
+  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(type));
+  T def;
+  if (IsInteger(type)) {
+    def = GetFieldDefaultI<T>(field);
+  } else {
+    FLATBUFFERS_ASSERT(IsFloat(type));
+    def = GetFieldDefaultF<T>(field);
+  }
+  return table->SetField(field.offset(), val, def);
+}
+
+// Raw helper functions used below: set any value in memory as a 64bit int, a
+// double or a string.
+// These work for all scalar values, but do nothing for other data types.
+// To set a string, see SetString below.
+void SetAnyValueI(reflection::BaseType type, uint8_t* data, int64_t val);
+void SetAnyValueF(reflection::BaseType type, uint8_t* data, double val);
+void SetAnyValueS(reflection::BaseType type, uint8_t* data, const char* val);
+
+// Set any table field as a 64bit int, regardless of type what it is.
+inline bool SetAnyFieldI(Table* table, const reflection::Field& field,
+                         int64_t val) {
+  auto field_ptr = table->GetAddressOf(field.offset());
+  if (!field_ptr) return val == GetFieldDefaultI<int64_t>(field);
+  SetAnyValueI(field.type()->base_type(), field_ptr, val);
+  return true;
+}
+
+// Set any table field as a double, regardless of what type it is.
+inline bool SetAnyFieldF(Table* table, const reflection::Field& field,
+                         double val) {
+  auto field_ptr = table->GetAddressOf(field.offset());
+  if (!field_ptr) return val == GetFieldDefaultF<double>(field);
+  SetAnyValueF(field.type()->base_type(), field_ptr, val);
+  return true;
+}
+
+// Set any table field as a string, regardless of what type it is.
+inline bool SetAnyFieldS(Table* table, const reflection::Field& field,
+                         const char* val) {
+  auto field_ptr = table->GetAddressOf(field.offset());
+  if (!field_ptr) return false;
+  SetAnyValueS(field.type()->base_type(), field_ptr, val);
+  return true;
+}
+
+// Set any struct field as a 64bit int, regardless of type what it is.
+inline void SetAnyFieldI(Struct* st, const reflection::Field& field,
+                         int64_t val) {
+  SetAnyValueI(field.type()->base_type(), st->GetAddressOf(field.offset()),
+               val);
+}
+
+// Set any struct field as a double, regardless of type what it is.
+inline void SetAnyFieldF(Struct* st, const reflection::Field& field,
+                         double val) {
+  SetAnyValueF(field.type()->base_type(), st->GetAddressOf(field.offset()),
+               val);
+}
+
+// Set any struct field as a string, regardless of type what it is.
+inline void SetAnyFieldS(Struct* st, const reflection::Field& field,
+                         const char* val) {
+  SetAnyValueS(field.type()->base_type(), st->GetAddressOf(field.offset()),
+               val);
+}
+
+// Set any vector element as a 64bit int, regardless of type what it is.
+inline void SetAnyVectorElemI(VectorOfAny* vec, reflection::BaseType elem_type,
+                              size_t i, int64_t val) {
+  SetAnyValueI(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
+}
+
+// Set any vector element as a double, regardless of type what it is.
+inline void SetAnyVectorElemF(VectorOfAny* vec, reflection::BaseType elem_type,
+                              size_t i, double val) {
+  SetAnyValueF(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
+}
+
+// Set any vector element as a string, regardless of type what it is.
+inline void SetAnyVectorElemS(VectorOfAny* vec, reflection::BaseType elem_type,
+                              size_t i, const char* val) {
+  SetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
+}
+
+// ------------------------- RESIZING SETTERS -------------------------
+
+// "smart" pointer for use with resizing vectors: turns a pointer inside
+// a vector into a relative offset, such that it is not affected by resizes.
+template <typename T, typename U>
+class pointer_inside_vector {
+ public:
+  pointer_inside_vector(T* ptr, std::vector<U>& vec)
+      : offset_(reinterpret_cast<uint8_t*>(ptr) -
+                reinterpret_cast<uint8_t*>(vec.data())),
+        vec_(vec) {}
+
+  T* operator*() const {
+    return reinterpret_cast<T*>(reinterpret_cast<uint8_t*>(vec_.data()) +
+                                offset_);
+  }
+  T* operator->() const { return operator*(); }
+
+ private:
+  size_t offset_;
+  std::vector<U>& vec_;
+};
+
+// Helper to create the above easily without specifying template args.
+template <typename T, typename U>
+pointer_inside_vector<T, U> piv(T* ptr, std::vector<U>& vec) {
+  return pointer_inside_vector<T, U>(ptr, vec);
+}
+
+constexpr const char* UnionTypeFieldSuffix() { return "_type"; }
+
+// Helper to figure out the actual table type a union refers to.
+inline const reflection::Object& GetUnionType(
+    const reflection::Schema& schema, const reflection::Object& parent,
+    const reflection::Field& unionfield, const Table& table) {
+  auto enumdef = schema.enums()->Get(unionfield.type()->index());
+  // TODO: this is clumsy and slow, but no other way to find it?
+  auto type_field = parent.fields()->LookupByKey(
+      (unionfield.name()->str() + UnionTypeFieldSuffix()).c_str());
+  FLATBUFFERS_ASSERT(type_field);
+  auto union_type = GetFieldI<uint8_t>(table, *type_field);
+  auto enumval = enumdef->values()->LookupByKey(union_type);
+  return *schema.objects()->Get(enumval->union_type()->index());
+}
+
+// Changes the contents of a string inside a FlatBuffer. FlatBuffer must
+// live inside a std::vector so we can resize the buffer if needed.
+// "str" must live inside "flatbuf" and may be invalidated after this call.
+// If your FlatBuffer's root table is not the schema's root table, you should
+// pass in your root_table type as well.
+void SetString(const reflection::Schema& schema, const std::string& val,
+               const String* str, std::vector<uint8_t>* flatbuf,
+               const reflection::Object* root_table = nullptr);
+
+// Resizes a flatbuffers::Vector inside a FlatBuffer. FlatBuffer must
+// live inside a std::vector so we can resize the buffer if needed.
+// "vec" must live inside "flatbuf" and may be invalidated after this call.
+// If your FlatBuffer's root table is not the schema's root table, you should
+// pass in your root_table type as well.
+uint8_t* ResizeAnyVector(const reflection::Schema& schema, uoffset_t newsize,
+                         const VectorOfAny* vec, uoffset_t num_elems,
+                         uoffset_t elem_size, std::vector<uint8_t>* flatbuf,
+                         const reflection::Object* root_table = nullptr);
+
+template <typename T>
+void ResizeVector(const reflection::Schema& schema, uoffset_t newsize, T val,
+                  const Vector<T>* vec, std::vector<uint8_t>* flatbuf,
+                  const reflection::Object* root_table = nullptr) {
+  auto delta_elem = static_cast<int>(newsize) - static_cast<int>(vec->size());
+  auto newelems = ResizeAnyVector(
+      schema, newsize, reinterpret_cast<const VectorOfAny*>(vec), vec->size(),
+      static_cast<uoffset_t>(sizeof(T)), flatbuf, root_table);
+  // Set new elements to "val".
+  for (int i = 0; i < delta_elem; i++) {
+    auto loc = newelems + i * sizeof(T);
+    auto is_scalar = flatbuffers::is_scalar<T>::value;
+    if (is_scalar) {
+      WriteScalar(loc, val);
+    } else {  // struct
+      *reinterpret_cast<T*>(loc) = val;
+    }
+  }
+}
+
+// Adds any new data (in the form of a new FlatBuffer) to an existing
+// FlatBuffer. This can be used when any of the above methods are not
+// sufficient, in particular for adding new tables and new fields.
+// This is potentially slightly less efficient than a FlatBuffer constructed
+// in one piece, since the new FlatBuffer doesn't share any vtables with the
+// existing one.
+// The return value can now be set using Vector::MutateOffset or SetFieldT
+// below.
+const uint8_t* AddFlatBuffer(std::vector<uint8_t>& flatbuf,
+                             const uint8_t* newbuf, size_t newlen);
+
+inline bool SetFieldT(Table* table, const reflection::Field& field,
+                      const uint8_t* val) {
+  FLATBUFFERS_ASSERT(sizeof(uoffset_t) ==
+                     GetTypeSize(field.type()->base_type()));
+  return table->SetPointer(field.offset(), val);
+}
+
+// ------------------------- COPYING -------------------------
+
+// Generic copying of tables from a FlatBuffer into a FlatBuffer builder.
+// Can be used to do any kind of merging/selecting you may want to do out
+// of existing buffers. Also useful to reconstruct a whole buffer if the
+// above resizing functionality has introduced garbage in a buffer you want
+// to remove.
+// Note: this does not deal with DAGs correctly. If the table passed forms a
+// DAG, the copy will be a tree instead (with duplicates). Strings can be
+// shared however, by passing true for use_string_pooling.
+
+Offset<const Table*> CopyTable(FlatBufferBuilder& fbb,
+                               const reflection::Schema& schema,
+                               const reflection::Object& objectdef,
+                               const Table& table,
+                               bool use_string_pooling = false);
+
+// Verifies the provided flatbuffer using reflection.
+// root should point to the root type for this flatbuffer.
+// buf should point to the start of flatbuffer data.
+// length specifies the size of the flatbuffer data.
+bool Verify(const reflection::Schema& schema, const reflection::Object& root,
+            const uint8_t* buf, size_t length, uoffset_t max_depth = 64,
+            uoffset_t max_tables = 1000000);
+
+bool VerifySizePrefixed(const reflection::Schema& schema,
+                        const reflection::Object& root, const uint8_t* buf,
+                        size_t length, uoffset_t max_depth = 64,
+                        uoffset_t max_tables = 1000000);
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_REFLECTION_H_
diff --git a/external/flatbuffers/include/flatbuffers/reflection_generated.h b/external/flatbuffers/include/flatbuffers/reflection_generated.h
new file mode 100644
index 00000000..32ee1aa6
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/reflection_generated.h
@@ -0,0 +1,1541 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
+#define FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+              FLATBUFFERS_VERSION_MINOR == 12 &&
+              FLATBUFFERS_VERSION_REVISION == 19,
+             "Non-compatible flatbuffers version included");
+
+namespace reflection {
+
+struct Type;
+struct TypeBuilder;
+
+struct KeyValue;
+struct KeyValueBuilder;
+
+struct EnumVal;
+struct EnumValBuilder;
+
+struct Enum;
+struct EnumBuilder;
+
+struct Field;
+struct FieldBuilder;
+
+struct Object;
+struct ObjectBuilder;
+
+struct RPCCall;
+struct RPCCallBuilder;
+
+struct Service;
+struct ServiceBuilder;
+
+struct SchemaFile;
+struct SchemaFileBuilder;
+
+struct Schema;
+struct SchemaBuilder;
+
+enum BaseType {
+  None = 0,
+  UType = 1,
+  Bool = 2,
+  Byte = 3,
+  UByte = 4,
+  Short = 5,
+  UShort = 6,
+  Int = 7,
+  UInt = 8,
+  Long = 9,
+  ULong = 10,
+  Float = 11,
+  Double = 12,
+  String = 13,
+  Vector = 14,
+  Obj = 15,
+  Union = 16,
+  Array = 17,
+  Vector64 = 18,
+  MaxBaseType = 19
+};
+
+inline const BaseType (&EnumValuesBaseType())[20] {
+  static const BaseType values[] = {
+    None,
+    UType,
+    Bool,
+    Byte,
+    UByte,
+    Short,
+    UShort,
+    Int,
+    UInt,
+    Long,
+    ULong,
+    Float,
+    Double,
+    String,
+    Vector,
+    Obj,
+    Union,
+    Array,
+    Vector64,
+    MaxBaseType
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesBaseType() {
+  static const char * const names[21] = {
+    "None",
+    "UType",
+    "Bool",
+    "Byte",
+    "UByte",
+    "Short",
+    "UShort",
+    "Int",
+    "UInt",
+    "Long",
+    "ULong",
+    "Float",
+    "Double",
+    "String",
+    "Vector",
+    "Obj",
+    "Union",
+    "Array",
+    "Vector64",
+    "MaxBaseType",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameBaseType(BaseType e) {
+  if (::flatbuffers::IsOutRange(e, None, MaxBaseType)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesBaseType()[index];
+}
+
+/// New schema language features that are not supported by old code generators.
+enum AdvancedFeatures {
+  AdvancedArrayFeatures = 1ULL,
+  AdvancedUnionFeatures = 2ULL,
+  OptionalScalars = 4ULL,
+  DefaultVectorsAndStrings = 8ULL
+};
+
+inline const AdvancedFeatures (&EnumValuesAdvancedFeatures())[4] {
+  static const AdvancedFeatures values[] = {
+    AdvancedArrayFeatures,
+    AdvancedUnionFeatures,
+    OptionalScalars,
+    DefaultVectorsAndStrings
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesAdvancedFeatures() {
+  static const char * const names[9] = {
+    "AdvancedArrayFeatures",
+    "AdvancedUnionFeatures",
+    "",
+    "OptionalScalars",
+    "",
+    "",
+    "",
+    "DefaultVectorsAndStrings",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameAdvancedFeatures(AdvancedFeatures e) {
+  if (::flatbuffers::IsOutRange(e, AdvancedArrayFeatures, DefaultVectorsAndStrings)) return "";
+  const size_t index = static_cast<size_t>(e) - static_cast<size_t>(AdvancedArrayFeatures);
+  return EnumNamesAdvancedFeatures()[index];
+}
+
+struct Type FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef TypeBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE_TYPE = 4,
+    VT_ELEMENT = 6,
+    VT_INDEX = 8,
+    VT_FIXED_LENGTH = 10,
+    VT_BASE_SIZE = 12,
+    VT_ELEMENT_SIZE = 14
+  };
+  reflection::BaseType base_type() const {
+    return static_cast<reflection::BaseType>(GetField<int8_t>(VT_BASE_TYPE, 0));
+  }
+  reflection::BaseType element() const {
+    return static_cast<reflection::BaseType>(GetField<int8_t>(VT_ELEMENT, 0));
+  }
+  int32_t index() const {
+    return GetField<int32_t>(VT_INDEX, -1);
+  }
+  uint16_t fixed_length() const {
+    return GetField<uint16_t>(VT_FIXED_LENGTH, 0);
+  }
+  /// The size (octets) of the `base_type` field.
+  uint32_t base_size() const {
+    return GetField<uint32_t>(VT_BASE_SIZE, 4);
+  }
+  /// The size (octets) of the `element` field, if present.
+  uint32_t element_size() const {
+    return GetField<uint32_t>(VT_ELEMENT_SIZE, 0);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int8_t>(verifier, VT_BASE_TYPE, 1) &&
+           VerifyField<int8_t>(verifier, VT_ELEMENT, 1) &&
+           VerifyField<int32_t>(verifier, VT_INDEX, 4) &&
+           VerifyField<uint16_t>(verifier, VT_FIXED_LENGTH, 2) &&
+           VerifyField<uint32_t>(verifier, VT_BASE_SIZE, 4) &&
+           VerifyField<uint32_t>(verifier, VT_ELEMENT_SIZE, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct TypeBuilder {
+  typedef Type Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_base_type(reflection::BaseType base_type) {
+    fbb_.AddElement<int8_t>(Type::VT_BASE_TYPE, static_cast<int8_t>(base_type), 0);
+  }
+  void add_element(reflection::BaseType element) {
+    fbb_.AddElement<int8_t>(Type::VT_ELEMENT, static_cast<int8_t>(element), 0);
+  }
+  void add_index(int32_t index) {
+    fbb_.AddElement<int32_t>(Type::VT_INDEX, index, -1);
+  }
+  void add_fixed_length(uint16_t fixed_length) {
+    fbb_.AddElement<uint16_t>(Type::VT_FIXED_LENGTH, fixed_length, 0);
+  }
+  void add_base_size(uint32_t base_size) {
+    fbb_.AddElement<uint32_t>(Type::VT_BASE_SIZE, base_size, 4);
+  }
+  void add_element_size(uint32_t element_size) {
+    fbb_.AddElement<uint32_t>(Type::VT_ELEMENT_SIZE, element_size, 0);
+  }
+  explicit TypeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Type> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Type>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Type> CreateType(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    reflection::BaseType base_type = reflection::None,
+    reflection::BaseType element = reflection::None,
+    int32_t index = -1,
+    uint16_t fixed_length = 0,
+    uint32_t base_size = 4,
+    uint32_t element_size = 0) {
+  TypeBuilder builder_(_fbb);
+  builder_.add_element_size(element_size);
+  builder_.add_base_size(base_size);
+  builder_.add_index(index);
+  builder_.add_fixed_length(fixed_length);
+  builder_.add_element(element);
+  builder_.add_base_type(base_type);
+  return builder_.Finish();
+}
+
+struct KeyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef KeyValueBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_KEY = 4,
+    VT_VALUE = 6
+  };
+  const ::flatbuffers::String *key() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_KEY);
+  }
+  bool KeyCompareLessThan(const KeyValue * const o) const {
+    return *key() < *o->key();
+  }
+  int KeyCompareWithValue(const char *_key) const {
+    return strcmp(key()->c_str(), _key);
+  }
+  template<typename StringType>
+  int KeyCompareWithValue(const StringType& _key) const {
+    if (key()->c_str() < _key) return -1;
+    if (_key < key()->c_str()) return 1;
+    return 0;
+  }
+  const ::flatbuffers::String *value() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffsetRequired(verifier, VT_KEY) &&
+           verifier.VerifyString(key()) &&
+           VerifyOffset(verifier, VT_VALUE) &&
+           verifier.VerifyString(value()) &&
+           verifier.EndTable();
+  }
+};
+
+struct KeyValueBuilder {
+  typedef KeyValue Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_key(::flatbuffers::Offset<::flatbuffers::String> key) {
+    fbb_.AddOffset(KeyValue::VT_KEY, key);
+  }
+  void add_value(::flatbuffers::Offset<::flatbuffers::String> value) {
+    fbb_.AddOffset(KeyValue::VT_VALUE, value);
+  }
+  explicit KeyValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<KeyValue> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<KeyValue>(end);
+    fbb_.Required(o, KeyValue::VT_KEY);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<KeyValue> CreateKeyValue(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> key = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> value = 0) {
+  KeyValueBuilder builder_(_fbb);
+  builder_.add_value(value);
+  builder_.add_key(key);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<KeyValue> CreateKeyValueDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *key = nullptr,
+    const char *value = nullptr) {
+  auto key__ = key ? _fbb.CreateString(key) : 0;
+  auto value__ = value ? _fbb.CreateString(value) : 0;
+  return reflection::CreateKeyValue(
+      _fbb,
+      key__,
+      value__);
+}
+
+struct EnumVal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef EnumValBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_VALUE = 6,
+    VT_UNION_TYPE = 10,
+    VT_DOCUMENTATION = 12,
+    VT_ATTRIBUTES = 14
+  };
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
+  }
+  int64_t value() const {
+    return GetField<int64_t>(VT_VALUE, 0);
+  }
+  bool KeyCompareLessThan(const EnumVal * const o) const {
+    return value() < o->value();
+  }
+  int KeyCompareWithValue(int64_t _value) const {
+    return static_cast<int>(value() > _value) - static_cast<int>(value() < _value);
+  }
+  const reflection::Type *union_type() const {
+    return GetPointer<const reflection::Type *>(VT_UNION_TYPE);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffsetRequired(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyField<int64_t>(verifier, VT_VALUE, 8) &&
+           VerifyOffset(verifier, VT_UNION_TYPE) &&
+           verifier.VerifyTable(union_type()) &&
+           VerifyOffset(verifier, VT_DOCUMENTATION) &&
+           verifier.VerifyVector(documentation()) &&
+           verifier.VerifyVectorOfStrings(documentation()) &&
+           VerifyOffset(verifier, VT_ATTRIBUTES) &&
+           verifier.VerifyVector(attributes()) &&
+           verifier.VerifyVectorOfTables(attributes()) &&
+           verifier.EndTable();
+  }
+};
+
+struct EnumValBuilder {
+  typedef EnumVal Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
+    fbb_.AddOffset(EnumVal::VT_NAME, name);
+  }
+  void add_value(int64_t value) {
+    fbb_.AddElement<int64_t>(EnumVal::VT_VALUE, value, 0);
+  }
+  void add_union_type(::flatbuffers::Offset<reflection::Type> union_type) {
+    fbb_.AddOffset(EnumVal::VT_UNION_TYPE, union_type);
+  }
+  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
+    fbb_.AddOffset(EnumVal::VT_DOCUMENTATION, documentation);
+  }
+  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
+    fbb_.AddOffset(EnumVal::VT_ATTRIBUTES, attributes);
+  }
+  explicit EnumValBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<EnumVal> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<EnumVal>(end);
+    fbb_.Required(o, EnumVal::VT_NAME);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<EnumVal> CreateEnumVal(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
+    int64_t value = 0,
+    ::flatbuffers::Offset<reflection::Type> union_type = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0) {
+  EnumValBuilder builder_(_fbb);
+  builder_.add_value(value);
+  builder_.add_attributes(attributes);
+  builder_.add_documentation(documentation);
+  builder_.add_union_type(union_type);
+  builder_.add_name(name);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<EnumVal> CreateEnumValDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *name = nullptr,
+    int64_t value = 0,
+    ::flatbuffers::Offset<reflection::Type> union_type = 0,
+    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
+    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
+  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
+  return reflection::CreateEnumVal(
+      _fbb,
+      name__,
+      value,
+      union_type,
+      documentation__,
+      attributes__);
+}
+
+struct Enum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef EnumBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_VALUES = 6,
+    VT_IS_UNION = 8,
+    VT_UNDERLYING_TYPE = 10,
+    VT_ATTRIBUTES = 12,
+    VT_DOCUMENTATION = 14,
+    VT_DECLARATION_FILE = 16
+  };
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
+  }
+  bool KeyCompareLessThan(const Enum * const o) const {
+    return *name() < *o->name();
+  }
+  int KeyCompareWithValue(const char *_name) const {
+    return strcmp(name()->c_str(), _name);
+  }
+  template<typename StringType>
+  int KeyCompareWithValue(const StringType& _name) const {
+    if (name()->c_str() < _name) return -1;
+    if (_name < name()->c_str()) return 1;
+    return 0;
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>> *values() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>> *>(VT_VALUES);
+  }
+  bool is_union() const {
+    return GetField<uint8_t>(VT_IS_UNION, 0) != 0;
+  }
+  const reflection::Type *underlying_type() const {
+    return GetPointer<const reflection::Type *>(VT_UNDERLYING_TYPE);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
+  }
+  /// File that this Enum is declared in.
+  const ::flatbuffers::String *declaration_file() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffsetRequired(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyOffsetRequired(verifier, VT_VALUES) &&
+           verifier.VerifyVector(values()) &&
+           verifier.VerifyVectorOfTables(values()) &&
+           VerifyField<uint8_t>(verifier, VT_IS_UNION, 1) &&
+           VerifyOffsetRequired(verifier, VT_UNDERLYING_TYPE) &&
+           verifier.VerifyTable(underlying_type()) &&
+           VerifyOffset(verifier, VT_ATTRIBUTES) &&
+           verifier.VerifyVector(attributes()) &&
+           verifier.VerifyVectorOfTables(attributes()) &&
+           VerifyOffset(verifier, VT_DOCUMENTATION) &&
+           verifier.VerifyVector(documentation()) &&
+           verifier.VerifyVectorOfStrings(documentation()) &&
+           VerifyOffset(verifier, VT_DECLARATION_FILE) &&
+           verifier.VerifyString(declaration_file()) &&
+           verifier.EndTable();
+  }
+};
+
+struct EnumBuilder {
+  typedef Enum Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
+    fbb_.AddOffset(Enum::VT_NAME, name);
+  }
+  void add_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>>> values) {
+    fbb_.AddOffset(Enum::VT_VALUES, values);
+  }
+  void add_is_union(bool is_union) {
+    fbb_.AddElement<uint8_t>(Enum::VT_IS_UNION, static_cast<uint8_t>(is_union), 0);
+  }
+  void add_underlying_type(::flatbuffers::Offset<reflection::Type> underlying_type) {
+    fbb_.AddOffset(Enum::VT_UNDERLYING_TYPE, underlying_type);
+  }
+  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
+    fbb_.AddOffset(Enum::VT_ATTRIBUTES, attributes);
+  }
+  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
+    fbb_.AddOffset(Enum::VT_DOCUMENTATION, documentation);
+  }
+  void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
+    fbb_.AddOffset(Enum::VT_DECLARATION_FILE, declaration_file);
+  }
+  explicit EnumBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Enum> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Enum>(end);
+    fbb_.Required(o, Enum::VT_NAME);
+    fbb_.Required(o, Enum::VT_VALUES);
+    fbb_.Required(o, Enum::VT_UNDERLYING_TYPE);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Enum> CreateEnum(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>>> values = 0,
+    bool is_union = false,
+    ::flatbuffers::Offset<reflection::Type> underlying_type = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
+  EnumBuilder builder_(_fbb);
+  builder_.add_declaration_file(declaration_file);
+  builder_.add_documentation(documentation);
+  builder_.add_attributes(attributes);
+  builder_.add_underlying_type(underlying_type);
+  builder_.add_values(values);
+  builder_.add_name(name);
+  builder_.add_is_union(is_union);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Enum> CreateEnumDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *name = nullptr,
+    std::vector<::flatbuffers::Offset<reflection::EnumVal>> *values = nullptr,
+    bool is_union = false,
+    ::flatbuffers::Offset<reflection::Type> underlying_type = 0,
+    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
+    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
+    const char *declaration_file = nullptr) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto values__ = values ? _fbb.CreateVectorOfSortedTables<reflection::EnumVal>(values) : 0;
+  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
+  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
+  auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
+  return reflection::CreateEnum(
+      _fbb,
+      name__,
+      values__,
+      is_union,
+      underlying_type,
+      attributes__,
+      documentation__,
+      declaration_file__);
+}
+
+struct Field FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef FieldBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_TYPE = 6,
+    VT_ID = 8,
+    VT_OFFSET = 10,
+    VT_DEFAULT_INTEGER = 12,
+    VT_DEFAULT_REAL = 14,
+    VT_DEPRECATED = 16,
+    VT_REQUIRED = 18,
+    VT_KEY = 20,
+    VT_ATTRIBUTES = 22,
+    VT_DOCUMENTATION = 24,
+    VT_OPTIONAL = 26,
+    VT_PADDING = 28,
+    VT_OFFSET64 = 30
+  };
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
+  }
+  bool KeyCompareLessThan(const Field * const o) const {
+    return *name() < *o->name();
+  }
+  int KeyCompareWithValue(const char *_name) const {
+    return strcmp(name()->c_str(), _name);
+  }
+  template<typename StringType>
+  int KeyCompareWithValue(const StringType& _name) const {
+    if (name()->c_str() < _name) return -1;
+    if (_name < name()->c_str()) return 1;
+    return 0;
+  }
+  const reflection::Type *type() const {
+    return GetPointer<const reflection::Type *>(VT_TYPE);
+  }
+  uint16_t id() const {
+    return GetField<uint16_t>(VT_ID, 0);
+  }
+  uint16_t offset() const {
+    return GetField<uint16_t>(VT_OFFSET, 0);
+  }
+  int64_t default_integer() const {
+    return GetField<int64_t>(VT_DEFAULT_INTEGER, 0);
+  }
+  double default_real() const {
+    return GetField<double>(VT_DEFAULT_REAL, 0.0);
+  }
+  bool deprecated() const {
+    return GetField<uint8_t>(VT_DEPRECATED, 0) != 0;
+  }
+  bool required() const {
+    return GetField<uint8_t>(VT_REQUIRED, 0) != 0;
+  }
+  bool key() const {
+    return GetField<uint8_t>(VT_KEY, 0) != 0;
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
+  }
+  bool optional() const {
+    return GetField<uint8_t>(VT_OPTIONAL, 0) != 0;
+  }
+  /// Number of padding octets to always add after this field. Structs only.
+  uint16_t padding() const {
+    return GetField<uint16_t>(VT_PADDING, 0);
+  }
+  /// If the field uses 64-bit offsets.
+  bool offset64() const {
+    return GetField<uint8_t>(VT_OFFSET64, 0) != 0;
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffsetRequired(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyOffsetRequired(verifier, VT_TYPE) &&
+           verifier.VerifyTable(type()) &&
+           VerifyField<uint16_t>(verifier, VT_ID, 2) &&
+           VerifyField<uint16_t>(verifier, VT_OFFSET, 2) &&
+           VerifyField<int64_t>(verifier, VT_DEFAULT_INTEGER, 8) &&
+           VerifyField<double>(verifier, VT_DEFAULT_REAL, 8) &&
+           VerifyField<uint8_t>(verifier, VT_DEPRECATED, 1) &&
+           VerifyField<uint8_t>(verifier, VT_REQUIRED, 1) &&
+           VerifyField<uint8_t>(verifier, VT_KEY, 1) &&
+           VerifyOffset(verifier, VT_ATTRIBUTES) &&
+           verifier.VerifyVector(attributes()) &&
+           verifier.VerifyVectorOfTables(attributes()) &&
+           VerifyOffset(verifier, VT_DOCUMENTATION) &&
+           verifier.VerifyVector(documentation()) &&
+           verifier.VerifyVectorOfStrings(documentation()) &&
+           VerifyField<uint8_t>(verifier, VT_OPTIONAL, 1) &&
+           VerifyField<uint16_t>(verifier, VT_PADDING, 2) &&
+           VerifyField<uint8_t>(verifier, VT_OFFSET64, 1) &&
+           verifier.EndTable();
+  }
+};
+
+struct FieldBuilder {
+  typedef Field Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
+    fbb_.AddOffset(Field::VT_NAME, name);
+  }
+  void add_type(::flatbuffers::Offset<reflection::Type> type) {
+    fbb_.AddOffset(Field::VT_TYPE, type);
+  }
+  void add_id(uint16_t id) {
+    fbb_.AddElement<uint16_t>(Field::VT_ID, id, 0);
+  }
+  void add_offset(uint16_t offset) {
+    fbb_.AddElement<uint16_t>(Field::VT_OFFSET, offset, 0);
+  }
+  void add_default_integer(int64_t default_integer) {
+    fbb_.AddElement<int64_t>(Field::VT_DEFAULT_INTEGER, default_integer, 0);
+  }
+  void add_default_real(double default_real) {
+    fbb_.AddElement<double>(Field::VT_DEFAULT_REAL, default_real, 0.0);
+  }
+  void add_deprecated(bool deprecated) {
+    fbb_.AddElement<uint8_t>(Field::VT_DEPRECATED, static_cast<uint8_t>(deprecated), 0);
+  }
+  void add_required(bool required) {
+    fbb_.AddElement<uint8_t>(Field::VT_REQUIRED, static_cast<uint8_t>(required), 0);
+  }
+  void add_key(bool key) {
+    fbb_.AddElement<uint8_t>(Field::VT_KEY, static_cast<uint8_t>(key), 0);
+  }
+  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
+    fbb_.AddOffset(Field::VT_ATTRIBUTES, attributes);
+  }
+  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
+    fbb_.AddOffset(Field::VT_DOCUMENTATION, documentation);
+  }
+  void add_optional(bool optional) {
+    fbb_.AddElement<uint8_t>(Field::VT_OPTIONAL, static_cast<uint8_t>(optional), 0);
+  }
+  void add_padding(uint16_t padding) {
+    fbb_.AddElement<uint16_t>(Field::VT_PADDING, padding, 0);
+  }
+  void add_offset64(bool offset64) {
+    fbb_.AddElement<uint8_t>(Field::VT_OFFSET64, static_cast<uint8_t>(offset64), 0);
+  }
+  explicit FieldBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Field> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Field>(end);
+    fbb_.Required(o, Field::VT_NAME);
+    fbb_.Required(o, Field::VT_TYPE);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Field> CreateField(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
+    ::flatbuffers::Offset<reflection::Type> type = 0,
+    uint16_t id = 0,
+    uint16_t offset = 0,
+    int64_t default_integer = 0,
+    double default_real = 0.0,
+    bool deprecated = false,
+    bool required = false,
+    bool key = false,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
+    bool optional = false,
+    uint16_t padding = 0,
+    bool offset64 = false) {
+  FieldBuilder builder_(_fbb);
+  builder_.add_default_real(default_real);
+  builder_.add_default_integer(default_integer);
+  builder_.add_documentation(documentation);
+  builder_.add_attributes(attributes);
+  builder_.add_type(type);
+  builder_.add_name(name);
+  builder_.add_padding(padding);
+  builder_.add_offset(offset);
+  builder_.add_id(id);
+  builder_.add_offset64(offset64);
+  builder_.add_optional(optional);
+  builder_.add_key(key);
+  builder_.add_required(required);
+  builder_.add_deprecated(deprecated);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Field> CreateFieldDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *name = nullptr,
+    ::flatbuffers::Offset<reflection::Type> type = 0,
+    uint16_t id = 0,
+    uint16_t offset = 0,
+    int64_t default_integer = 0,
+    double default_real = 0.0,
+    bool deprecated = false,
+    bool required = false,
+    bool key = false,
+    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
+    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
+    bool optional = false,
+    uint16_t padding = 0,
+    bool offset64 = false) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
+  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
+  return reflection::CreateField(
+      _fbb,
+      name__,
+      type,
+      id,
+      offset,
+      default_integer,
+      default_real,
+      deprecated,
+      required,
+      key,
+      attributes__,
+      documentation__,
+      optional,
+      padding,
+      offset64);
+}
+
+struct Object FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ObjectBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_FIELDS = 6,
+    VT_IS_STRUCT = 8,
+    VT_MINALIGN = 10,
+    VT_BYTESIZE = 12,
+    VT_ATTRIBUTES = 14,
+    VT_DOCUMENTATION = 16,
+    VT_DECLARATION_FILE = 18
+  };
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
+  }
+  bool KeyCompareLessThan(const Object * const o) const {
+    return *name() < *o->name();
+  }
+  int KeyCompareWithValue(const char *_name) const {
+    return strcmp(name()->c_str(), _name);
+  }
+  template<typename StringType>
+  int KeyCompareWithValue(const StringType& _name) const {
+    if (name()->c_str() < _name) return -1;
+    if (_name < name()->c_str()) return 1;
+    return 0;
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>> *fields() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>> *>(VT_FIELDS);
+  }
+  bool is_struct() const {
+    return GetField<uint8_t>(VT_IS_STRUCT, 0) != 0;
+  }
+  int32_t minalign() const {
+    return GetField<int32_t>(VT_MINALIGN, 0);
+  }
+  int32_t bytesize() const {
+    return GetField<int32_t>(VT_BYTESIZE, 0);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
+  }
+  /// File that this Object is declared in.
+  const ::flatbuffers::String *declaration_file() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffsetRequired(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyOffsetRequired(verifier, VT_FIELDS) &&
+           verifier.VerifyVector(fields()) &&
+           verifier.VerifyVectorOfTables(fields()) &&
+           VerifyField<uint8_t>(verifier, VT_IS_STRUCT, 1) &&
+           VerifyField<int32_t>(verifier, VT_MINALIGN, 4) &&
+           VerifyField<int32_t>(verifier, VT_BYTESIZE, 4) &&
+           VerifyOffset(verifier, VT_ATTRIBUTES) &&
+           verifier.VerifyVector(attributes()) &&
+           verifier.VerifyVectorOfTables(attributes()) &&
+           VerifyOffset(verifier, VT_DOCUMENTATION) &&
+           verifier.VerifyVector(documentation()) &&
+           verifier.VerifyVectorOfStrings(documentation()) &&
+           VerifyOffset(verifier, VT_DECLARATION_FILE) &&
+           verifier.VerifyString(declaration_file()) &&
+           verifier.EndTable();
+  }
+};
+
+struct ObjectBuilder {
+  typedef Object Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
+    fbb_.AddOffset(Object::VT_NAME, name);
+  }
+  void add_fields(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>>> fields) {
+    fbb_.AddOffset(Object::VT_FIELDS, fields);
+  }
+  void add_is_struct(bool is_struct) {
+    fbb_.AddElement<uint8_t>(Object::VT_IS_STRUCT, static_cast<uint8_t>(is_struct), 0);
+  }
+  void add_minalign(int32_t minalign) {
+    fbb_.AddElement<int32_t>(Object::VT_MINALIGN, minalign, 0);
+  }
+  void add_bytesize(int32_t bytesize) {
+    fbb_.AddElement<int32_t>(Object::VT_BYTESIZE, bytesize, 0);
+  }
+  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
+    fbb_.AddOffset(Object::VT_ATTRIBUTES, attributes);
+  }
+  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
+    fbb_.AddOffset(Object::VT_DOCUMENTATION, documentation);
+  }
+  void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
+    fbb_.AddOffset(Object::VT_DECLARATION_FILE, declaration_file);
+  }
+  explicit ObjectBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Object> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Object>(end);
+    fbb_.Required(o, Object::VT_NAME);
+    fbb_.Required(o, Object::VT_FIELDS);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Object> CreateObject(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>>> fields = 0,
+    bool is_struct = false,
+    int32_t minalign = 0,
+    int32_t bytesize = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
+  ObjectBuilder builder_(_fbb);
+  builder_.add_declaration_file(declaration_file);
+  builder_.add_documentation(documentation);
+  builder_.add_attributes(attributes);
+  builder_.add_bytesize(bytesize);
+  builder_.add_minalign(minalign);
+  builder_.add_fields(fields);
+  builder_.add_name(name);
+  builder_.add_is_struct(is_struct);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Object> CreateObjectDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *name = nullptr,
+    std::vector<::flatbuffers::Offset<reflection::Field>> *fields = nullptr,
+    bool is_struct = false,
+    int32_t minalign = 0,
+    int32_t bytesize = 0,
+    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
+    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
+    const char *declaration_file = nullptr) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto fields__ = fields ? _fbb.CreateVectorOfSortedTables<reflection::Field>(fields) : 0;
+  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
+  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
+  auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
+  return reflection::CreateObject(
+      _fbb,
+      name__,
+      fields__,
+      is_struct,
+      minalign,
+      bytesize,
+      attributes__,
+      documentation__,
+      declaration_file__);
+}
+
+struct RPCCall FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef RPCCallBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_REQUEST = 6,
+    VT_RESPONSE = 8,
+    VT_ATTRIBUTES = 10,
+    VT_DOCUMENTATION = 12
+  };
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
+  }
+  bool KeyCompareLessThan(const RPCCall * const o) const {
+    return *name() < *o->name();
+  }
+  int KeyCompareWithValue(const char *_name) const {
+    return strcmp(name()->c_str(), _name);
+  }
+  template<typename StringType>
+  int KeyCompareWithValue(const StringType& _name) const {
+    if (name()->c_str() < _name) return -1;
+    if (_name < name()->c_str()) return 1;
+    return 0;
+  }
+  const reflection::Object *request() const {
+    return GetPointer<const reflection::Object *>(VT_REQUEST);
+  }
+  const reflection::Object *response() const {
+    return GetPointer<const reflection::Object *>(VT_RESPONSE);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffsetRequired(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyOffsetRequired(verifier, VT_REQUEST) &&
+           verifier.VerifyTable(request()) &&
+           VerifyOffsetRequired(verifier, VT_RESPONSE) &&
+           verifier.VerifyTable(response()) &&
+           VerifyOffset(verifier, VT_ATTRIBUTES) &&
+           verifier.VerifyVector(attributes()) &&
+           verifier.VerifyVectorOfTables(attributes()) &&
+           VerifyOffset(verifier, VT_DOCUMENTATION) &&
+           verifier.VerifyVector(documentation()) &&
+           verifier.VerifyVectorOfStrings(documentation()) &&
+           verifier.EndTable();
+  }
+};
+
+struct RPCCallBuilder {
+  typedef RPCCall Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
+    fbb_.AddOffset(RPCCall::VT_NAME, name);
+  }
+  void add_request(::flatbuffers::Offset<reflection::Object> request) {
+    fbb_.AddOffset(RPCCall::VT_REQUEST, request);
+  }
+  void add_response(::flatbuffers::Offset<reflection::Object> response) {
+    fbb_.AddOffset(RPCCall::VT_RESPONSE, response);
+  }
+  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
+    fbb_.AddOffset(RPCCall::VT_ATTRIBUTES, attributes);
+  }
+  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
+    fbb_.AddOffset(RPCCall::VT_DOCUMENTATION, documentation);
+  }
+  explicit RPCCallBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<RPCCall> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<RPCCall>(end);
+    fbb_.Required(o, RPCCall::VT_NAME);
+    fbb_.Required(o, RPCCall::VT_REQUEST);
+    fbb_.Required(o, RPCCall::VT_RESPONSE);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<RPCCall> CreateRPCCall(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
+    ::flatbuffers::Offset<reflection::Object> request = 0,
+    ::flatbuffers::Offset<reflection::Object> response = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0) {
+  RPCCallBuilder builder_(_fbb);
+  builder_.add_documentation(documentation);
+  builder_.add_attributes(attributes);
+  builder_.add_response(response);
+  builder_.add_request(request);
+  builder_.add_name(name);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<RPCCall> CreateRPCCallDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *name = nullptr,
+    ::flatbuffers::Offset<reflection::Object> request = 0,
+    ::flatbuffers::Offset<reflection::Object> response = 0,
+    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
+    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
+  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
+  return reflection::CreateRPCCall(
+      _fbb,
+      name__,
+      request,
+      response,
+      attributes__,
+      documentation__);
+}
+
+struct Service FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ServiceBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_CALLS = 6,
+    VT_ATTRIBUTES = 8,
+    VT_DOCUMENTATION = 10,
+    VT_DECLARATION_FILE = 12
+  };
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
+  }
+  bool KeyCompareLessThan(const Service * const o) const {
+    return *name() < *o->name();
+  }
+  int KeyCompareWithValue(const char *_name) const {
+    return strcmp(name()->c_str(), _name);
+  }
+  template<typename StringType>
+  int KeyCompareWithValue(const StringType& _name) const {
+    if (name()->c_str() < _name) return -1;
+    if (_name < name()->c_str()) return 1;
+    return 0;
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>> *calls() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>> *>(VT_CALLS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
+  }
+  /// File that this Service is declared in.
+  const ::flatbuffers::String *declaration_file() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffsetRequired(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyOffset(verifier, VT_CALLS) &&
+           verifier.VerifyVector(calls()) &&
+           verifier.VerifyVectorOfTables(calls()) &&
+           VerifyOffset(verifier, VT_ATTRIBUTES) &&
+           verifier.VerifyVector(attributes()) &&
+           verifier.VerifyVectorOfTables(attributes()) &&
+           VerifyOffset(verifier, VT_DOCUMENTATION) &&
+           verifier.VerifyVector(documentation()) &&
+           verifier.VerifyVectorOfStrings(documentation()) &&
+           VerifyOffset(verifier, VT_DECLARATION_FILE) &&
+           verifier.VerifyString(declaration_file()) &&
+           verifier.EndTable();
+  }
+};
+
+struct ServiceBuilder {
+  typedef Service Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
+    fbb_.AddOffset(Service::VT_NAME, name);
+  }
+  void add_calls(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>>> calls) {
+    fbb_.AddOffset(Service::VT_CALLS, calls);
+  }
+  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
+    fbb_.AddOffset(Service::VT_ATTRIBUTES, attributes);
+  }
+  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
+    fbb_.AddOffset(Service::VT_DOCUMENTATION, documentation);
+  }
+  void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
+    fbb_.AddOffset(Service::VT_DECLARATION_FILE, declaration_file);
+  }
+  explicit ServiceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Service> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Service>(end);
+    fbb_.Required(o, Service::VT_NAME);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Service> CreateService(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>>> calls = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
+  ServiceBuilder builder_(_fbb);
+  builder_.add_declaration_file(declaration_file);
+  builder_.add_documentation(documentation);
+  builder_.add_attributes(attributes);
+  builder_.add_calls(calls);
+  builder_.add_name(name);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Service> CreateServiceDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *name = nullptr,
+    std::vector<::flatbuffers::Offset<reflection::RPCCall>> *calls = nullptr,
+    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
+    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
+    const char *declaration_file = nullptr) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto calls__ = calls ? _fbb.CreateVectorOfSortedTables<reflection::RPCCall>(calls) : 0;
+  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
+  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
+  auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
+  return reflection::CreateService(
+      _fbb,
+      name__,
+      calls__,
+      attributes__,
+      documentation__,
+      declaration_file__);
+}
+
+/// File specific information.
+/// Symbols declared within a file may be recovered by iterating over all
+/// symbols and examining the `declaration_file` field.
+struct SchemaFile FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef SchemaFileBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_FILENAME = 4,
+    VT_INCLUDED_FILENAMES = 6
+  };
+  /// Filename, relative to project root.
+  const ::flatbuffers::String *filename() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_FILENAME);
+  }
+  bool KeyCompareLessThan(const SchemaFile * const o) const {
+    return *filename() < *o->filename();
+  }
+  int KeyCompareWithValue(const char *_filename) const {
+    return strcmp(filename()->c_str(), _filename);
+  }
+  template<typename StringType>
+  int KeyCompareWithValue(const StringType& _filename) const {
+    if (filename()->c_str() < _filename) return -1;
+    if (_filename < filename()->c_str()) return 1;
+    return 0;
+  }
+  /// Names of included files, relative to project root.
+  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *included_filenames() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_INCLUDED_FILENAMES);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffsetRequired(verifier, VT_FILENAME) &&
+           verifier.VerifyString(filename()) &&
+           VerifyOffset(verifier, VT_INCLUDED_FILENAMES) &&
+           verifier.VerifyVector(included_filenames()) &&
+           verifier.VerifyVectorOfStrings(included_filenames()) &&
+           verifier.EndTable();
+  }
+};
+
+struct SchemaFileBuilder {
+  typedef SchemaFile Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_filename(::flatbuffers::Offset<::flatbuffers::String> filename) {
+    fbb_.AddOffset(SchemaFile::VT_FILENAME, filename);
+  }
+  void add_included_filenames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> included_filenames) {
+    fbb_.AddOffset(SchemaFile::VT_INCLUDED_FILENAMES, included_filenames);
+  }
+  explicit SchemaFileBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<SchemaFile> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<SchemaFile>(end);
+    fbb_.Required(o, SchemaFile::VT_FILENAME);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<SchemaFile> CreateSchemaFile(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> filename = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> included_filenames = 0) {
+  SchemaFileBuilder builder_(_fbb);
+  builder_.add_included_filenames(included_filenames);
+  builder_.add_filename(filename);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<SchemaFile> CreateSchemaFileDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *filename = nullptr,
+    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *included_filenames = nullptr) {
+  auto filename__ = filename ? _fbb.CreateString(filename) : 0;
+  auto included_filenames__ = included_filenames ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*included_filenames) : 0;
+  return reflection::CreateSchemaFile(
+      _fbb,
+      filename__,
+      included_filenames__);
+}
+
+struct Schema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef SchemaBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_OBJECTS = 4,
+    VT_ENUMS = 6,
+    VT_FILE_IDENT = 8,
+    VT_FILE_EXT = 10,
+    VT_ROOT_TABLE = 12,
+    VT_SERVICES = 14,
+    VT_ADVANCED_FEATURES = 16,
+    VT_FBS_FILES = 18
+  };
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>> *objects() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>> *>(VT_OBJECTS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>> *enums() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>> *>(VT_ENUMS);
+  }
+  const ::flatbuffers::String *file_ident() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_FILE_IDENT);
+  }
+  const ::flatbuffers::String *file_ext() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_FILE_EXT);
+  }
+  const reflection::Object *root_table() const {
+    return GetPointer<const reflection::Object *>(VT_ROOT_TABLE);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>> *services() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>> *>(VT_SERVICES);
+  }
+  reflection::AdvancedFeatures advanced_features() const {
+    return static_cast<reflection::AdvancedFeatures>(GetField<uint64_t>(VT_ADVANCED_FEATURES, 0));
+  }
+  /// All the files used in this compilation. Files are relative to where
+  /// flatc was invoked.
+  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *fbs_files() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *>(VT_FBS_FILES);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffsetRequired(verifier, VT_OBJECTS) &&
+           verifier.VerifyVector(objects()) &&
+           verifier.VerifyVectorOfTables(objects()) &&
+           VerifyOffsetRequired(verifier, VT_ENUMS) &&
+           verifier.VerifyVector(enums()) &&
+           verifier.VerifyVectorOfTables(enums()) &&
+           VerifyOffset(verifier, VT_FILE_IDENT) &&
+           verifier.VerifyString(file_ident()) &&
+           VerifyOffset(verifier, VT_FILE_EXT) &&
+           verifier.VerifyString(file_ext()) &&
+           VerifyOffset(verifier, VT_ROOT_TABLE) &&
+           verifier.VerifyTable(root_table()) &&
+           VerifyOffset(verifier, VT_SERVICES) &&
+           verifier.VerifyVector(services()) &&
+           verifier.VerifyVectorOfTables(services()) &&
+           VerifyField<uint64_t>(verifier, VT_ADVANCED_FEATURES, 8) &&
+           VerifyOffset(verifier, VT_FBS_FILES) &&
+           verifier.VerifyVector(fbs_files()) &&
+           verifier.VerifyVectorOfTables(fbs_files()) &&
+           verifier.EndTable();
+  }
+};
+
+struct SchemaBuilder {
+  typedef Schema Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_objects(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>>> objects) {
+    fbb_.AddOffset(Schema::VT_OBJECTS, objects);
+  }
+  void add_enums(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>>> enums) {
+    fbb_.AddOffset(Schema::VT_ENUMS, enums);
+  }
+  void add_file_ident(::flatbuffers::Offset<::flatbuffers::String> file_ident) {
+    fbb_.AddOffset(Schema::VT_FILE_IDENT, file_ident);
+  }
+  void add_file_ext(::flatbuffers::Offset<::flatbuffers::String> file_ext) {
+    fbb_.AddOffset(Schema::VT_FILE_EXT, file_ext);
+  }
+  void add_root_table(::flatbuffers::Offset<reflection::Object> root_table) {
+    fbb_.AddOffset(Schema::VT_ROOT_TABLE, root_table);
+  }
+  void add_services(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>>> services) {
+    fbb_.AddOffset(Schema::VT_SERVICES, services);
+  }
+  void add_advanced_features(reflection::AdvancedFeatures advanced_features) {
+    fbb_.AddElement<uint64_t>(Schema::VT_ADVANCED_FEATURES, static_cast<uint64_t>(advanced_features), 0);
+  }
+  void add_fbs_files(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>>> fbs_files) {
+    fbb_.AddOffset(Schema::VT_FBS_FILES, fbs_files);
+  }
+  explicit SchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Schema> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Schema>(end);
+    fbb_.Required(o, Schema::VT_OBJECTS);
+    fbb_.Required(o, Schema::VT_ENUMS);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Schema> CreateSchema(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>>> objects = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>>> enums = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> file_ident = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> file_ext = 0,
+    ::flatbuffers::Offset<reflection::Object> root_table = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>>> services = 0,
+    reflection::AdvancedFeatures advanced_features = static_cast<reflection::AdvancedFeatures>(0),
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>>> fbs_files = 0) {
+  SchemaBuilder builder_(_fbb);
+  builder_.add_advanced_features(advanced_features);
+  builder_.add_fbs_files(fbs_files);
+  builder_.add_services(services);
+  builder_.add_root_table(root_table);
+  builder_.add_file_ext(file_ext);
+  builder_.add_file_ident(file_ident);
+  builder_.add_enums(enums);
+  builder_.add_objects(objects);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Schema> CreateSchemaDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    std::vector<::flatbuffers::Offset<reflection::Object>> *objects = nullptr,
+    std::vector<::flatbuffers::Offset<reflection::Enum>> *enums = nullptr,
+    const char *file_ident = nullptr,
+    const char *file_ext = nullptr,
+    ::flatbuffers::Offset<reflection::Object> root_table = 0,
+    std::vector<::flatbuffers::Offset<reflection::Service>> *services = nullptr,
+    reflection::AdvancedFeatures advanced_features = static_cast<reflection::AdvancedFeatures>(0),
+    std::vector<::flatbuffers::Offset<reflection::SchemaFile>> *fbs_files = nullptr) {
+  auto objects__ = objects ? _fbb.CreateVectorOfSortedTables<reflection::Object>(objects) : 0;
+  auto enums__ = enums ? _fbb.CreateVectorOfSortedTables<reflection::Enum>(enums) : 0;
+  auto file_ident__ = file_ident ? _fbb.CreateString(file_ident) : 0;
+  auto file_ext__ = file_ext ? _fbb.CreateString(file_ext) : 0;
+  auto services__ = services ? _fbb.CreateVectorOfSortedTables<reflection::Service>(services) : 0;
+  auto fbs_files__ = fbs_files ? _fbb.CreateVectorOfSortedTables<reflection::SchemaFile>(fbs_files) : 0;
+  return reflection::CreateSchema(
+      _fbb,
+      objects__,
+      enums__,
+      file_ident__,
+      file_ext__,
+      root_table,
+      services__,
+      advanced_features,
+      fbs_files__);
+}
+
+inline const reflection::Schema *GetSchema(const void *buf) {
+  return ::flatbuffers::GetRoot<reflection::Schema>(buf);
+}
+
+inline const reflection::Schema *GetSizePrefixedSchema(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<reflection::Schema>(buf);
+}
+
+inline const char *SchemaIdentifier() {
+  return "BFBS";
+}
+
+inline bool SchemaBufferHasIdentifier(const void *buf) {
+  return ::flatbuffers::BufferHasIdentifier(
+      buf, SchemaIdentifier());
+}
+
+inline bool SizePrefixedSchemaBufferHasIdentifier(const void *buf) {
+  return ::flatbuffers::BufferHasIdentifier(
+      buf, SchemaIdentifier(), true);
+}
+
+template <bool B = false>
+inline bool VerifySchemaBuffer(
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifyBuffer<reflection::Schema>(SchemaIdentifier());
+}
+
+template <bool B = false>
+inline bool VerifySizePrefixedSchemaBuffer(
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<reflection::Schema>(SchemaIdentifier());
+}
+
+inline const char *SchemaExtension() {
+  return "bfbs";
+}
+
+inline void FinishSchemaBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<reflection::Schema> root) {
+  fbb.Finish(root, SchemaIdentifier());
+}
+
+inline void FinishSizePrefixedSchemaBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<reflection::Schema> root) {
+  fbb.FinishSizePrefixed(root, SchemaIdentifier());
+}
+
+}  // namespace reflection
+
+#endif  // FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
diff --git a/external/flatbuffers/include/flatbuffers/registry.h b/external/flatbuffers/include/flatbuffers/registry.h
new file mode 100644
index 00000000..e70cfc33
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/registry.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_REGISTRY_H_
+#define FLATBUFFERS_REGISTRY_H_
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/idl.h"
+
+namespace flatbuffers {
+
+// Convenience class to easily parse or generate text for arbitrary FlatBuffers.
+// Simply pre-populate it with all schema filenames that may be in use, and
+// This class will look them up using the file_identifier declared in the
+// schema.
+class Registry {
+ public:
+  // Call this for all schemas that may be in use. The identifier has
+  // a function in the generated code, e.g. MonsterIdentifier().
+  void Register(const char* file_identifier, const char* schema_path) {
+    Schema schema;
+    schema.path_ = schema_path;
+    schemas_[file_identifier] = schema;
+  }
+
+  // Generate text from an arbitrary FlatBuffer by looking up its
+  // file_identifier in the registry.
+  bool FlatBufferToText(const uint8_t* flatbuf, size_t len, std::string* dest) {
+    // Get the identifier out of the buffer.
+    // If the buffer is truncated, exit.
+    if (len < sizeof(uoffset_t) + kFileIdentifierLength) {
+      lasterror_ = "buffer truncated";
+      return false;
+    }
+    std::string ident(
+        reinterpret_cast<const char*>(flatbuf) + sizeof(uoffset_t),
+        kFileIdentifierLength);
+    // Load and parse the schema.
+    Parser parser;
+    if (!LoadSchema(ident, &parser)) return false;
+    // Now we're ready to generate text.
+    auto err = GenText(parser, flatbuf, dest);
+    if (err) {
+      lasterror_ =
+          "unable to generate text for FlatBuffer binary: " + std::string(err);
+      return false;
+    }
+    return true;
+  }
+
+  // Converts a binary buffer to text using one of the schemas in the registry,
+  // use the file_identifier to indicate which.
+  // If DetachedBuffer::data() is null then parsing failed.
+  DetachedBuffer TextToFlatBuffer(const char* text,
+                                  const char* file_identifier) {
+    // Load and parse the schema.
+    Parser parser;
+    if (!LoadSchema(file_identifier, &parser)) return DetachedBuffer();
+    // Parse the text.
+    if (!parser.Parse(text)) {
+      lasterror_ = parser.error_;
+      return DetachedBuffer();
+    }
+    // We have a valid FlatBuffer. Detach it from the builder and return.
+    return parser.builder_.Release();
+  }
+
+  // Modify any parsing / output options used by the other functions.
+  void SetOptions(const IDLOptions& opts) { opts_ = opts; }
+
+  // If schemas used contain include statements, call this function for every
+  // directory the parser should search them for.
+  void AddIncludeDirectory(const char* path) { include_paths_.push_back(path); }
+
+  // Returns a human readable error if any of the above functions fail.
+  const std::string& GetLastError() { return lasterror_; }
+
+ private:
+  bool LoadSchema(const std::string& ident, Parser* parser) {
+    // Find the schema, if not, exit.
+    auto it = schemas_.find(ident);
+    if (it == schemas_.end()) {
+      // Don't attach the identifier, since it may not be human readable.
+      lasterror_ = "identifier for this buffer not in the registry";
+      return false;
+    }
+    auto& schema = it->second;
+    // Load the schema from disk. If not, exit.
+    std::string schematext;
+    if (!LoadFile(schema.path_.c_str(), false, &schematext)) {
+      lasterror_ = "could not load schema: " + schema.path_;
+      return false;
+    }
+    // Parse schema.
+    parser->opts = opts_;
+    if (!parser->Parse(schematext.c_str(), include_paths_.data(),
+                       schema.path_.c_str())) {
+      lasterror_ = parser->error_;
+      return false;
+    }
+    return true;
+  }
+
+  struct Schema {
+    std::string path_;
+    // TODO(wvo) optionally cache schema file or parsed schema here.
+  };
+
+  std::string lasterror_;
+  IDLOptions opts_;
+  std::vector<const char*> include_paths_;
+  std::map<std::string, Schema> schemas_;
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_REGISTRY_H_
diff --git a/external/flatbuffers/include/flatbuffers/stl_emulation.h b/external/flatbuffers/include/flatbuffers/stl_emulation.h
new file mode 100644
index 00000000..fc8e4b1d
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/stl_emulation.h
@@ -0,0 +1,516 @@
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_STL_EMULATION_H_
+#define FLATBUFFERS_STL_EMULATION_H_
+
+// clang-format off
+#include "flatbuffers/base.h"
+
+#include <string>
+#include <type_traits>
+#include <vector>
+#include <memory>
+#include <limits>
+
+#ifndef FLATBUFFERS_USE_STD_OPTIONAL
+  // Detect C++17 compatible compiler.
+  // __cplusplus >= 201703L - a compiler has support of 'static inline' variables.
+  #if (defined(__cplusplus) && __cplusplus >= 201703L) \
+      || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+    #define FLATBUFFERS_USE_STD_OPTIONAL 1
+  #else
+    #define FLATBUFFERS_USE_STD_OPTIONAL 0
+  #endif // (defined(__cplusplus) && __cplusplus >= 201703L) ...
+#endif // FLATBUFFERS_USE_STD_OPTIONAL
+
+#if FLATBUFFERS_USE_STD_OPTIONAL
+  #include <optional>
+#endif
+
+#ifndef FLATBUFFERS_USE_STD_SPAN
+  // Testing __cpp_lib_span requires including either <version> or <span>,
+  // both of which were added in C++20.
+  // See: https://en.cppreference.com/w/cpp/utility/feature_test
+  #if defined(__cplusplus) && __cplusplus >= 202002L \
+      || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
+    #if __has_include(<span>)
+      #define FLATBUFFERS_USE_STD_SPAN 1
+    #endif
+  #endif
+#endif // FLATBUFFERS_USE_STD_SPAN
+
+#if defined(FLATBUFFERS_USE_STD_SPAN)
+  #include <array>
+  #include <span>
+#else
+  // Disable non-trivial ctors if FLATBUFFERS_SPAN_MINIMAL defined.
+  #if !defined(FLATBUFFERS_TEMPLATES_ALIASES)
+    #define FLATBUFFERS_SPAN_MINIMAL
+  #else
+    // Enable implicit construction of a span<T,N> from a std::array<T,N>.
+    #include <array>
+  #endif
+#endif // defined(FLATBUFFERS_USE_STD_SPAN)
+
+// This header provides backwards compatibility for older versions of the STL.
+namespace flatbuffers {
+
+#if defined(FLATBUFFERS_TEMPLATES_ALIASES)
+  template <typename T>
+  using numeric_limits = std::numeric_limits<T>;
+#else
+  template <typename T> class numeric_limits :
+    public std::numeric_limits<T> {};
+#endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
+
+#if defined(FLATBUFFERS_TEMPLATES_ALIASES)
+  template <typename T> using is_scalar = std::is_scalar<T>;
+  template <typename T, typename U> using is_same = std::is_same<T,U>;
+  template <typename T> using is_floating_point = std::is_floating_point<T>;
+  template <typename T> using is_unsigned = std::is_unsigned<T>;
+  template <typename T> using is_enum = std::is_enum<T>;
+  template <typename T> using make_unsigned = std::make_unsigned<T>;
+  template<bool B, class T, class F>
+  using conditional = std::conditional<B, T, F>;
+  template<class T, T v>
+  using integral_constant = std::integral_constant<T, v>;
+  template <bool B>
+  using bool_constant = integral_constant<bool, B>;
+  using true_type  = std::true_type;
+  using false_type = std::false_type;
+#else
+  // MSVC 2010 doesn't support C++11 aliases.
+  template <typename T> struct is_scalar : public std::is_scalar<T> {};
+  template <typename T, typename U> struct is_same : public std::is_same<T,U> {};
+  template <typename T> struct is_floating_point :
+        public std::is_floating_point<T> {};
+  template <typename T> struct is_unsigned : public std::is_unsigned<T> {};
+  template <typename T> struct is_enum : public std::is_enum<T> {};
+  template <typename T> struct make_unsigned : public std::make_unsigned<T> {};
+  template<bool B, class T, class F>
+  struct conditional : public std::conditional<B, T, F> {};
+  template<class T, T v>
+  struct integral_constant : public std::integral_constant<T, v> {};
+  template <bool B>
+  struct bool_constant : public integral_constant<bool, B> {};
+  typedef bool_constant<true>  true_type;
+  typedef bool_constant<false> false_type;
+#endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
+
+#if defined(FLATBUFFERS_TEMPLATES_ALIASES)
+  template <class T> using unique_ptr = std::unique_ptr<T>;
+#else
+  // MSVC 2010 doesn't support C++11 aliases.
+  // We're manually "aliasing" the class here as we want to bring unique_ptr
+  // into the flatbuffers namespace.  We have unique_ptr in the flatbuffers
+  // namespace we have a completely independent implementation (see below)
+  // for C++98 STL implementations.
+  template <class T> class unique_ptr : public std::unique_ptr<T> {
+    public:
+    unique_ptr() {}
+    explicit unique_ptr(T* p) : std::unique_ptr<T>(p) {}
+    unique_ptr(std::unique_ptr<T>&& u) { *this = std::move(u); }
+    unique_ptr(unique_ptr&& u) { *this = std::move(u); }
+    unique_ptr& operator=(std::unique_ptr<T>&& u) {
+      std::unique_ptr<T>::reset(u.release());
+      return *this;
+    }
+    unique_ptr& operator=(unique_ptr&& u) {
+      std::unique_ptr<T>::reset(u.release());
+      return *this;
+    }
+    unique_ptr& operator=(T* p) {
+      return std::unique_ptr<T>::operator=(p);
+    }
+  };
+#endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
+
+#if FLATBUFFERS_USE_STD_OPTIONAL
+template<class T>
+using Optional = std::optional<T>;
+using nullopt_t = std::nullopt_t;
+inline constexpr nullopt_t nullopt = std::nullopt;
+
+#else
+// Limited implementation of Optional<T> type for a scalar T.
+// This implementation limited by trivial types compatible with
+// std::is_arithmetic<T> or std::is_enum<T> type traits.
+
+// A tag to indicate an empty flatbuffers::optional<T>.
+struct nullopt_t {
+  explicit FLATBUFFERS_CONSTEXPR_CPP11 nullopt_t(int) {}
+};
+
+#if defined(FLATBUFFERS_CONSTEXPR_DEFINED)
+  namespace internal {
+    template <class> struct nullopt_holder {
+      static constexpr nullopt_t instance_ = nullopt_t(0);
+    };
+    template<class Dummy>
+    constexpr nullopt_t nullopt_holder<Dummy>::instance_;
+  }
+  static constexpr const nullopt_t &nullopt = internal::nullopt_holder<void>::instance_;
+
+#else
+  namespace internal {
+    template <class> struct nullopt_holder {
+      static const nullopt_t instance_;
+    };
+    template<class Dummy>
+    const nullopt_t nullopt_holder<Dummy>::instance_  = nullopt_t(0);
+  }
+  static const nullopt_t &nullopt = internal::nullopt_holder<void>::instance_;
+
+#endif
+
+template<class T>
+class Optional FLATBUFFERS_FINAL_CLASS {
+  // Non-scalar 'T' would extremely complicated Optional<T>.
+  // Use is_scalar<T> checking because flatbuffers flatbuffers::is_arithmetic<T>
+  // isn't implemented.
+  static_assert(flatbuffers::is_scalar<T>::value, "unexpected type T");
+
+ public:
+  ~Optional() {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional() FLATBUFFERS_NOEXCEPT
+    : value_(), has_value_(false) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional(nullopt_t) FLATBUFFERS_NOEXCEPT
+    : value_(), has_value_(false) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional(T val) FLATBUFFERS_NOEXCEPT
+    : value_(val), has_value_(true) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional(const Optional &other) FLATBUFFERS_NOEXCEPT
+    : value_(other.value_), has_value_(other.has_value_) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(const Optional &other) FLATBUFFERS_NOEXCEPT {
+    value_ = other.value_;
+    has_value_ = other.has_value_;
+    return *this;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(nullopt_t) FLATBUFFERS_NOEXCEPT {
+    value_ = T();
+    has_value_ = false;
+    return *this;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(T val) FLATBUFFERS_NOEXCEPT {
+    value_ = val;
+    has_value_ = true;
+    return *this;
+  }
+
+  void reset() FLATBUFFERS_NOEXCEPT {
+    *this = nullopt;
+  }
+
+  void swap(Optional &other) FLATBUFFERS_NOEXCEPT {
+    std::swap(value_, other.value_);
+    std::swap(has_value_, other.has_value_);
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 FLATBUFFERS_EXPLICIT_CPP11 operator bool() const FLATBUFFERS_NOEXCEPT {
+    return has_value_;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 bool has_value() const FLATBUFFERS_NOEXCEPT {
+    return has_value_;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 const T& operator*() const FLATBUFFERS_NOEXCEPT {
+    return value_;
+  }
+
+  const T& value() const {
+    FLATBUFFERS_ASSERT(has_value());
+    return value_;
+  }
+
+  T value_or(T default_value) const FLATBUFFERS_NOEXCEPT {
+    return has_value() ? value_ : default_value;
+  }
+
+ private:
+  T value_;
+  bool has_value_;
+};
+
+template<class T>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& opt, nullopt_t) FLATBUFFERS_NOEXCEPT {
+  return !opt;
+}
+template<class T>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(nullopt_t, const Optional<T>& opt) FLATBUFFERS_NOEXCEPT {
+  return !opt;
+}
+
+template<class T, class U>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& lhs, const U& rhs) FLATBUFFERS_NOEXCEPT {
+  return static_cast<bool>(lhs) && (*lhs == rhs);
+}
+
+template<class T, class U>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const T& lhs, const Optional<U>& rhs) FLATBUFFERS_NOEXCEPT {
+  return static_cast<bool>(rhs) && (lhs == *rhs);
+}
+
+template<class T, class U>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& lhs, const Optional<U>& rhs) FLATBUFFERS_NOEXCEPT {
+  return static_cast<bool>(lhs) != static_cast<bool>(rhs)
+              ? false
+              : !static_cast<bool>(lhs) ? true : (*lhs == *rhs);
+}
+#endif // FLATBUFFERS_USE_STD_OPTIONAL
+
+
+// Very limited and naive partial implementation of C++20 std::span<T,Extent>.
+#if defined(FLATBUFFERS_USE_STD_SPAN)
+  inline constexpr std::size_t dynamic_extent = std::dynamic_extent;
+  template<class T, std::size_t Extent = std::dynamic_extent>
+  using span = std::span<T, Extent>;
+
+#else // !defined(FLATBUFFERS_USE_STD_SPAN)
+FLATBUFFERS_CONSTEXPR std::size_t dynamic_extent = static_cast<std::size_t>(-1);
+
+// Exclude this code if MSVC2010 or non-STL Android is active.
+// The non-STL Android doesn't have `std::is_convertible` required for SFINAE.
+#if !defined(FLATBUFFERS_SPAN_MINIMAL)
+namespace internal {
+  // This is SFINAE helper class for checking of a common condition:
+  // > This overload only participates in overload resolution
+  // > Check whether a pointer to an array of From can be converted
+  // > to a pointer to an array of To.
+  // This helper is used for checking of 'From -> const From'.
+  template<class To, std::size_t Extent, class From, std::size_t N>
+  struct is_span_convertible {
+    using type =
+      typename std::conditional<std::is_convertible<From (*)[], To (*)[]>::value
+                                && (Extent == dynamic_extent || N == Extent),
+                                int, void>::type;
+  };
+
+  template<typename T>
+  struct SpanIterator {
+    // TODO: upgrade to std::random_access_iterator_tag.
+    using iterator_category = std::forward_iterator_tag;
+    using difference_type  = std::ptrdiff_t;
+    using value_type = typename std::remove_cv<T>::type;
+    using reference = T&;
+    using pointer   = T*;
+
+    // Convince MSVC compiler that this iterator is trusted (it is verified).
+    #ifdef _MSC_VER
+      using _Unchecked_type = pointer;
+    #endif // _MSC_VER
+
+    SpanIterator(pointer ptr) : ptr_(ptr) {}
+    reference operator*() const { return *ptr_; }
+    pointer operator->() { return ptr_; }
+    SpanIterator& operator++() { ptr_++; return *this; }
+    SpanIterator  operator++(int) { auto tmp = *this; ++(*this); return tmp; }
+
+    friend bool operator== (const SpanIterator& lhs, const SpanIterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
+    friend bool operator!= (const SpanIterator& lhs, const SpanIterator& rhs) { return lhs.ptr_ != rhs.ptr_; }
+
+   private:
+    pointer ptr_;
+  };
+}  // namespace internal
+#endif  // !defined(FLATBUFFERS_SPAN_MINIMAL)
+
+// T - element type; must be a complete type that is not an abstract
+// class type.
+// Extent - the number of elements in the sequence, or dynamic.
+template<class T, std::size_t Extent = dynamic_extent>
+class span FLATBUFFERS_FINAL_CLASS {
+ public:
+  typedef T element_type;
+  typedef T& reference;
+  typedef const T& const_reference;
+  typedef T* pointer;
+  typedef const T* const_pointer;
+  typedef std::size_t size_type;
+
+  static FLATBUFFERS_CONSTEXPR size_type extent = Extent;
+
+  // Returns the number of elements in the span.
+  FLATBUFFERS_CONSTEXPR_CPP11 size_type size() const FLATBUFFERS_NOEXCEPT {
+    return count_;
+  }
+
+  // Returns the size of the sequence in bytes.
+  FLATBUFFERS_CONSTEXPR_CPP11
+  size_type size_bytes() const FLATBUFFERS_NOEXCEPT {
+    return size() * sizeof(element_type);
+  }
+
+  // Checks if the span is empty.
+  FLATBUFFERS_CONSTEXPR_CPP11 bool empty() const FLATBUFFERS_NOEXCEPT {
+    return size() == 0;
+  }
+
+  // Returns a pointer to the beginning of the sequence.
+  FLATBUFFERS_CONSTEXPR_CPP11 pointer data() const FLATBUFFERS_NOEXCEPT {
+    return data_;
+  }
+
+  #if !defined(FLATBUFFERS_SPAN_MINIMAL)
+    using Iterator = internal::SpanIterator<T>;
+
+    Iterator begin() const { return Iterator(data()); }
+    Iterator end() const   { return Iterator(data() + size()); }
+  #endif
+
+  // Returns a reference to the idx-th element of the sequence.
+  // The behavior is undefined if the idx is greater than or equal to size().
+  FLATBUFFERS_CONSTEXPR_CPP11 reference operator[](size_type idx) const {
+    return data()[idx];
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 span(const span &other) FLATBUFFERS_NOEXCEPT
+      : data_(other.data_), count_(other.count_) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP14 span &operator=(const span &other)
+      FLATBUFFERS_NOEXCEPT {
+    data_ = other.data_;
+    count_ = other.count_;
+  }
+
+  // Limited implementation of
+  // `template <class It> constexpr std::span(It first, size_type count);`.
+  //
+  // Constructs a span that is a view over the range [first, first + count);
+  // the resulting span has: data() == first and size() == count.
+  // The behavior is undefined if [first, first + count) is not a valid range,
+  // or if (extent != flatbuffers::dynamic_extent && count != extent).
+  FLATBUFFERS_CONSTEXPR_CPP11
+  explicit span(pointer first, size_type count) FLATBUFFERS_NOEXCEPT
+    : data_ (Extent == dynamic_extent ? first : (Extent == count ? first : nullptr)),
+      count_(Extent == dynamic_extent ? count : (Extent == count ? Extent : 0)) {
+      // Make span empty if the count argument is incompatible with span<T,N>.
+  }
+
+  // Exclude this code if MSVC2010 is active. The MSVC2010 isn't C++11
+  // compliant, it doesn't support default template arguments for functions.
+  #if defined(FLATBUFFERS_SPAN_MINIMAL)
+  FLATBUFFERS_CONSTEXPR_CPP11 span() FLATBUFFERS_NOEXCEPT : data_(nullptr),
+                                                            count_(0) {
+    static_assert(extent == 0 || extent == dynamic_extent, "invalid span");
+  }
+
+  #else
+  // Constructs an empty span whose data() == nullptr and size() == 0.
+  // This overload only participates in overload resolution if
+  // extent == 0 || extent == flatbuffers::dynamic_extent.
+  // A dummy template argument N is need dependency for SFINAE.
+  template<std::size_t N = 0,
+    typename internal::is_span_convertible<element_type, Extent, element_type, (N - N)>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span() FLATBUFFERS_NOEXCEPT : data_(nullptr),
+                                                            count_(0) {
+    static_assert(extent == 0 || extent == dynamic_extent, "invalid span");
+  }
+
+  // Constructs a span that is a view over the array arr; the resulting span
+  // has size() == N and data() == std::data(arr). These overloads only
+  // participate in overload resolution if
+  // extent == std::dynamic_extent || N == extent is true and
+  // std::remove_pointer_t<decltype(std::data(arr))>(*)[]
+  // is convertible to element_type (*)[].
+  template<std::size_t N,
+    typename internal::is_span_convertible<element_type, Extent, element_type, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(element_type (&arr)[N]) FLATBUFFERS_NOEXCEPT
+      : data_(arr), count_(N) {}
+
+  template<class U, std::size_t N,
+    typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
+     : data_(arr.data()), count_(N) {}
+
+  //template<class U, std::size_t N,
+  //  int = 0>
+  //FLATBUFFERS_CONSTEXPR_CPP11 span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
+  //   : data_(arr.data()), count_(N) {}
+
+  template<class U, std::size_t N,
+    typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(const std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
+    : data_(arr.data()), count_(N) {}
+
+  // Converting constructor from another span s;
+  // the resulting span has size() == s.size() and data() == s.data().
+  // This overload only participates in overload resolution
+  // if extent == std::dynamic_extent || N == extent is true and U (*)[]
+  // is convertible to element_type (*)[].
+  template<class U, std::size_t N,
+    typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(const flatbuffers::span<U, N> &s) FLATBUFFERS_NOEXCEPT
+      : span(s.data(), s.size()) {
+  }
+
+  #endif  // !defined(FLATBUFFERS_SPAN_MINIMAL)
+
+ private:
+  // This is a naive implementation with 'count_' member even if (Extent != dynamic_extent).
+  pointer const data_;
+  size_type count_;
+};
+#endif  // defined(FLATBUFFERS_USE_STD_SPAN)
+
+#if !defined(FLATBUFFERS_SPAN_MINIMAL)
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<ElementType, Extent> make_span(ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
+  return span<ElementType, Extent>(arr);
+}
+
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<const ElementType, Extent> make_span(const ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
+  return span<const ElementType, Extent>(arr);
+}
+
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<ElementType, Extent> make_span(std::array<ElementType, Extent> &arr) FLATBUFFERS_NOEXCEPT {
+  return span<ElementType, Extent>(arr);
+}
+
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<const ElementType, Extent> make_span(const std::array<ElementType, Extent> &arr) FLATBUFFERS_NOEXCEPT {
+  return span<const ElementType, Extent>(arr);
+}
+
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<ElementType, dynamic_extent> make_span(ElementType *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
+  return span<ElementType, dynamic_extent>(first, count);
+}
+
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<const ElementType, dynamic_extent> make_span(const ElementType *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
+  return span<const ElementType, dynamic_extent>(first, count);
+}
+#endif // !defined(FLATBUFFERS_SPAN_MINIMAL)
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_STL_EMULATION_H_
diff --git a/external/flatbuffers/include/flatbuffers/string.h b/external/flatbuffers/include/flatbuffers/string.h
new file mode 100644
index 00000000..d9c62f96
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/string.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_STRING_H_
+#define FLATBUFFERS_STRING_H_
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/vector.h"
+
+namespace flatbuffers {
+
+struct String : public Vector<char> {
+  const char* c_str() const { return reinterpret_cast<const char*>(Data()); }
+  std::string str() const { return std::string(c_str(), size()); }
+
+  // clang-format off
+  #ifdef FLATBUFFERS_HAS_STRING_VIEW
+  flatbuffers::string_view string_view() const {
+    return flatbuffers::string_view(c_str(), size());
+  }
+
+  /* implicit */
+  operator flatbuffers::string_view() const {
+    return flatbuffers::string_view(c_str(), size());
+  }
+  #endif // FLATBUFFERS_HAS_STRING_VIEW
+  // clang-format on
+
+  bool operator<(const String& o) const {
+    return StringLessThan(this->data(), this->size(), o.data(), o.size());
+  }
+};
+
+// Convenience function to get std::string from a String returning an empty
+// string on null pointer.
+static inline std::string GetString(const String* str) {
+  return str ? str->str() : "";
+}
+
+// Convenience function to get char* from a String returning an empty string on
+// null pointer.
+static inline const char* GetCstring(const String* str) {
+  return str ? str->c_str() : "";
+}
+
+#ifdef FLATBUFFERS_HAS_STRING_VIEW
+// Convenience function to get string_view from a String returning an empty
+// string_view on null pointer.
+static inline flatbuffers::string_view GetStringView(const String* str) {
+  return str ? str->string_view() : flatbuffers::string_view();
+}
+#endif  // FLATBUFFERS_HAS_STRING_VIEW
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_STRING_H_
diff --git a/external/flatbuffers/include/flatbuffers/struct.h b/external/flatbuffers/include/flatbuffers/struct.h
new file mode 100644
index 00000000..3aa434c0
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/struct.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_STRUCT_H_
+#define FLATBUFFERS_STRUCT_H_
+
+#include "flatbuffers/base.h"
+
+namespace flatbuffers {
+
+// "structs" are flat structures that do not have an offset table, thus
+// always have all members present and do not support forwards/backwards
+// compatible extensions.
+
+class Struct FLATBUFFERS_FINAL_CLASS {
+ public:
+  template <typename T>
+  T GetField(uoffset_t o) const {
+    return ReadScalar<T>(&data_[o]);
+  }
+
+  template <typename T>
+  T GetStruct(uoffset_t o) const {
+    return reinterpret_cast<T>(&data_[o]);
+  }
+
+  const uint8_t* GetAddressOf(uoffset_t o) const { return &data_[o]; }
+  uint8_t* GetAddressOf(uoffset_t o) { return &data_[o]; }
+
+ private:
+  // private constructor & copy constructor: you obtain instances of this
+  // class by pointing to existing data only
+  Struct();
+  Struct(const Struct&);
+  Struct& operator=(const Struct&);
+
+  uint8_t data_[1];
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_STRUCT_H_
diff --git a/external/flatbuffers/include/flatbuffers/table.h b/external/flatbuffers/include/flatbuffers/table.h
new file mode 100644
index 00000000..622d1340
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/table.h
@@ -0,0 +1,263 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_TABLE_H_
+#define FLATBUFFERS_TABLE_H_
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/vector.h"
+#include "flatbuffers/verifier.h"
+
+namespace flatbuffers {
+
+// "tables" use an offset table (possibly shared) that allows fields to be
+// omitted and added at will, but uses an extra indirection to read.
+class Table {
+ public:
+  const uint8_t* GetVTable() const {
+    return data_ - ReadScalar<soffset_t>(data_);
+  }
+
+  // This gets the field offset for any of the functions below it, or 0
+  // if the field was not present.
+  voffset_t GetOptionalFieldOffset(voffset_t field) const {
+    // The vtable offset is always at the start.
+    auto vtable = GetVTable();
+    // The first element is the size of the vtable (fields + type id + itself).
+    auto vtsize = ReadScalar<voffset_t>(vtable);
+    // If the field we're accessing is outside the vtable, we're reading older
+    // data, so it's the same as if the offset was 0 (not present).
+    return field < vtsize ? ReadScalar<voffset_t>(vtable + field) : 0;
+  }
+
+  template <typename T>
+  T GetField(voffset_t field, T defaultval) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
+  }
+
+  template <typename P, typename OffsetSize = uoffset_t>
+  P GetPointer(voffset_t field) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    auto p = data_ + field_offset;
+    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
+                        : nullptr;
+  }
+  template <typename P, typename OffsetSize = uoffset_t>
+  P GetPointer(voffset_t field) const {
+    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
+  }
+
+  template <typename P>
+  P GetPointer64(voffset_t field) {
+    return GetPointer<P, uoffset64_t>(field);
+  }
+
+  template <typename P>
+  P GetPointer64(voffset_t field) const {
+    return GetPointer<P, uoffset64_t>(field);
+  }
+
+  template <typename P, typename SizeT = uoffset_t,
+            typename OffsetSize = uoffset_t>
+  const Vector<P, SizeT>* GetVectorPointerOrEmpty(voffset_t field) const {
+    auto* ptr = GetPointer<const Vector<P, SizeT>*, OffsetSize>(field);
+    return ptr ? ptr : EmptyVector<P, SizeT>();
+  }
+
+  template <typename P, typename SizeT = uoffset_t>
+  const Vector<P, SizeT>* GetVectorPointer64OrEmpty(voffset_t field) const {
+    return GetVectorPointerOrEmpty<P, SizeT, uoffset64_t>(field);
+  }
+
+  template <typename P, typename SizeT = uoffset_t,
+            typename OffsetSize = uoffset_t>
+  Vector<P, SizeT>* GetMutableVectorPointerOrEmpty(voffset_t field) {
+    auto* ptr = GetPointer<Vector<P, SizeT>*, OffsetSize>(field);
+    // This is a const_cast, but safe, since all mutable operations on an
+    // empty vector are NOPs.
+    return ptr ? ptr : const_cast<Vector<P, SizeT>*>(EmptyVector<P, SizeT>());
+  }
+
+  template <typename P, typename SizeT = uoffset_t>
+  Vector<P, SizeT>* GetMutableVectorPointer64OrEmpty(voffset_t field) {
+    return GetMutableVectorPointerOrEmpty<P, SizeT, uoffset64_t>(field);
+  }
+
+  template <typename P>
+  P GetStruct(voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    auto p = const_cast<uint8_t*>(data_ + field_offset);
+    return field_offset ? reinterpret_cast<P>(p) : nullptr;
+  }
+
+  template <typename Raw, typename Face>
+  flatbuffers::Optional<Face> GetOptional(voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    auto p = data_ + field_offset;
+    return field_offset ? Optional<Face>(static_cast<Face>(ReadScalar<Raw>(p)))
+                        : Optional<Face>();
+  }
+
+  template <typename T>
+  bool SetField(voffset_t field, T val, T def) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    if (!field_offset) return IsTheSameAs(val, def);
+    WriteScalar(data_ + field_offset, val);
+    return true;
+  }
+  template <typename T>
+  bool SetField(voffset_t field, T val) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    if (!field_offset) return false;
+    WriteScalar(data_ + field_offset, val);
+    return true;
+  }
+
+  bool SetPointer(voffset_t field, const uint8_t* val) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    if (!field_offset) return false;
+    WriteScalar(data_ + field_offset,
+                static_cast<uoffset_t>(val - (data_ + field_offset)));
+    return true;
+  }
+
+  uint8_t* GetAddressOf(voffset_t field) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return field_offset ? data_ + field_offset : nullptr;
+  }
+  const uint8_t* GetAddressOf(voffset_t field) const {
+    return const_cast<Table*>(this)->GetAddressOf(field);
+  }
+
+  bool CheckField(voffset_t field) const {
+    return GetOptionalFieldOffset(field) != 0;
+  }
+
+  // Verify the vtable of this table.
+  // Call this once per table, followed by VerifyField once per field.
+  template <bool B>
+  bool VerifyTableStart(VerifierTemplate<B>& verifier) const {
+    return verifier.VerifyTableStart(data_);
+  }
+
+  // Verify a particular field.
+  template <typename T, bool B>
+  bool VerifyField(const VerifierTemplate<B>& verifier, voffset_t field,
+                   size_t align) const {
+    // Calling GetOptionalFieldOffset should be safe now thanks to
+    // VerifyTable().
+    auto field_offset = GetOptionalFieldOffset(field);
+    // Check the actual field.
+    return !field_offset ||
+           verifier.template VerifyField<T>(data_, field_offset, align);
+  }
+
+  // VerifyField for required fields.
+  template <typename T, bool B>
+  bool VerifyFieldRequired(const VerifierTemplate<B>& verifier, voffset_t field,
+                           size_t align) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return verifier.Check(field_offset != 0) &&
+           verifier.template VerifyField<T>(data_, field_offset, align);
+  }
+
+  // Versions for offsets.
+  template <typename OffsetT = uoffset_t, bool B = false>
+  bool VerifyOffset(const VerifierTemplate<B>& verifier,
+                    voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return !field_offset ||
+           verifier.template VerifyOffset<OffsetT>(data_, field_offset);
+  }
+
+  template <typename OffsetT = uoffset_t, bool B = false>
+  bool VerifyOffsetRequired(const VerifierTemplate<B>& verifier,
+                            voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return verifier.Check(field_offset != 0) &&
+           verifier.template VerifyOffset<OffsetT>(data_, field_offset);
+  }
+
+  template <bool B>
+  bool VerifyOffset64(const VerifierTemplate<B>& verifier,
+                      voffset_t field) const {
+    return VerifyOffset<uoffset64_t>(verifier, field);
+  }
+
+  template <bool B>
+  bool VerifyOffset64Required(const VerifierTemplate<B>& verifier,
+                              voffset_t field) const {
+    return VerifyOffsetRequired<uoffset64_t>(verifier, field);
+  }
+
+  // Verify a string that may have a default value.
+  template <typename OffsetT = uoffset_t>
+  bool VerifyStringWithDefault(const Verifier& verifier,
+                               voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return field_offset == 0 ||
+           verifier.VerifyString(GetPointer<const String*, OffsetT>(field));
+  }
+
+  // Verify a vector that has a default empty value.
+  template <typename P, typename SizeT = uoffset_t,
+            typename OffsetSize = uoffset_t>
+  bool VerifyVectorWithDefault(const Verifier& verifier,
+                               voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return field_offset == 0 ||
+           verifier.VerifyVector(
+               GetPointer<const Vector<P, SizeT>*, OffsetSize>(field));
+  }
+
+  template <typename P, typename SizeT = uoffset_t>
+  bool VerifyVector64WithDefault(const Verifier& verifier,
+                                 voffset_t field) const {
+    return VerifyVectorWithDefault<P, SizeT, uoffset64_t>(verifier, field);
+  }
+
+ protected:
+  template <typename T, typename SizeT = uoffset_t>
+  static const Vector<T, SizeT>* EmptyVector() {
+    static const SizeT empty_vector_length = 0;
+    return reinterpret_cast<const Vector<T, SizeT>*>(&empty_vector_length);
+  }
+
+ private:
+  // private constructor & copy constructor: you obtain instances of this
+  // class by pointing to existing data only
+  Table();
+  Table(const Table& other);
+  Table& operator=(const Table&);
+
+  uint8_t data_[1];
+};
+
+// This specialization allows avoiding warnings like:
+// MSVC C4800: type: forcing value to bool 'true' or 'false'.
+template <>
+inline flatbuffers::Optional<bool> Table::GetOptional<uint8_t, bool>(
+    voffset_t field) const {
+  auto field_offset = GetOptionalFieldOffset(field);
+  auto p = data_ + field_offset;
+  return field_offset ? Optional<bool>(ReadScalar<uint8_t>(p) != 0)
+                      : Optional<bool>();
+}
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_TABLE_H_
diff --git a/external/flatbuffers/include/flatbuffers/util.h b/external/flatbuffers/include/flatbuffers/util.h
new file mode 100644
index 00000000..d8387e17
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/util.h
@@ -0,0 +1,781 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_UTIL_H_
+#define FLATBUFFERS_UTIL_H_
+
+#include <ctype.h>
+#include <errno.h>
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/stl_emulation.h"
+
+#ifndef FLATBUFFERS_PREFER_PRINTF
+#include <iomanip>
+#include <sstream>
+#else  // FLATBUFFERS_PREFER_PRINTF
+#include <float.h>
+#include <stdio.h>
+#endif  // FLATBUFFERS_PREFER_PRINTF
+
+#include <cmath>
+#include <limits>
+#include <string>
+
+namespace flatbuffers {
+
+// @locale-independent functions for ASCII characters set.
+
+// Fast checking that character lies in closed range: [a <= x <= b]
+// using one compare (conditional branch) operator.
+inline bool check_ascii_range(char x, char a, char b) {
+  FLATBUFFERS_ASSERT(a <= b);
+  // (Hacker's Delight): `a <= x <= b` <=> `(x-a) <={u} (b-a)`.
+  // The x, a, b will be promoted to int and subtracted without overflow.
+  return static_cast<unsigned int>(x - a) <= static_cast<unsigned int>(b - a);
+}
+
+// Case-insensitive isalpha
+inline bool is_alpha(char c) {
+  // ASCII only: alpha to upper case => reset bit 0x20 (~0x20 = 0xDF).
+  return check_ascii_range(c & 0xDF, 'a' & 0xDF, 'z' & 0xDF);
+}
+
+// Check for uppercase alpha
+inline bool is_alpha_upper(char c) { return check_ascii_range(c, 'A', 'Z'); }
+
+// Check (case-insensitive) that `c` is equal to alpha.
+inline bool is_alpha_char(char c, char alpha) {
+  FLATBUFFERS_ASSERT(is_alpha(alpha));
+  // ASCII only: alpha to upper case => reset bit 0x20 (~0x20 = 0xDF).
+  return ((c & 0xDF) == (alpha & 0xDF));
+}
+
+// https://en.cppreference.com/w/cpp/string/byte/isxdigit
+// isdigit and isxdigit are the only standard narrow character classification
+// functions that are not affected by the currently installed C locale. although
+// some implementations (e.g. Microsoft in 1252 codepage) may classify
+// additional single-byte characters as digits.
+inline bool is_digit(char c) { return check_ascii_range(c, '0', '9'); }
+
+inline bool is_xdigit(char c) {
+  // Replace by look-up table.
+  return is_digit(c) || check_ascii_range(c & 0xDF, 'a' & 0xDF, 'f' & 0xDF);
+}
+
+// Case-insensitive isalnum
+inline bool is_alnum(char c) { return is_alpha(c) || is_digit(c); }
+
+inline char CharToUpper(char c) {
+  return static_cast<char>(::toupper(static_cast<unsigned char>(c)));
+}
+
+inline char CharToLower(char c) {
+  return static_cast<char>(::tolower(static_cast<unsigned char>(c)));
+}
+
+// @end-locale-independent functions for ASCII character set
+
+#ifdef FLATBUFFERS_PREFER_PRINTF
+template <typename T>
+size_t IntToDigitCount(T t) {
+  size_t digit_count = 0;
+  // Count the sign for negative numbers
+  if (t < 0) digit_count++;
+  // Count a single 0 left of the dot for fractional numbers
+  if (-1 < t && t < 1) digit_count++;
+  // Count digits until fractional part
+  T eps = std::numeric_limits<T>::epsilon();
+  while (t <= (-1 + eps) || (1 - eps) <= t) {
+    t /= 10;
+    digit_count++;
+  }
+  return digit_count;
+}
+
+template <typename T>
+size_t NumToStringWidth(T t, int precision = 0) {
+  size_t string_width = IntToDigitCount(t);
+  // Count the dot for floating point numbers
+  if (precision) string_width += (precision + 1);
+  return string_width;
+}
+
+template <typename T>
+std::string NumToStringImplWrapper(T t, const char* fmt, int precision = 0) {
+  size_t string_width = NumToStringWidth(t, precision);
+  std::string s(string_width, 0x00);
+  // Allow snprintf to use std::string trailing null to detect buffer overflow
+  snprintf(const_cast<char*>(s.data()), (s.size() + 1), fmt, string_width, t);
+  return s;
+}
+#endif  // FLATBUFFERS_PREFER_PRINTF
+
+// Convert an integer or floating point value to a string.
+// In contrast to std::stringstream, "char" values are
+// converted to a string of digits, and we don't use scientific notation.
+template <typename T>
+std::string NumToString(T t) {
+  // clang-format off
+
+  #ifndef FLATBUFFERS_PREFER_PRINTF
+    std::stringstream ss;
+    ss << t;
+    return ss.str();
+  #else // FLATBUFFERS_PREFER_PRINTF
+    auto v = static_cast<long long>(t);
+    return NumToStringImplWrapper(v, "%.*lld");
+  #endif // FLATBUFFERS_PREFER_PRINTF
+  // clang-format on
+}
+// Avoid char types used as character data.
+template <>
+inline std::string NumToString<signed char>(signed char t) {
+  return NumToString(static_cast<int>(t));
+}
+template <>
+inline std::string NumToString<unsigned char>(unsigned char t) {
+  return NumToString(static_cast<int>(t));
+}
+template <>
+inline std::string NumToString<char>(char t) {
+  return NumToString(static_cast<int>(t));
+}
+
+// Special versions for floats/doubles.
+template <typename T>
+std::string FloatToString(T t, int precision) {
+  // clang-format off
+
+  #ifndef FLATBUFFERS_PREFER_PRINTF
+    // to_string() prints different numbers of digits for floats depending on
+    // platform and isn't available on Android, so we use stringstream
+    std::stringstream ss;
+    // Use std::fixed to suppress scientific notation.
+    ss << std::fixed;
+    // Default precision is 6, we want that to be higher for doubles.
+    ss << std::setprecision(precision);
+    ss << t;
+    auto s = ss.str();
+  #else // FLATBUFFERS_PREFER_PRINTF
+    auto v = static_cast<double>(t);
+    auto s = NumToStringImplWrapper(v, "%0.*f", precision);
+  #endif // FLATBUFFERS_PREFER_PRINTF
+  // clang-format on
+  // Sadly, std::fixed turns "1" into "1.00000", so here we undo that.
+  auto p = s.find_last_not_of('0');
+  if (p != std::string::npos) {
+    // Strip trailing zeroes. If it is a whole number, keep one zero.
+    s.resize(p + (s[p] == '.' ? 2 : 1));
+  }
+  return s;
+}
+
+template <>
+inline std::string NumToString<double>(double t) {
+  return FloatToString(t, 12);
+}
+template <>
+inline std::string NumToString<float>(float t) {
+  return FloatToString(t, 6);
+}
+
+// Convert an integer value to a hexadecimal string.
+// The returned string length is always xdigits long, prefixed by 0 digits.
+// For example, IntToStringHex(0x23, 8) returns the string "00000023".
+inline std::string IntToStringHex(int i, int xdigits) {
+  FLATBUFFERS_ASSERT(i >= 0);
+  // clang-format off
+
+  #ifndef FLATBUFFERS_PREFER_PRINTF
+    std::stringstream ss;
+    ss << std::setw(xdigits) << std::setfill('0') << std::hex << std::uppercase
+       << i;
+    return ss.str();
+  #else // FLATBUFFERS_PREFER_PRINTF
+    return NumToStringImplWrapper(i, "%.*X", xdigits);
+  #endif // FLATBUFFERS_PREFER_PRINTF
+  // clang-format on
+}
+
+// clang-format off
+// Use locale independent functions {strtod_l, strtof_l, strtoll_l, strtoull_l}.
+#if defined(FLATBUFFERS_LOCALE_INDEPENDENT) && (FLATBUFFERS_LOCALE_INDEPENDENT > 0)
+  class ClassicLocale {
+    #ifdef _MSC_VER
+      typedef _locale_t locale_type;
+    #else
+      typedef locale_t locale_type;  // POSIX.1-2008 locale_t type
+    #endif
+    ClassicLocale();
+    ~ClassicLocale();
+    locale_type locale_;
+    static ClassicLocale instance_;
+  public:
+    static locale_type Get() { return instance_.locale_; }
+  };
+
+  #ifdef _MSC_VER
+    #define __strtoull_impl(s, pe, b) _strtoui64_l(s, pe, b, ClassicLocale::Get())
+    #define __strtoll_impl(s, pe, b) _strtoi64_l(s, pe, b, ClassicLocale::Get())
+    #define __strtod_impl(s, pe) _strtod_l(s, pe, ClassicLocale::Get())
+    #define __strtof_impl(s, pe) _strtof_l(s, pe, ClassicLocale::Get())
+  #else
+    #define __strtoull_impl(s, pe, b) strtoull_l(s, pe, b, ClassicLocale::Get())
+    #define __strtoll_impl(s, pe, b) strtoll_l(s, pe, b, ClassicLocale::Get())
+    #define __strtod_impl(s, pe) strtod_l(s, pe, ClassicLocale::Get())
+    #define __strtof_impl(s, pe) strtof_l(s, pe, ClassicLocale::Get())
+  #endif
+#else
+  #define __strtod_impl(s, pe) strtod(s, pe)
+  #define __strtof_impl(s, pe) static_cast<float>(strtod(s, pe))
+  #ifdef _MSC_VER
+    #define __strtoull_impl(s, pe, b) _strtoui64(s, pe, b)
+    #define __strtoll_impl(s, pe, b) _strtoi64(s, pe, b)
+  #else
+    #define __strtoull_impl(s, pe, b) strtoull(s, pe, b)
+    #define __strtoll_impl(s, pe, b) strtoll(s, pe, b)
+  #endif
+#endif
+
+inline void strtoval_impl(int64_t *val, const char *str, char **endptr,
+                                 int base) {
+    *val = __strtoll_impl(str, endptr, base);
+}
+
+inline void strtoval_impl(uint64_t *val, const char *str, char **endptr,
+                                 int base) {
+  *val = __strtoull_impl(str, endptr, base);
+}
+
+inline void strtoval_impl(double *val, const char *str, char **endptr) {
+  *val = __strtod_impl(str, endptr);
+}
+
+// UBSAN: double to float is safe if numeric_limits<float>::is_iec559 is true.
+FLATBUFFERS_SUPPRESS_UBSAN("float-cast-overflow")
+inline void strtoval_impl(float *val, const char *str, char **endptr) {
+  *val = __strtof_impl(str, endptr);
+}
+#undef __strtoull_impl
+#undef __strtoll_impl
+#undef __strtod_impl
+#undef __strtof_impl
+// clang-format on
+
+// Adaptor for strtoull()/strtoll().
+// Flatbuffers accepts numbers with any count of leading zeros (-009 is -9),
+// while strtoll with base=0 interprets first leading zero as octal prefix.
+// In future, it is possible to add prefixed 0b0101.
+// 1) Checks errno code for overflow condition (out of range).
+// 2) If base <= 0, function try to detect base of number by prefix.
+//
+// Return value (like strtoull and strtoll, but reject partial result):
+// - If successful, an integer value corresponding to the str is returned.
+// - If full string conversion can't be performed, 0 is returned.
+// - If the converted value falls out of range of corresponding return type, a
+// range error occurs. In this case value MAX(T)/MIN(T) is returned.
+template <typename T>
+inline bool StringToIntegerImpl(T* val, const char* const str,
+                                const int base = 0,
+                                const bool check_errno = true) {
+  // T is int64_t or uint64_T
+  FLATBUFFERS_ASSERT(str);
+  if (base <= 0) {
+    auto s = str;
+    while (*s && !is_digit(*s)) s++;
+    if (s[0] == '0' && is_alpha_char(s[1], 'X'))
+      return StringToIntegerImpl(val, str, 16, check_errno);
+    // if a prefix not match, try base=10
+    return StringToIntegerImpl(val, str, 10, check_errno);
+  } else {
+    if (check_errno) errno = 0;  // clear thread-local errno
+    auto endptr = str;
+    strtoval_impl(val, str, const_cast<char**>(&endptr), base);
+    if ((*endptr != '\0') || (endptr == str)) {
+      *val = 0;      // erase partial result
+      return false;  // invalid string
+    }
+    // errno is out-of-range, return MAX/MIN
+    if (check_errno && errno) return false;
+    return true;
+  }
+}
+
+template <typename T>
+inline bool StringToFloatImpl(T* val, const char* const str) {
+  // Type T must be either float or double.
+  FLATBUFFERS_ASSERT(str && val);
+  auto end = str;
+  strtoval_impl(val, str, const_cast<char**>(&end));
+  auto done = (end != str) && (*end == '\0');
+  if (!done) *val = 0;  // erase partial result
+  if (done && std::isnan(*val)) {
+    *val = std::numeric_limits<T>::quiet_NaN();
+  }
+  return done;
+}
+
+// Convert a string to an instance of T.
+// Return value (matched with StringToInteger64Impl and strtod):
+// - If successful, a numeric value corresponding to the str is returned.
+// - If full string conversion can't be performed, 0 is returned.
+// - If the converted value falls out of range of corresponding return type, a
+// range error occurs. In this case value MAX(T)/MIN(T) is returned.
+template <typename T>
+inline bool StringToNumber(const char* s, T* val) {
+  // Assert on `unsigned long` and `signed long` on LP64.
+  // If it is necessary, it could be solved with flatbuffers::enable_if<B,T>.
+  static_assert(sizeof(T) < sizeof(int64_t), "unexpected type T");
+  FLATBUFFERS_ASSERT(s && val);
+  int64_t i64;
+  // The errno check isn't needed, will return MAX/MIN on overflow.
+  if (StringToIntegerImpl(&i64, s, 0, false)) {
+    const int64_t max = (flatbuffers::numeric_limits<T>::max)();
+    const int64_t min = flatbuffers::numeric_limits<T>::lowest();
+    if (i64 > max) {
+      *val = static_cast<T>(max);
+      return false;
+    }
+    if (i64 < min) {
+      // For unsigned types return max to distinguish from
+      // "no conversion can be performed" when 0 is returned.
+      *val = static_cast<T>(flatbuffers::is_unsigned<T>::value ? max : min);
+      return false;
+    }
+    *val = static_cast<T>(i64);
+    return true;
+  }
+  *val = 0;
+  return false;
+}
+
+template <>
+inline bool StringToNumber<int64_t>(const char* str, int64_t* val) {
+  return StringToIntegerImpl(val, str);
+}
+
+template <>
+inline bool StringToNumber<uint64_t>(const char* str, uint64_t* val) {
+  if (!StringToIntegerImpl(val, str)) return false;
+  // The strtoull accepts negative numbers:
+  // If the minus sign was part of the input sequence, the numeric value
+  // calculated from the sequence of digits is negated as if by unary minus
+  // in the result type, which applies unsigned integer wraparound rules.
+  // Fix this behaviour (except -0).
+  if (*val) {
+    auto s = str;
+    while (*s && !is_digit(*s)) s++;
+    s = (s > str) ? (s - 1) : s;  // step back to one symbol
+    if (*s == '-') {
+      // For unsigned types return the max to distinguish from
+      // "no conversion can be performed".
+      *val = (flatbuffers::numeric_limits<uint64_t>::max)();
+      return false;
+    }
+  }
+  return true;
+}
+
+template <>
+inline bool StringToNumber(const char* s, float* val) {
+  return StringToFloatImpl(val, s);
+}
+
+template <>
+inline bool StringToNumber(const char* s, double* val) {
+  return StringToFloatImpl(val, s);
+}
+
+inline int64_t StringToInt(const char* s, int base = 10) {
+  int64_t val;
+  return StringToIntegerImpl(&val, s, base) ? val : 0;
+}
+
+inline uint64_t StringToUInt(const char* s, int base = 10) {
+  uint64_t val;
+  return StringToIntegerImpl(&val, s, base) ? val : 0;
+}
+
+inline bool StringIsFlatbufferNan(const std::string& s) {
+  return s == "nan" || s == "+nan" || s == "-nan";
+}
+
+inline bool StringIsFlatbufferPositiveInfinity(const std::string& s) {
+  return s == "inf" || s == "+inf" || s == "infinity" || s == "+infinity";
+}
+
+inline bool StringIsFlatbufferNegativeInfinity(const std::string& s) {
+  return s == "-inf" || s == "-infinity";
+}
+
+typedef bool (*LoadFileFunction)(const char* filename, bool binary,
+                                 std::string* dest);
+typedef bool (*FileExistsFunction)(const char* filename);
+
+LoadFileFunction SetLoadFileFunction(LoadFileFunction load_file_function);
+
+FileExistsFunction SetFileExistsFunction(
+    FileExistsFunction file_exists_function);
+
+// Check if file "name" exists.
+bool FileExists(const char* name);
+
+// Check if "name" exists and it is also a directory.
+bool DirExists(const char* name);
+
+// Load file "name" into "buf" returning true if successful
+// false otherwise.  If "binary" is false data is read
+// using ifstream's text mode, otherwise data is read with
+// no transcoding.
+bool LoadFile(const char* name, bool binary, std::string* buf);
+
+// Save data "buf" of length "len" bytes into a file
+// "name" returning true if successful, false otherwise.
+// If "binary" is false data is written using ifstream's
+// text mode, otherwise data is written with no
+// transcoding.
+// NOTE: this function is deprecated in favor of FileSaver class,
+// but left here for compatibility.
+bool SaveFile(const char* name, const char* buf, size_t len, bool binary);
+
+// Save data "buf" into file "name" returning true if
+// successful, false otherwise.  If "binary" is false
+// data is written using ifstream's text mode, otherwise
+// data is written with no transcoding.
+// NOTE: this function is deprecated in favor of FileSaver class,
+// but left here for compatibility.
+inline bool SaveFile(const char* name, const std::string& buf, bool binary) {
+  return SaveFile(name, buf.c_str(), buf.size(), binary);
+}
+
+// Functionality for minimalistic portable path handling.
+
+// The functions below behave correctly regardless of whether posix ('/') or
+// Windows ('/' or '\\') separators are used.
+
+// Any new separators inserted are always posix.
+FLATBUFFERS_CONSTEXPR char kPathSeparator = '/';
+
+// Returns the path with the extension, if any, removed.
+std::string StripExtension(const std::string& filepath);
+
+// Returns the extension, if any.
+std::string GetExtension(const std::string& filepath);
+
+// Return the last component of the path, after the last separator.
+std::string StripPath(const std::string& filepath);
+
+// Strip the last component of the path + separator.
+std::string StripFileName(const std::string& filepath);
+
+std::string StripPrefix(const std::string& filepath,
+                        const std::string& prefix_to_remove);
+
+// Concatenates a path with a filename, regardless of whether the path
+// ends in a separator or not.
+std::string ConCatPathFileName(const std::string& path,
+                               const std::string& filename);
+
+// Replaces any '\\' separators with '/'
+std::string PosixPath(const char* path);
+std::string PosixPath(const std::string& path);
+
+// This function ensure a directory exists, by recursively
+// creating dirs for any parts of the path that don't exist yet.
+void EnsureDirExists(const std::string& filepath);
+
+// Obtains the relative or absolute path.
+std::string FilePath(const std::string& project, const std::string& filePath,
+                     bool absolute);
+
+// Obtains the absolute path from any other path.
+// Returns the input path if the absolute path couldn't be resolved.
+std::string AbsolutePath(const std::string& filepath);
+
+// Returns files relative to the --project_root path, prefixed with `//`.
+std::string RelativeToRootPath(const std::string& project,
+                               const std::string& filepath);
+
+// To and from UTF-8 unicode conversion functions
+
+// Convert a unicode code point into a UTF-8 representation by appending it
+// to a string. Returns the number of bytes generated.
+inline int ToUTF8(uint32_t ucc, std::string* out) {
+  FLATBUFFERS_ASSERT(!(ucc & 0x80000000));  // Top bit can't be set.
+  // 6 possible encodings: http://en.wikipedia.org/wiki/UTF-8
+  for (int i = 0; i < 6; i++) {
+    // Max bits this encoding can represent.
+    uint32_t max_bits = 6 + i * 5 + static_cast<int>(!i);
+    if (ucc < (1u << max_bits)) {  // does it fit?
+      // Remaining bits not encoded in the first byte, store 6 bits each
+      uint32_t remain_bits = i * 6;
+      // Store first byte:
+      (*out) += static_cast<char>((0xFE << (max_bits - remain_bits)) |
+                                  (ucc >> remain_bits));
+      // Store remaining bytes:
+      for (int j = i - 1; j >= 0; j--) {
+        (*out) += static_cast<char>(((ucc >> (j * 6)) & 0x3F) | 0x80);
+      }
+      return i + 1;  // Return the number of bytes added.
+    }
+  }
+  FLATBUFFERS_ASSERT(0);  // Impossible to arrive here.
+  return -1;
+}
+
+// Converts whatever prefix of the incoming string corresponds to a valid
+// UTF-8 sequence into a unicode code. The incoming pointer will have been
+// advanced past all bytes parsed.
+// returns -1 upon corrupt UTF-8 encoding (ignore the incoming pointer in
+// this case).
+inline int FromUTF8(const char** in) {
+  int len = 0;
+  // Count leading 1 bits.
+  for (int mask = 0x80; mask >= 0x04; mask >>= 1) {
+    if (**in & mask) {
+      len++;
+    } else {
+      break;
+    }
+  }
+  if ((static_cast<unsigned char>(**in) << len) & 0x80)
+    return -1;  // Bit after leading 1's must be 0.
+  if (!len) return *(*in)++;
+  // UTF-8 encoded values with a length are between 2 and 4 bytes.
+  if (len < 2 || len > 4) {
+    return -1;
+  }
+  // Grab initial bits of the code.
+  int ucc = *(*in)++ & ((1 << (7 - len)) - 1);
+  for (int i = 0; i < len - 1; i++) {
+    if ((**in & 0xC0) != 0x80) return -1;  // Upper bits must 1 0.
+    ucc <<= 6;
+    ucc |= *(*in)++ & 0x3F;  // Grab 6 more bits of the code.
+  }
+  // UTF-8 cannot encode values between 0xD800 and 0xDFFF (reserved for
+  // UTF-16 surrogate pairs).
+  if (ucc >= 0xD800 && ucc <= 0xDFFF) {
+    return -1;
+  }
+  // UTF-8 must represent code points in their shortest possible encoding.
+  switch (len) {
+    case 2:
+      // Two bytes of UTF-8 can represent code points from U+0080 to U+07FF.
+      if (ucc < 0x0080 || ucc > 0x07FF) {
+        return -1;
+      }
+      break;
+    case 3:
+      // Three bytes of UTF-8 can represent code points from U+0800 to U+FFFF.
+      if (ucc < 0x0800 || ucc > 0xFFFF) {
+        return -1;
+      }
+      break;
+    case 4:
+      // Four bytes of UTF-8 can represent code points from U+10000 to U+10FFFF.
+      if (ucc < 0x10000 || ucc > 0x10FFFF) {
+        return -1;
+      }
+      break;
+  }
+  return ucc;
+}
+
+#ifndef FLATBUFFERS_PREFER_PRINTF
+// Wraps a string to a maximum length, inserting new lines where necessary. Any
+// existing whitespace will be collapsed down to a single space. A prefix or
+// suffix can be provided, which will be inserted before or after a wrapped
+// line, respectively.
+inline std::string WordWrap(const std::string in, size_t max_length,
+                            const std::string wrapped_line_prefix,
+                            const std::string wrapped_line_suffix) {
+  std::istringstream in_stream(in);
+  std::string wrapped, line, word;
+
+  in_stream >> word;
+  line = word;
+
+  while (in_stream >> word) {
+    if ((line.length() + 1 + word.length() + wrapped_line_suffix.length()) <
+        max_length) {
+      line += " " + word;
+    } else {
+      wrapped += line + wrapped_line_suffix + "\n";
+      line = wrapped_line_prefix + word;
+    }
+  }
+  wrapped += line;
+
+  return wrapped;
+}
+#endif  // !FLATBUFFERS_PREFER_PRINTF
+
+inline bool EscapeString(const char* s, size_t length, std::string* _text,
+                         bool allow_non_utf8, bool natural_utf8) {
+  std::string& text = *_text;
+  text += "\"";
+  for (uoffset_t i = 0; i < length; i++) {
+    char c = s[i];
+    switch (c) {
+      case '\n':
+        text += "\\n";
+        break;
+      case '\t':
+        text += "\\t";
+        break;
+      case '\r':
+        text += "\\r";
+        break;
+      case '\b':
+        text += "\\b";
+        break;
+      case '\f':
+        text += "\\f";
+        break;
+      case '\"':
+        text += "\\\"";
+        break;
+      case '\\':
+        text += "\\\\";
+        break;
+      default:
+        if (c >= ' ' && c <= '~') {
+          text += c;
+        } else {
+          // Not printable ASCII data. Let's see if it's valid UTF-8 first:
+          const char* utf8 = s + i;
+          int ucc = FromUTF8(&utf8);
+          if (ucc < 0) {
+            if (allow_non_utf8) {
+              text += "\\x";
+              text += IntToStringHex(static_cast<uint8_t>(c), 2);
+            } else {
+              // There are two cases here:
+              //
+              // 1) We reached here by parsing an IDL file. In that case,
+              // we previously checked for non-UTF-8, so we shouldn't reach
+              // here.
+              //
+              // 2) We reached here by someone calling GenText()
+              // on a previously-serialized flatbuffer. The data might have
+              // non-UTF-8 Strings, or might be corrupt.
+              //
+              // In both cases, we have to give up and inform the caller
+              // they have no JSON.
+              return false;
+            }
+          } else {
+            if (natural_utf8) {
+              // utf8 points to past all utf-8 bytes parsed
+              text.append(s + i, static_cast<size_t>(utf8 - s - i));
+            } else if (ucc <= 0xFFFF) {
+              // Parses as Unicode within JSON's \uXXXX range, so use that.
+              text += "\\u";
+              text += IntToStringHex(ucc, 4);
+            } else if (ucc <= 0x10FFFF) {
+              // Encode Unicode SMP values to a surrogate pair using two \u
+              // escapes.
+              uint32_t base = ucc - 0x10000;
+              auto high_surrogate = (base >> 10) + 0xD800;
+              auto low_surrogate = (base & 0x03FF) + 0xDC00;
+              text += "\\u";
+              text += IntToStringHex(high_surrogate, 4);
+              text += "\\u";
+              text += IntToStringHex(low_surrogate, 4);
+            }
+            // Skip past characters recognized.
+            i = static_cast<uoffset_t>(utf8 - s - 1);
+          }
+        }
+        break;
+    }
+  }
+  text += "\"";
+  return true;
+}
+
+inline std::string BufferToHexText(const void* buffer, size_t buffer_size,
+                                   size_t max_length,
+                                   const std::string& wrapped_line_prefix,
+                                   const std::string& wrapped_line_suffix) {
+  std::string text = wrapped_line_prefix;
+  size_t start_offset = 0;
+  const char* s = reinterpret_cast<const char*>(buffer);
+  for (size_t i = 0; s && i < buffer_size; i++) {
+    // Last iteration or do we have more?
+    bool have_more = i + 1 < buffer_size;
+    text += "0x";
+    text += IntToStringHex(static_cast<uint8_t>(s[i]), 2);
+    if (have_more) {
+      text += ',';
+    }
+    // If we have more to process and we reached max_length
+    if (have_more &&
+        text.size() + wrapped_line_suffix.size() >= start_offset + max_length) {
+      text += wrapped_line_suffix;
+      text += '\n';
+      start_offset = text.size();
+      text += wrapped_line_prefix;
+    }
+  }
+  text += wrapped_line_suffix;
+  return text;
+}
+
+// Remove paired quotes in a string: "text"|'text' -> text.
+std::string RemoveStringQuotes(const std::string& s);
+
+// Change th global C-locale to locale with name <locale_name>.
+// Returns an actual locale name in <_value>, useful if locale_name is "" or
+// null.
+bool SetGlobalTestLocale(const char* locale_name,
+                         std::string* _value = nullptr);
+
+// Read (or test) a value of environment variable.
+bool ReadEnvironmentVariable(const char* var_name,
+                             std::string* _value = nullptr);
+
+enum class Case {
+  kUnknown = 0,
+  // TheQuickBrownFox
+  kUpperCamel = 1,
+  // theQuickBrownFox
+  kLowerCamel = 2,
+  // the_quick_brown_fox
+  kSnake = 3,
+  // THE_QUICK_BROWN_FOX
+  kScreamingSnake = 4,
+  // THEQUICKBROWNFOX
+  kAllUpper = 5,
+  // thequickbrownfox
+  kAllLower = 6,
+  // the-quick-brown-fox
+  kDasher = 7,
+  // THEQuiCKBr_ownFox (or whatever you want, we won't change it)
+  kKeep = 8,
+  // the_quick_brown_fox123 (as opposed to the_quick_brown_fox_123)
+  kSnake2 = 9,
+};
+
+// Convert the `input` string of case `input_case` to the specified
+// `output_case`.
+std::string ConvertCase(const std::string& input, Case output_case,
+                        Case input_case = Case::kSnake);
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_UTIL_H_
diff --git a/external/flatbuffers/include/flatbuffers/vector.h b/external/flatbuffers/include/flatbuffers/vector.h
new file mode 100644
index 00000000..759a9269
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/vector.h
@@ -0,0 +1,455 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_VECTOR_H_
+#define FLATBUFFERS_VECTOR_H_
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/buffer.h"
+#include "flatbuffers/stl_emulation.h"
+
+namespace flatbuffers {
+
+struct String;
+
+// An STL compatible iterator implementation for Vector below, effectively
+// calling Get() for every element.
+template <typename T, typename IT, typename Data = uint8_t*,
+          typename SizeT = uoffset_t>
+struct VectorIterator {
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef IT value_type;
+  typedef ptrdiff_t difference_type;
+  typedef IT* pointer;
+  typedef IT& reference;
+
+  static const SizeT element_stride = IndirectHelper<T>::element_stride;
+
+  VectorIterator(Data data, SizeT i) : data_(data + element_stride * i) {}
+  VectorIterator(const VectorIterator& other) : data_(other.data_) {}
+  VectorIterator() : data_(nullptr) {}
+
+  VectorIterator& operator=(const VectorIterator& other) {
+    data_ = other.data_;
+    return *this;
+  }
+
+  VectorIterator& operator=(VectorIterator&& other) {
+    data_ = other.data_;
+    return *this;
+  }
+
+  bool operator==(const VectorIterator& other) const {
+    return data_ == other.data_;
+  }
+
+  bool operator!=(const VectorIterator& other) const {
+    return data_ != other.data_;
+  }
+
+  bool operator<(const VectorIterator& other) const {
+    return data_ < other.data_;
+  }
+
+  bool operator>(const VectorIterator& other) const {
+    return data_ > other.data_;
+  }
+
+  bool operator<=(const VectorIterator& other) const {
+    return !(data_ > other.data_);
+  }
+
+  bool operator>=(const VectorIterator& other) const {
+    return !(data_ < other.data_);
+  }
+
+  difference_type operator-(const VectorIterator& other) const {
+    return (data_ - other.data_) / element_stride;
+  }
+
+  // Note: return type is incompatible with the standard
+  // `reference operator*()`.
+  IT operator*() const { return IndirectHelper<T>::Read(data_, 0); }
+
+  // Note: return type is incompatible with the standard
+  // `pointer operator->()`.
+  IT operator->() const { return IndirectHelper<T>::Read(data_, 0); }
+
+  VectorIterator& operator++() {
+    data_ += element_stride;
+    return *this;
+  }
+
+  VectorIterator operator++(int) {
+    VectorIterator temp(data_, 0);
+    data_ += element_stride;
+    return temp;
+  }
+
+  VectorIterator operator+(const SizeT& offset) const {
+    return VectorIterator(data_ + offset * element_stride, 0);
+  }
+
+  VectorIterator& operator+=(const SizeT& offset) {
+    data_ += offset * element_stride;
+    return *this;
+  }
+
+  VectorIterator& operator--() {
+    data_ -= element_stride;
+    return *this;
+  }
+
+  VectorIterator operator--(int) {
+    VectorIterator temp(data_, 0);
+    data_ -= element_stride;
+    return temp;
+  }
+
+  VectorIterator operator-(const SizeT& offset) const {
+    return VectorIterator(data_ - offset * element_stride, 0);
+  }
+
+  VectorIterator& operator-=(const SizeT& offset) {
+    data_ -= offset * element_stride;
+    return *this;
+  }
+
+ private:
+  Data data_;
+};
+
+template <typename T, typename IT, typename SizeT = uoffset_t>
+using VectorConstIterator = VectorIterator<T, IT, const uint8_t*, SizeT>;
+
+template <typename Iterator>
+struct VectorReverseIterator : public std::reverse_iterator<Iterator> {
+  explicit VectorReverseIterator(Iterator iter)
+      : std::reverse_iterator<Iterator>(iter) {}
+
+  // Note: return type is incompatible with the standard
+  // `reference operator*()`.
+  typename Iterator::value_type operator*() const {
+    auto tmp = std::reverse_iterator<Iterator>::current;
+    return *--tmp;
+  }
+
+  // Note: return type is incompatible with the standard
+  // `pointer operator->()`.
+  typename Iterator::value_type operator->() const {
+    auto tmp = std::reverse_iterator<Iterator>::current;
+    return *--tmp;
+  }
+};
+
+// This is used as a helper type for accessing vectors.
+// Vector::data() assumes the vector elements start after the length field.
+template <typename T, typename SizeT = uoffset_t>
+class Vector {
+ public:
+  typedef VectorIterator<T, typename IndirectHelper<T>::mutable_return_type,
+                         uint8_t*, SizeT>
+      iterator;
+  typedef VectorConstIterator<T, typename IndirectHelper<T>::return_type, SizeT>
+      const_iterator;
+  typedef VectorReverseIterator<iterator> reverse_iterator;
+  typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
+
+  typedef typename flatbuffers::bool_constant<flatbuffers::is_scalar<T>::value>
+      scalar_tag;
+
+  static FLATBUFFERS_CONSTEXPR bool is_span_observable =
+      scalar_tag::value && !std::is_pointer<T>::value &&
+      (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1);
+
+  SizeT size() const { return EndianScalar(length_); }
+
+  // Returns true if the vector is empty.
+  //
+  // This just provides another standardized method that is expected of vectors.
+  bool empty() const { return size() == 0; }
+
+  // Deprecated: use size(). Here for backwards compatibility.
+  FLATBUFFERS_ATTRIBUTE([[deprecated("use size() instead")]])
+  SizeT Length() const { return size(); }
+
+  typedef SizeT size_type;
+  typedef typename IndirectHelper<T>::return_type return_type;
+  typedef typename IndirectHelper<T>::mutable_return_type mutable_return_type;
+  typedef return_type value_type;
+
+  return_type Get(SizeT i) const {
+    FLATBUFFERS_ASSERT(i < size());
+    return IndirectHelper<T>::Read(Data(), i);
+  }
+
+  return_type operator[](SizeT i) const { return Get(i); }
+
+  // If this is a Vector of enums, T will be its storage type, not the enum
+  // type. This function makes it convenient to retrieve value with enum
+  // type E.
+  template <typename E>
+  E GetEnum(SizeT i) const {
+    return static_cast<E>(Get(i));
+  }
+
+  // If this a vector of unions, this does the cast for you. There's no check
+  // to make sure this is the right type!
+  template <typename U>
+  const U* GetAs(SizeT i) const {
+    return reinterpret_cast<const U*>(Get(i));
+  }
+
+  // If this a vector of unions, this does the cast for you. There's no check
+  // to make sure this is actually a string!
+  const String* GetAsString(SizeT i) const {
+    return reinterpret_cast<const String*>(Get(i));
+  }
+
+  const void* GetStructFromOffset(size_t o) const {
+    return reinterpret_cast<const void*>(Data() + o);
+  }
+
+  iterator begin() { return iterator(Data(), 0); }
+  const_iterator begin() const { return const_iterator(Data(), 0); }
+
+  iterator end() { return iterator(Data(), size()); }
+  const_iterator end() const { return const_iterator(Data(), size()); }
+
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  const_iterator cbegin() const { return begin(); }
+
+  const_iterator cend() const { return end(); }
+
+  const_reverse_iterator crbegin() const { return rbegin(); }
+
+  const_reverse_iterator crend() const { return rend(); }
+
+  // Change elements if you have a non-const pointer to this object.
+  // Scalars only. See reflection.h, and the documentation.
+  void Mutate(SizeT i, const T& val) {
+    FLATBUFFERS_ASSERT(i < size());
+    WriteScalar(data() + i, val);
+  }
+
+  // Change an element of a vector of tables (or strings).
+  // "val" points to the new table/string, as you can obtain from
+  // e.g. reflection::AddFlatBuffer().
+  void MutateOffset(SizeT i, const uint8_t* val) {
+    FLATBUFFERS_ASSERT(i < size());
+    static_assert(sizeof(T) == sizeof(SizeT), "Unrelated types");
+    WriteScalar(data() + i,
+                static_cast<SizeT>(val - (Data() + i * sizeof(SizeT))));
+  }
+
+  // Get a mutable pointer to tables/strings inside this vector.
+  mutable_return_type GetMutableObject(SizeT i) const {
+    FLATBUFFERS_ASSERT(i < size());
+    return const_cast<mutable_return_type>(IndirectHelper<T>::Read(Data(), i));
+  }
+
+  // The raw data in little endian format. Use with care.
+  const uint8_t* Data() const {
+    return reinterpret_cast<const uint8_t*>(&length_ + 1);
+  }
+
+  uint8_t* Data() { return reinterpret_cast<uint8_t*>(&length_ + 1); }
+
+  // Similarly, but typed, much like std::vector::data
+  const T* data() const { return reinterpret_cast<const T*>(Data()); }
+  T* data() { return reinterpret_cast<T*>(Data()); }
+
+  template <typename K>
+  return_type LookupByKey(K key) const {
+    void* search_result = std::bsearch(
+        &key, Data(), size(), IndirectHelper<T>::element_stride, KeyCompare<K>);
+
+    if (!search_result) {
+      return nullptr;  // Key not found.
+    }
+
+    const uint8_t* element = reinterpret_cast<const uint8_t*>(search_result);
+
+    return IndirectHelper<T>::Read(element, 0);
+  }
+
+  template <typename K>
+  mutable_return_type MutableLookupByKey(K key) {
+    return const_cast<mutable_return_type>(LookupByKey(key));
+  }
+
+ protected:
+  // This class is only used to access pre-existing data. Don't ever
+  // try to construct these manually.
+  Vector();
+
+  SizeT length_;
+
+ private:
+  // This class is a pointer. Copying will therefore create an invalid object.
+  // Private and unimplemented copy constructor.
+  Vector(const Vector&);
+  Vector& operator=(const Vector&);
+
+  template <typename K>
+  static int KeyCompare(const void* ap, const void* bp) {
+    const K* key = reinterpret_cast<const K*>(ap);
+    const uint8_t* data = reinterpret_cast<const uint8_t*>(bp);
+    auto table = IndirectHelper<T>::Read(data, 0);
+
+    // std::bsearch compares with the operands transposed, so we negate the
+    // result here.
+    return -table->KeyCompareWithValue(*key);
+  }
+};
+
+template <typename T>
+using Vector64 = Vector<T, uoffset64_t>;
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_span(Vector<U>& vec)
+    FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::is_span_observable,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return span<U>(vec.data(), vec.size());
+}
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_span(
+    const Vector<U>& vec) FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::is_span_observable,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return span<const U>(vec.data(), vec.size());
+}
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<uint8_t> make_bytes_span(
+    Vector<U>& vec) FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::scalar_tag::value,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return span<uint8_t>(vec.Data(), vec.size() * sizeof(U));
+}
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const uint8_t> make_bytes_span(
+    const Vector<U>& vec) FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::scalar_tag::value,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return span<const uint8_t>(vec.Data(), vec.size() * sizeof(U));
+}
+
+#if FLATBUFFERS_LITTLEENDIAN
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_structs_span(
+    Vector<const U*>& vec) FLATBUFFERS_NOEXCEPT {
+  return span<U>(reinterpret_cast<U*>(vec.data()), vec.size());
+}
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_structs_span(
+    const Vector<const U*>& vec) FLATBUFFERS_NOEXCEPT {
+  return span<const U>(reinterpret_cast<const U*>(vec.data()), vec.size());
+}
+
+#endif
+
+// Convenient helper functions to get a span of any vector, regardless
+// of whether it is null or not (the field is not set).
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_span(Vector<U>* ptr)
+    FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::is_span_observable,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return ptr ? make_span(*ptr) : span<U>();
+}
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_span(
+    const Vector<U>* ptr) FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::is_span_observable,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return ptr ? make_span(*ptr) : span<const U>();
+}
+
+#if FLATBUFFERS_LITTLEENDIAN
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_structs_span(
+    Vector<const U*>* ptr) FLATBUFFERS_NOEXCEPT {
+  return ptr ? make_span(*ptr) : span<U>();
+}
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_structs_span(
+    const Vector<const U*>* ptr) FLATBUFFERS_NOEXCEPT {
+  return ptr ? make_span(*ptr) : span<const U>();
+}
+
+#endif
+
+// Represent a vector much like the template above, but in this case we
+// don't know what the element types are (used with reflection.h).
+class VectorOfAny {
+ public:
+  uoffset_t size() const { return EndianScalar(length_); }
+
+  const uint8_t* Data() const {
+    return reinterpret_cast<const uint8_t*>(&length_ + 1);
+  }
+  uint8_t* Data() { return reinterpret_cast<uint8_t*>(&length_ + 1); }
+
+ protected:
+  VectorOfAny();
+
+  uoffset_t length_;
+
+ private:
+  VectorOfAny(const VectorOfAny&);
+  VectorOfAny& operator=(const VectorOfAny&);
+};
+
+template <typename T, typename U>
+Vector<Offset<T>>* VectorCast(Vector<Offset<U>>* ptr) {
+  static_assert(std::is_base_of<T, U>::value, "Unrelated types");
+  return reinterpret_cast<Vector<Offset<T>>*>(ptr);
+}
+
+template <typename T, typename U>
+const Vector<Offset<T>>* VectorCast(const Vector<Offset<U>>* ptr) {
+  static_assert(std::is_base_of<T, U>::value, "Unrelated types");
+  return reinterpret_cast<const Vector<Offset<T>>*>(ptr);
+}
+
+// Convenient helper function to get the length of any vector, regardless
+// of whether it is null or not (the field is not set).
+template <typename T>
+static inline size_t VectorLength(const Vector<T>* v) {
+  return v ? v->size() : 0;
+}
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_VERIFIER_H_
diff --git a/external/flatbuffers/include/flatbuffers/vector_downward.h b/external/flatbuffers/include/flatbuffers/vector_downward.h
new file mode 100644
index 00000000..3e6da8e9
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/vector_downward.h
@@ -0,0 +1,298 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_VECTOR_DOWNWARD_H_
+#define FLATBUFFERS_VECTOR_DOWNWARD_H_
+
+#include <algorithm>
+#include <cstdint>
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/default_allocator.h"
+#include "flatbuffers/detached_buffer.h"
+
+namespace flatbuffers {
+
+// This is a minimal replication of std::vector<uint8_t> functionality,
+// except growing from higher to lower addresses. i.e. push_back() inserts data
+// in the lowest address in the vector.
+// Since this vector leaves the lower part unused, we support a "scratch-pad"
+// that can be stored there for temporary data, to share the allocated space.
+// Essentially, this supports 2 std::vectors in a single buffer.
+template <typename SizeT = uoffset_t>
+class vector_downward {
+ public:
+  explicit vector_downward(size_t initial_size, Allocator* allocator,
+                           bool own_allocator, size_t buffer_minalign,
+                           const SizeT max_size = FLATBUFFERS_MAX_BUFFER_SIZE)
+      : allocator_(allocator),
+        own_allocator_(own_allocator),
+        initial_size_(initial_size),
+        max_size_(max_size),
+        buffer_minalign_(buffer_minalign),
+        reserved_(0),
+        size_(0),
+        buf_(nullptr),
+        cur_(nullptr),
+        scratch_(nullptr) {}
+
+  vector_downward(vector_downward&& other) noexcept
+      // clang-format on
+      : allocator_(other.allocator_),
+        own_allocator_(other.own_allocator_),
+        initial_size_(other.initial_size_),
+        max_size_(other.max_size_),
+        buffer_minalign_(other.buffer_minalign_),
+        reserved_(other.reserved_),
+        size_(other.size_),
+        buf_(other.buf_),
+        cur_(other.cur_),
+        scratch_(other.scratch_) {
+    // No change in other.allocator_
+    // No change in other.initial_size_
+    // No change in other.buffer_minalign_
+    other.own_allocator_ = false;
+    other.reserved_ = 0;
+    other.buf_ = nullptr;
+    other.cur_ = nullptr;
+    other.scratch_ = nullptr;
+  }
+
+  vector_downward& operator=(vector_downward&& other) noexcept {
+    // Move construct a temporary and swap idiom
+    vector_downward temp(std::move(other));
+    swap(temp);
+    return *this;
+  }
+
+  ~vector_downward() {
+    clear_buffer();
+    clear_allocator();
+  }
+
+  void reset() {
+    clear_buffer();
+    clear();
+  }
+
+  void clear() {
+    if (buf_) {
+      cur_ = buf_ + reserved_;
+    } else {
+      reserved_ = 0;
+      cur_ = nullptr;
+    }
+    size_ = 0;
+    clear_scratch();
+  }
+
+  void clear_scratch() { scratch_ = buf_; }
+
+  void clear_allocator() {
+    if (own_allocator_ && allocator_) {
+      delete allocator_;
+    }
+    allocator_ = nullptr;
+    own_allocator_ = false;
+  }
+
+  void clear_buffer() {
+    if (buf_) Deallocate(allocator_, buf_, reserved_);
+    buf_ = nullptr;
+  }
+
+  // Relinquish the pointer to the caller.
+  uint8_t* release_raw(size_t& allocated_bytes, size_t& offset) {
+    auto* buf = buf_;
+    allocated_bytes = reserved_;
+    offset = vector_downward::offset();
+
+    // release_raw only relinquishes the buffer ownership.
+    // Does not deallocate or reset the allocator. Destructor will do that.
+    buf_ = nullptr;
+    clear();
+    return buf;
+  }
+
+  // Relinquish the pointer to the caller.
+  DetachedBuffer release() {
+    // allocator ownership (if any) is transferred to DetachedBuffer.
+    DetachedBuffer fb(allocator_, own_allocator_, buf_, reserved_, cur_,
+                      size());
+    if (own_allocator_) {
+      allocator_ = nullptr;
+      own_allocator_ = false;
+    }
+    buf_ = nullptr;
+    clear();
+    return fb;
+  }
+
+  size_t ensure_space(size_t len) {
+    FLATBUFFERS_ASSERT(cur_ >= scratch_ && scratch_ >= buf_);
+    // If the length is larger than the unused part of the buffer, we need to
+    // grow.
+    if (len > unused_buffer_size()) {
+      reallocate(len);
+    }
+    FLATBUFFERS_ASSERT(size() < max_size_);
+    return len;
+  }
+
+  inline uint8_t* make_space(size_t len) {
+    if (len) {
+      ensure_space(len);
+      cur_ -= len;
+      size_ += static_cast<SizeT>(len);
+    }
+    return cur_;
+  }
+
+  // Returns nullptr if using the DefaultAllocator.
+  Allocator* get_custom_allocator() { return allocator_; }
+
+  // The current offset into the buffer.
+  size_t offset() const { return cur_ - buf_; }
+
+  // The total size of the vector (both the buffer and scratch parts).
+  inline SizeT size() const { return size_; }
+
+  // The size of the buffer part of the vector that is currently unused.
+  SizeT unused_buffer_size() const {
+    return static_cast<SizeT>(cur_ - scratch_);
+  }
+
+  // The size of the scratch part of the vector.
+  SizeT scratch_size() const { return static_cast<SizeT>(scratch_ - buf_); }
+
+  size_t capacity() const { return reserved_; }
+
+  uint8_t* data() const {
+    FLATBUFFERS_ASSERT(cur_);
+    return cur_;
+  }
+
+  uint8_t* scratch_data() const {
+    FLATBUFFERS_ASSERT(buf_);
+    return buf_;
+  }
+
+  uint8_t* scratch_end() const {
+    FLATBUFFERS_ASSERT(scratch_);
+    return scratch_;
+  }
+
+  uint8_t* data_at(size_t offset) const { return buf_ + reserved_ - offset; }
+
+  void push(const uint8_t* bytes, size_t num) {
+    if (num > 0) {
+      memcpy(make_space(num), bytes, num);
+    }
+  }
+
+  // Specialized version of push() that avoids memcpy call for small data.
+  template <typename T>
+  void push_small(const T& little_endian_t) {
+    make_space(sizeof(T));
+    *reinterpret_cast<T*>(cur_) = little_endian_t;
+  }
+
+  template <typename T>
+  void scratch_push_small(const T& t) {
+    ensure_space(sizeof(T));
+    *reinterpret_cast<T*>(scratch_) = t;
+    scratch_ += sizeof(T);
+  }
+
+  // fill() is most frequently called with small byte counts (<= 4),
+  // which is why we're using loops rather than calling memset.
+  void fill(size_t zero_pad_bytes) {
+    make_space(zero_pad_bytes);
+    for (size_t i = 0; i < zero_pad_bytes; i++) cur_[i] = 0;
+  }
+
+  // Version for when we know the size is larger.
+  // Precondition: zero_pad_bytes > 0
+  void fill_big(size_t zero_pad_bytes) {
+    memset(make_space(zero_pad_bytes), 0, zero_pad_bytes);
+  }
+
+  void pop(size_t bytes_to_remove) {
+    cur_ += bytes_to_remove;
+    size_ -= static_cast<SizeT>(bytes_to_remove);
+  }
+
+  void scratch_pop(size_t bytes_to_remove) { scratch_ -= bytes_to_remove; }
+
+  void swap(vector_downward& other) {
+    using std::swap;
+    swap(allocator_, other.allocator_);
+    swap(own_allocator_, other.own_allocator_);
+    swap(initial_size_, other.initial_size_);
+    swap(buffer_minalign_, other.buffer_minalign_);
+    swap(reserved_, other.reserved_);
+    swap(size_, other.size_);
+    swap(max_size_, other.max_size_);
+    swap(buf_, other.buf_);
+    swap(cur_, other.cur_);
+    swap(scratch_, other.scratch_);
+  }
+
+  void swap_allocator(vector_downward& other) {
+    using std::swap;
+    swap(allocator_, other.allocator_);
+    swap(own_allocator_, other.own_allocator_);
+  }
+
+ private:
+  // You shouldn't really be copying instances of this class.
+  FLATBUFFERS_DELETE_FUNC(vector_downward(const vector_downward&));
+  FLATBUFFERS_DELETE_FUNC(vector_downward& operator=(const vector_downward&));
+
+  Allocator* allocator_;
+  bool own_allocator_;
+  size_t initial_size_;
+
+  // The maximum size the vector can be.
+  SizeT max_size_;
+  size_t buffer_minalign_;
+  size_t reserved_;
+  SizeT size_;
+  uint8_t* buf_;
+  uint8_t* cur_;  // Points at location between empty (below) and used (above).
+  uint8_t* scratch_;  // Points to the end of the scratchpad in use.
+
+  void reallocate(size_t len) {
+    auto old_reserved = reserved_;
+    auto old_size = size();
+    auto old_scratch_size = scratch_size();
+    reserved_ +=
+        (std::max)(len, old_reserved ? old_reserved / 2 : initial_size_);
+    reserved_ = (reserved_ + buffer_minalign_ - 1) & ~(buffer_minalign_ - 1);
+    if (buf_) {
+      buf_ = ReallocateDownward(allocator_, buf_, old_reserved, reserved_,
+                                old_size, old_scratch_size);
+    } else {
+      buf_ = Allocate(allocator_, reserved_);
+    }
+    cur_ = buf_ + reserved_ - old_size;
+    scratch_ = buf_ + old_scratch_size;
+  }
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_VECTOR_DOWNWARD_H_
diff --git a/external/flatbuffers/include/flatbuffers/verifier.h b/external/flatbuffers/include/flatbuffers/verifier.h
new file mode 100644
index 00000000..a0b79359
--- /dev/null
+++ b/external/flatbuffers/include/flatbuffers/verifier.h
@@ -0,0 +1,370 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_VERIFIER_H_
+#define FLATBUFFERS_VERIFIER_H_
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/vector.h"
+
+namespace flatbuffers {
+
+// Helper class to verify the integrity of a FlatBuffer
+template <bool TrackVerifierBufferSize>
+class VerifierTemplate FLATBUFFERS_FINAL_CLASS {
+ public:
+  struct Options {
+    // The maximum nesting of tables and vectors before we call it invalid.
+    uoffset_t max_depth = 64;
+    // The maximum number of tables we will verify before we call it invalid.
+    uoffset_t max_tables = 1000000;
+    // If true, verify all data is aligned.
+    bool check_alignment = true;
+    // If true, run verifier on nested flatbuffers
+    bool check_nested_flatbuffers = true;
+    // The maximum size of a buffer.
+    size_t max_size = FLATBUFFERS_MAX_BUFFER_SIZE;
+    // Use assertions to check for errors.
+    bool assert = false;
+  };
+
+  explicit VerifierTemplate(const uint8_t* const buf, const size_t buf_len,
+                            const Options& opts)
+      : buf_(buf), size_(buf_len), opts_(opts) {
+    FLATBUFFERS_ASSERT(size_ < opts.max_size);
+  }
+
+  // Deprecated API, please construct with VerifierTemplate::Options.
+  VerifierTemplate(const uint8_t* const buf, const size_t buf_len,
+                   const uoffset_t max_depth = 64,
+                   const uoffset_t max_tables = 1000000,
+                   const bool check_alignment = true)
+      : VerifierTemplate(buf, buf_len, [&] {
+          Options opts;
+          opts.max_depth = max_depth;
+          opts.max_tables = max_tables;
+          opts.check_alignment = check_alignment;
+          return opts;
+        }()) {}
+
+  // Central location where any verification failures register.
+  bool Check(const bool ok) const {
+    // clang-format off
+    #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
+      if (opts_.assert) { FLATBUFFERS_ASSERT(ok); }
+    #endif
+    // clang-format on
+    if (TrackVerifierBufferSize) {
+      if (!ok) {
+        upper_bound_ = 0;
+      }
+    }
+    return ok;
+  }
+
+  // Verify any range within the buffer.
+  bool Verify(const size_t elem, const size_t elem_len) const {
+    if (TrackVerifierBufferSize) {
+      auto upper_bound = elem + elem_len;
+      if (upper_bound_ < upper_bound) {
+        upper_bound_ = upper_bound;
+      }
+    }
+    return Check(elem_len < size_ && elem <= size_ - elem_len);
+  }
+
+  bool VerifyAlignment(const size_t elem, const size_t align) const {
+    return Check((elem & (align - 1)) == 0 || !opts_.check_alignment);
+  }
+
+  // Verify a range indicated by sizeof(T).
+  template <typename T>
+  bool Verify(const size_t elem) const {
+    return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
+  }
+
+  bool VerifyFromPointer(const uint8_t* const p, const size_t len) {
+    return Verify(static_cast<size_t>(p - buf_), len);
+  }
+
+  // Verify relative to a known-good base pointer.
+  bool VerifyFieldStruct(const uint8_t* const base, const voffset_t elem_off,
+                         const size_t elem_len, const size_t align) const {
+    const auto f = static_cast<size_t>(base - buf_) + elem_off;
+    return VerifyAlignment(f, align) && Verify(f, elem_len);
+  }
+
+  template <typename T>
+  bool VerifyField(const uint8_t* const base, const voffset_t elem_off,
+                   const size_t align) const {
+    const auto f = static_cast<size_t>(base - buf_) + elem_off;
+    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
+  }
+
+  // Verify a pointer (may be NULL) of a table type.
+  template <typename T>
+  bool VerifyTable(const T* const table) {
+    return !table || table->Verify(*this);
+  }
+
+  // Verify a pointer (may be NULL) of any vector type.
+  template <int&..., typename T, typename LenT>
+  bool VerifyVector(const Vector<T, LenT>* const vec) const {
+    return !vec || VerifyVectorOrString<LenT>(
+                       reinterpret_cast<const uint8_t*>(vec), sizeof(T));
+  }
+
+  // Verify a pointer (may be NULL) of a vector to struct.
+  template <int&..., typename T, typename LenT>
+  bool VerifyVector(const Vector<const T*, LenT>* const vec) const {
+    return VerifyVector(reinterpret_cast<const Vector<T, LenT>*>(vec));
+  }
+
+  // Verify a pointer (may be NULL) to string.
+  bool VerifyString(const String* const str) const {
+    size_t end;
+    return !str || (VerifyVectorOrString<uoffset_t>(
+                        reinterpret_cast<const uint8_t*>(str), 1, &end) &&
+                    Verify(end, 1) &&           // Must have terminator
+                    Check(buf_[end] == '\0'));  // Terminating byte must be 0.
+  }
+
+  // Common code between vectors and strings.
+  template <typename LenT = uoffset_t>
+  bool VerifyVectorOrString(const uint8_t* const vec, const size_t elem_size,
+                            size_t* const end = nullptr) const {
+    const auto vec_offset = static_cast<size_t>(vec - buf_);
+    // Check we can read the size field.
+    if (!Verify<LenT>(vec_offset)) return false;
+    // Check the whole array. If this is a string, the byte past the array must
+    // be 0.
+    const LenT size = ReadScalar<LenT>(vec);
+    const auto max_elems = opts_.max_size / elem_size;
+    if (!Check(size < max_elems))
+      return false;  // Protect against byte_size overflowing.
+    const auto byte_size = sizeof(LenT) + elem_size * size;
+    if (end) *end = vec_offset + byte_size;
+    return Verify(vec_offset, byte_size);
+  }
+
+  // Special case for string contents, after the above has been called.
+  bool VerifyVectorOfStrings(const Vector<Offset<String>>* const vec) const {
+    if (vec) {
+      for (uoffset_t i = 0; i < vec->size(); i++) {
+        if (!VerifyString(vec->Get(i))) return false;
+      }
+    }
+    return true;
+  }
+
+  // Special case for table contents, after the above has been called.
+  template <typename T>
+  bool VerifyVectorOfTables(const Vector<Offset<T>>* const vec) {
+    if (vec) {
+      for (uoffset_t i = 0; i < vec->size(); i++) {
+        if (!vec->Get(i)->Verify(*this)) return false;
+      }
+    }
+    return true;
+  }
+
+  FLATBUFFERS_SUPPRESS_UBSAN("unsigned-integer-overflow")
+  bool VerifyTableStart(const uint8_t* const table) {
+    // Check the vtable offset.
+    const auto tableo = static_cast<size_t>(table - buf_);
+    if (!Verify<soffset_t>(tableo)) return false;
+    // This offset may be signed, but doing the subtraction unsigned always
+    // gives the result we want.
+    const auto vtableo =
+        tableo - static_cast<size_t>(ReadScalar<soffset_t>(table));
+    // Check the vtable size field, then check vtable fits in its entirety.
+    if (!(VerifyComplexity() && Verify<voffset_t>(vtableo) &&
+          VerifyAlignment(ReadScalar<voffset_t>(buf_ + vtableo),
+                          sizeof(voffset_t))))
+      return false;
+    const auto vsize = ReadScalar<voffset_t>(buf_ + vtableo);
+    return Check((vsize & 1) == 0) && Verify(vtableo, vsize);
+  }
+
+  template <typename T>
+  bool VerifyBufferFromStart(const char* const identifier, const size_t start) {
+    // Buffers have to be of some size to be valid. The reason it is a runtime
+    // check instead of static_assert, is that nested flatbuffers go through
+    // this call and their size is determined at runtime.
+    if (!Check(size_ >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
+
+    // If an identifier is provided, check that we have a buffer
+    if (identifier && !Check((size_ >= 2 * sizeof(flatbuffers::uoffset_t) &&
+                              BufferHasIdentifier(buf_ + start, identifier)))) {
+      return false;
+    }
+
+    // Call T::Verify, which must be in the generated code for this type.
+    const auto o = VerifyOffset<uoffset_t>(start);
+    if (!Check(o != 0)) return false;
+    if (!(reinterpret_cast<const T*>(buf_ + start + o)->Verify(*this))) {
+      return false;
+    }
+    if (TrackVerifierBufferSize) {
+      if (GetComputedSize() == 0) return false;
+    }
+    return true;
+  }
+
+  template <typename T, int&..., typename SizeT>
+  bool VerifyNestedFlatBuffer(const Vector<uint8_t, SizeT>* const buf,
+                              const char* const identifier) {
+    // Caller opted out of this.
+    if (!opts_.check_nested_flatbuffers) return true;
+
+    // An empty buffer is OK as it indicates not present.
+    if (!buf) return true;
+
+    // If there is a nested buffer, it must be greater than the min size.
+    if (!Check(buf->size() >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
+
+    VerifierTemplate<TrackVerifierBufferSize> nested_verifier(
+        buf->data(), buf->size(), opts_);
+    return nested_verifier.VerifyBuffer<T>(identifier);
+  }
+
+  // Verify this whole buffer, starting with root type T.
+  template <typename T>
+  bool VerifyBuffer() {
+    return VerifyBuffer<T>(nullptr);
+  }
+
+  template <typename T>
+  bool VerifyBuffer(const char* const identifier) {
+    return VerifyBufferFromStart<T>(identifier, 0);
+  }
+
+  template <typename T, typename SizeT = uoffset_t>
+  bool VerifySizePrefixedBuffer(const char* const identifier) {
+    return Verify<SizeT>(0U) &&
+           // Ensure the prefixed size is within the bounds of the provided
+           // length.
+           Check(ReadScalar<SizeT>(buf_) + sizeof(SizeT) <= size_) &&
+           VerifyBufferFromStart<T>(identifier, sizeof(SizeT));
+  }
+
+  template <typename OffsetT = uoffset_t, typename SOffsetT = soffset_t>
+  size_t VerifyOffset(const size_t start) const {
+    if (!Verify<OffsetT>(start)) return 0;
+    const auto o = ReadScalar<OffsetT>(buf_ + start);
+    // May not point to itself.
+    if (!Check(o != 0)) return 0;
+    // Can't wrap around larger than the max size.
+    if (!Check(static_cast<SOffsetT>(o) >= 0)) return 0;
+    // Must be inside the buffer to create a pointer from it (pointer outside
+    // buffer is UB).
+    if (!Verify(start + o, 1)) return 0;
+    return o;
+  }
+
+  template <typename OffsetT = uoffset_t>
+  size_t VerifyOffset(const uint8_t* const base, const voffset_t start) const {
+    return VerifyOffset<OffsetT>(static_cast<size_t>(base - buf_) + start);
+  }
+
+  // Called at the start of a table to increase counters measuring data
+  // structure depth and amount, and possibly bails out with false if limits set
+  // by the constructor have been hit. Needs to be balanced with EndTable().
+  bool VerifyComplexity() {
+    depth_++;
+    num_tables_++;
+    return Check(depth_ <= opts_.max_depth && num_tables_ <= opts_.max_tables);
+  }
+
+  // Called at the end of a table to pop the depth count.
+  bool EndTable() {
+    depth_--;
+    return true;
+  }
+
+  // Returns the message size in bytes.
+  //
+  // This should only be called after first calling VerifyBuffer or
+  // VerifySizePrefixedBuffer.
+  //
+  // This method should only be called for VerifierTemplate instances
+  // where the TrackVerifierBufferSize template parameter is true,
+  // i.e. for SizeVerifier.  For instances where TrackVerifierBufferSize
+  // is false, this fails at runtime or returns zero.
+  size_t GetComputedSize() const {
+    if (TrackVerifierBufferSize) {
+      uintptr_t size = upper_bound_;
+      // Align the size to uoffset_t
+      size = (size - 1 + sizeof(uoffset_t)) & ~(sizeof(uoffset_t) - 1);
+      return (size > size_) ? 0 : size;
+    }
+    // Must use SizeVerifier, or (deprecated) turn on
+    // FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE, for this to work.
+    (void)upper_bound_;
+    FLATBUFFERS_ASSERT(false);
+    return 0;
+  }
+
+  std::vector<uint8_t>* GetFlexReuseTracker() { return flex_reuse_tracker_; }
+
+  void SetFlexReuseTracker(std::vector<uint8_t>* const rt) {
+    flex_reuse_tracker_ = rt;
+  }
+
+ private:
+  const uint8_t* buf_;
+  const size_t size_;
+  const Options opts_;
+
+  mutable size_t upper_bound_ = 0;
+
+  uoffset_t depth_ = 0;
+  uoffset_t num_tables_ = 0;
+  std::vector<uint8_t>* flex_reuse_tracker_ = nullptr;
+};
+
+// Specialization for 64-bit offsets.
+template <>
+template <>
+inline size_t VerifierTemplate<false>::VerifyOffset<uoffset64_t>(
+    const size_t start) const {
+  return VerifyOffset<uoffset64_t, soffset64_t>(start);
+}
+template <>
+template <>
+inline size_t VerifierTemplate<true>::VerifyOffset<uoffset64_t>(
+    const size_t start) const {
+  return VerifyOffset<uoffset64_t, soffset64_t>(start);
+}
+
+// Instance of VerifierTemplate that supports GetComputedSize().
+using SizeVerifier = VerifierTemplate</*TrackVerifierBufferSize = */ true>;
+
+// The FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE build configuration macro is
+// deprecated, and should not be defined, since it is easy to misuse in ways
+// that result in ODR violations. Rather than using Verifier and defining
+// FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE, please use SizeVerifier instead.
+#ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE  // Deprecated, see above.
+using Verifier = SizeVerifier;
+#else
+// Instance of VerifierTemplate that is slightly faster, but does not
+// support GetComputedSize().
+using Verifier = VerifierTemplate</*TrackVerifierBufferSize = */ false>;
+#endif
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_VERIFIER_H_
diff --git a/source/LottieFlatbuffer/README.md b/source/LottieFlatbuffer/README.md
index c07d70e3..33221b7a 100644
--- a/source/LottieFlatbuffer/README.md
+++ b/source/LottieFlatbuffer/README.md
@@ -57,12 +57,16 @@ a buffer may carry meaning in fields the reader does not look at.
 installed. After changing the schema:
 
 ```powershell
-./build/RegenerateFlatbuffers.ps1 -Flatc <path to flatc>
+./build/RegenerateFlatbuffers.ps1 `
+    -CSharpFlatc <path to 25.2.10 flatc> `
+    -CppFlatc <path to 25.12.19 flatc.exe> `
+    -CppSource <path to extracted pinned FlatBuffers source>
 ```
 
-The `flatc` version **must** match the `Google.FlatBuffers` NuGet package version;
-the generated C# calls a version-stamped method that only exists in the matching
-package. Both are currently 25.2.10.
+The C# `flatc` version **must** match the `Google.FlatBuffers` NuGet package
+version. The C++ `flatc` and headers must match each other. The script validates
+both versions and, when `-CppSource` is supplied, refreshes the vendored C++
+headers and license.
 
 ## Consumers
 

From ace259358ef4ce3f2c88e7a882ea25710ef44f93 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@ntdev.microsoft.com>
Date: Fri, 16 Oct 2026 13:40:25 -0700
Subject: [PATCH 33/39] Expose composition metadata and reusable image surfaces

Add native metadata loading with live theme properties, cached loaded-image descriptors and image reuse. Preserve the existing visual-only API, fix owned property-set realization ordering, and document the APIs with focused synthetic native regression tests.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: ee78c03d-680b-409f-8f5b-264e3e7f9317
---
 source/LottieRuntime/LottieRuntime.cpp        | 155 ++++++-
 source/LottieRuntime/LottieRuntime.h          |  59 +++
 source/LottieRuntime/README.md                | 119 ++++++
 tests/LottieRuntime.Tests/MetadataTests.cpp   | 393 ++++++++++++++++++
 .../MetadataTests.manifest                    |   9 +
 5 files changed, 720 insertions(+), 15 deletions(-)
 create mode 100644 tests/LottieRuntime.Tests/MetadataTests.cpp
 create mode 100644 tests/LottieRuntime.Tests/MetadataTests.manifest

diff --git a/source/LottieRuntime/LottieRuntime.cpp b/source/LottieRuntime/LottieRuntime.cpp
index c0f097b7..6a324d60 100644
--- a/source/LottieRuntime/LottieRuntime.cpp
+++ b/source/LottieRuntime/LottieRuntime.cpp
@@ -38,6 +38,7 @@
 
 #include "LottieRuntime.h"
 
+#include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <optional>
@@ -75,9 +76,11 @@ using namespace winrt::Windows::Foundation::Numerics;
 #if defined(LOTTIE_RUNTIME_WINUI3)
 using namespace winrt::Microsoft::UI::Composition;
 namespace XamlMedia = winrt::Microsoft::UI::Xaml::Media;
+namespace Runtime = CommunityToolkit::WinUI3::Lottie;
 #else
 using namespace winrt::Windows::UI::Composition;
 namespace XamlMedia = winrt::Windows::UI::Xaml::Media;
+namespace Runtime = CommunityToolkit::WinUI2::Lottie;
 #endif
 
 namespace
@@ -109,6 +112,7 @@ namespace
         throw winrt::hresult_not_implemented(L"The composition uses a feature this build does not support.");
     }
 
+    _Post_satisfies_(condition)
     void Check(bool condition)
     {
         if (!condition)
@@ -340,7 +344,10 @@ namespace
     class Interpreter
     {
     public:
-        Interpreter(Compositor const& compositor, Fb::LottieComposition const& root) :
+        Interpreter(
+            Compositor const& compositor,
+            Fb::LottieComposition const& root,
+            std::span<Runtime::CompositionImageSurface const> imageSurfaces = {}) :
             m_compositor(compositor),
             m_root(root),
             m_strings(Count(root.strings())),
@@ -363,6 +370,15 @@ namespace
             m_propertySets(Count(root.property_sets()), nullptr),
             m_controllers(Count(root.controllers()), nullptr)
         {
+            for (auto const& image : imageSurfaces)
+            {
+                auto const* source = At(root.surfaces(), image.Index);
+                Check(source->kind() == Fb::SurfaceKind::LoadedImageFromStream ||
+                    source->kind() == Fb::SurfaceKind::LoadedImageFromUri);
+                Check(image.Surface != nullptr && m_surfaces[image.Index] == nullptr);
+                Check(image.Surface.try_as<XamlMedia::LoadedImageSurface>() != nullptr);
+                m_surfaces[image.Index] = image.Surface;
+            }
         }
 
         Visual Run()
@@ -372,6 +388,88 @@ namespace
             return result;
         }
 
+        Runtime::LoadedComposition RunWithMetadata()
+        {
+            auto const* metadata = m_root.metadata();
+            if (metadata == nullptr)
+            {
+                ThrowMalformed();
+            }
+            Check(std::isfinite(metadata->width()) && metadata->width() >= 0);
+            Check(std::isfinite(metadata->height()) && metadata->height() >= 0);
+            Check(metadata->duration_ticks() >= 0);
+            Check(std::isfinite(metadata->frames_per_second()) && metadata->frames_per_second() >= 0);
+
+            // Check even the metadata string references that are not exposed by this API.
+            GetString(metadata->name());
+            if (auto const* bindings = metadata->property_bindings(); bindings != nullptr)
+            {
+                for (uint32_t i = 0; i != bindings->size(); ++i)
+                {
+                    auto const* binding = At(bindings, i);
+                    Check(binding->name() != NullIndex && binding->display_name() != NullIndex);
+                    GetString(binding->name());
+                    GetString(binding->display_name());
+                    Check(binding->actual_type() >= Fb::PropertyValueType::Color &&
+                        binding->actual_type() <= Fb::PropertyValueType::Vector4);
+                    Check(binding->exposed_type() >= Fb::PropertyValueType::Color &&
+                        binding->exposed_type() <= Fb::PropertyValueType::Vector4);
+                    Check(std::isfinite(binding->default_scalar()));
+                    if (auto const* value = binding->default_vector(); value != nullptr)
+                    {
+                        Check(std::isfinite(value->x()) && std::isfinite(value->y()) &&
+                            std::isfinite(value->z()) && std::isfinite(value->w()));
+                    }
+                }
+            }
+
+            auto const themeIndex = metadata->theming_property_set();
+            if (themeIndex != NullIndex)
+            {
+                // Metadata must not expose an object's owned property set as a theme.
+                Check(At(m_root.property_sets(), themeIndex)->owner() == NullIndex);
+            }
+
+            Runtime::LoadedComposition result;
+            result.Duration = winrt::Windows::Foundation::TimeSpan{ metadata->duration_ticks() };
+            result.Size = { metadata->width(), metadata->height() };
+            result.FramesPerSecond = metadata->frames_per_second();
+            if (auto const* markers = metadata->markers(); markers != nullptr)
+            {
+                result.Markers.reserve(markers->size());
+                for (uint32_t i = 0; i != markers->size(); ++i)
+                {
+                    auto const* marker = At(markers, i);
+                    Check(marker->name() != NullIndex);
+                    Check(std::isfinite(marker->progress()));
+                    Check(std::isfinite(marker->duration_progress()) && marker->duration_progress() >= 0);
+                    result.Markers.push_back({
+                        GetString(marker->name()), marker->progress(), marker->duration_progress() });
+                }
+            }
+
+            result.Root = Run();
+            if (themeIndex != NullIndex)
+            {
+                result.ThemeProperties = GetPropertySet(themeIndex);
+            }
+
+            for (uint32_t i = 0; i != m_surfaces.size(); ++i)
+            {
+                if (m_surfaces[i] != nullptr)
+                {
+                    auto const kind = At(m_root.surfaces(), i)->kind();
+                    if (kind == Fb::SurfaceKind::LoadedImageFromStream ||
+                        kind == Fb::SurfaceKind::LoadedImageFromUri)
+                    {
+                        result.ImageSurfaces.push_back({ i, m_surfaces[i] });
+                    }
+                }
+            }
+
+            return result;
+        }
+
     private:
         class TraversalGuard
         {
@@ -409,11 +507,17 @@ namespace
             }
 
             auto const* strings = m_root.strings();
-            Check(strings != nullptr && index < strings->size());
+            if (strings == nullptr || index >= strings->size())
+            {
+                ThrowMalformed();
+            }
             if (!m_stringCached[index])
             {
                 auto const* value = strings->Get(index);
-                Check(value != nullptr);
+                if (value == nullptr)
+                {
+                    ThrowMalformed();
+                }
 
                 m_strings[index] =
                     winrt::to_hstring(std::string_view(value->c_str(), value->size()));
@@ -596,9 +700,12 @@ namespace
 
                 if (auto owner = source->owner(); owner != NullIndex)
                 {
-                    // Realizing the owner populates the cache as a side effect,
-                    // because Initialize realizes the owner's property set.
-                    GetObjectReference(owner);
+                    // The owner may be cached while its children are still being
+                    // initialized. A child's expression can reference these properties
+                    // before the owner's InitializeProperties call is reached.
+                    auto target = GetObjectReference(owner);
+                    Check(target != nullptr);
+                    RealizePropertySet(index, target.Properties());
                 }
                 else
                 {
@@ -2156,15 +2263,8 @@ namespace
         std::vector<AnimationController> m_controllers;
         uint32_t m_traversalDepth = 0;
     };
-}
 
-#if defined(LOTTIE_RUNTIME_WINUI3)
-namespace CommunityToolkit::WinUI3::Lottie
-#else
-namespace CommunityToolkit::WinUI2::Lottie
-#endif
-{
-    Visual LoadComposition(Compositor const& compositor, std::span<std::byte const> buffer)
+    Fb::LottieComposition const& VerifyComposition(std::span<std::byte const> buffer)
     {
         // The buffer is untrusted, so nothing is read out of it until the verifier
         // has agreed that every offset in it is inside it.
@@ -2205,7 +2305,32 @@ namespace CommunityToolkit::WinUI2::Lottie
         static_cast<void>(requiredUapVersion);
 #endif
 
-        return Interpreter(compositor, *root).Run();
+        return *root;
+    }
+}
+
+#if defined(LOTTIE_RUNTIME_WINUI3)
+namespace CommunityToolkit::WinUI3::Lottie
+#else
+namespace CommunityToolkit::WinUI2::Lottie
+#endif
+{
+    Visual LoadComposition(Compositor const& compositor, std::span<std::byte const> buffer)
+    {
+        return Interpreter(compositor, VerifyComposition(buffer)).Run();
+    }
+
+    LoadedComposition LoadCompositionWithMetadata(Compositor const& compositor, std::span<std::byte const> buffer)
+    {
+        return LoadCompositionWithMetadata(compositor, buffer, {});
+    }
+
+    LoadedComposition LoadCompositionWithMetadata(
+        Compositor const& compositor,
+        std::span<std::byte const> buffer,
+        std::span<CompositionImageSurface const> imageSurfaces)
+    {
+        return Interpreter(compositor, VerifyComposition(buffer), imageSurfaces).RunWithMetadata();
     }
 
     CompositionPropertySet ProgressPropertySet(Visual const& root)
diff --git a/source/LottieRuntime/LottieRuntime.h b/source/LottieRuntime/LottieRuntime.h
index 4ecf7297..b0f2bf1f 100644
--- a/source/LottieRuntime/LottieRuntime.h
+++ b/source/LottieRuntime/LottieRuntime.h
@@ -7,7 +7,11 @@
 #include <unknwn.h>
 
 #include <cstddef>
+#include <cstdint>
 #include <span>
+#include <vector>
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Foundation.Numerics.h>
 
 #if defined(LOTTIE_RUNTIME_WINUI2) == defined(LOTTIE_RUNTIME_WINUI3)
 #error Define exactly one of LOTTIE_RUNTIME_WINUI2 or LOTTIE_RUNTIME_WINUI3.
@@ -48,6 +52,61 @@ namespace CommunityToolkit::WinUI2::Lottie
         Compositor const& compositor,
         std::span<std::byte const> buffer);
 
+    struct CompositionMarker
+    {
+        winrt::hstring Name;
+        float Progress = 0;
+        float DurationProgress = 0;
+    };
+
+    struct CompositionImageSurface
+    {
+        uint32_t Index = 0;
+        ICompositionSurface Surface{ nullptr };
+    };
+
+    struct LoadedComposition
+    {
+        Visual Root{ nullptr };
+        winrt::Windows::Foundation::TimeSpan Duration{};
+        winrt::Windows::Foundation::Numerics::float2 Size{};
+        float FramesPerSecond = 0;
+        std::vector<CompositionMarker> Markers;
+        CompositionPropertySet ThemeProperties{ nullptr };
+        std::vector<CompositionImageSurface> ImageSurfaces;
+    };
+
+    // Loads the same animated tree as LoadComposition, together with its serialized
+    // metadata. Duration uses 100ns ticks. Marker progress and duration are fractions
+    // of the animation duration; order and duplicate names are preserved. Markers
+    // outside the animation's playback range are not clamped or discarded.
+    //
+    // ThemeProperties is the actual standalone property set referenced by the
+    // loaded graph's expressions, or nullptr when no theme set is declared.
+    // Inserting values into it updates the existing graph, not a separate copy.
+    //
+    // ImageSurfaces contains the actual realized LoadedImageSurface objects and
+    // their serialized surface indices, in index order. Visual surfaces and
+    // unrealized images are excluded. A host can observe image completion and
+    // reuse these objects when loading another tree from the same buffer.
+    //
+    // Requires a metadata table. Missing metadata, invalid numeric metadata, or
+    // invalid metadata indices throw winrt::hresult_invalid_argument. The returned
+    // metadata owns its values and does not require the buffer to remain alive.
+    LoadedComposition LoadCompositionWithMetadata(
+        Compositor const& compositor,
+        std::span<std::byte const> buffer);
+
+    // Reuses images from a previous load of the same buffer on the same XAML host
+    // compositor. Null surfaces, duplicate/out-of-range indices, nonimage indices,
+    // and objects that are not this projection's LoadedImageSurface are rejected.
+    // Other images are loaded normally. Completion events and playback policy
+    // remain the host's responsibility; this overload does not wait for images.
+    LoadedComposition LoadCompositionWithMetadata(
+        Compositor const& compositor,
+        std::span<std::byte const> buffer,
+        std::span<CompositionImageSurface const> imageSurfaces);
+
     // The property set that drives the animation. Animating its "Progress" scalar from
     // 0 to 1 plays the animation once.
     //
diff --git a/source/LottieRuntime/README.md b/source/LottieRuntime/README.md
index 072017e3..c6eb9f1a 100644
--- a/source/LottieRuntime/README.md
+++ b/source/LottieRuntime/README.md
@@ -68,6 +68,99 @@ projection-specific objects to be linked into the same binary.
 the Composition property set containing the `Progress` scalar. XAML integration
 and `IAnimatedVisual` wrapping remain the caller's responsibility.
 
+Animations containing loaded image surfaces must be loaded on the XAML UI thread
+with the XAML host's compositor (for example, the compositor obtained from
+`ElementCompositionPreview::GetElementVisual(element)`). `LoadedImageSurface`
+uses XAML's image pipeline; initializing only a dispatcher queue or supplying an
+unrelated `Compositor` is not sufficient for these assets.
+
+### Loading metadata and live theme properties
+
+```cpp
+namespace Lottie = CommunityToolkit::WinUI2::Lottie;
+auto animation = Lottie::LoadCompositionWithMetadata(compositor, bytes);
+auto root = animation.Root;                  // Visual
+auto duration = animation.Duration;          // Windows::Foundation::TimeSpan
+auto size = animation.Size;                  // Windows::Foundation::Numerics::float2
+auto framesPerSecond = animation.FramesPerSecond; // float
+auto progress = Lottie::ProgressPropertySet(root);
+for (auto const& marker : animation.Markers)
+{
+    // marker.Name is hstring; Progress and DurationProgress are floats.
+    RegisterMarker(marker.Name, marker.Progress, marker.DurationProgress);
+}
+if (animation.ThemeProperties)
+{
+    // Use the actual serialized property name and Composition storage type.
+    animation.ThemeProperties.InsertVector4(L"Foreground", foregroundVector);
+}
+```
+
+`LoadedComposition` owns its metadata and retains the Composition objects; the
+input buffer may be released after loading. `Duration.count()` is the serialized
+duration in **100ns ticks**, not milliseconds. `Size` and `FramesPerSecond` are
+the serialized source dimensions and frame rate, not inferred from the visual
+tree. Serialized zero values are preserved, including buffers produced without
+source timing metadata.
+
+`Markers` is a `std::vector<CompositionMarker>` with `Name`, `Progress`, and
+`DurationProgress`. Both numeric values are fractions of the entire animation's
+duration, not frame numbers or seconds. Names, order, duplicates, and finite
+out-of-playback-range markers are preserved, matching the serializer's unfiltered
+source markers. A host projecting markers to `IMapView<hstring, double>` must
+choose its own duplicate-name and out-of-range policy. The runtime does not
+invent separate start/end marker names, clamp markers, or nudge frame positions.
+
+`ThemeProperties` is nullable. When present it is the **same standalone
+CompositionPropertySet** used by expressions in the loaded graph, not the root's
+progress property set and not a new set populated from metadata defaults.
+Updating an existing property therefore targets the loaded animation. Color
+bindings may be stored as `Vector4`; use the names/types generated for the asset.
+Theme lifetime follows the returned Composition objects.
+
+### Observing and reusing loaded images
+
+`LoadedComposition.ImageSurfaces` is a
+`std::vector<CompositionImageSurface>`. Each descriptor contains `Index`
+(`uint32_t`, the serialized surface-table index) and `Surface`
+(`ICompositionSurface`). These are the **actual cached `LoadedImageSurface`
+objects used by the returned graph**, not new image loads. Descriptors are in
+serialized index order; visual surfaces and unrealized images are excluded.
+The runtime header does not add a XAML dependency for this field.
+
+A WinUI 2 host can include `<winrt/Windows.UI.Xaml.Media.h>`, cast a descriptor's
+`Surface` to `winrt::Windows::UI::Xaml::Media::LoadedImageSurface`, and subscribe
+to its `LoadCompleted` event. A WinUI 3 host uses the matching
+`Microsoft.UI.Xaml.Media` projection. Image completion, asynchronous-loading
+policy, notifications, retry/fallback, and event revocation belong to the host.
+The runtime starts image loading but does not wait for decoding or substitute
+a static visual. A host waiting for images should retain the first
+`LoadedComposition` and attach its already-created root once ready.
+
+To create another tree without restarting those image loads:
+
+```cpp
+auto another = Lottie::LoadCompositionWithMetadata(
+    compositor, bytes, animation.ImageSurfaces);
+```
+
+This additive three-argument overload seeds the new interpreter's image cache.
+The original two-argument overload and `LoadComposition` remain available.
+Only reuse descriptors from the **same serialized buffer and XAML host
+compositor**; indices do not identify images across different files or UAP
+variants. Null objects, duplicate/out-of-range indices, nonimage surface indices,
+and objects that are not the selected projection's `LoadedImageSurface` are
+rejected with `winrt::hresult_invalid_argument`. Images without a supplied
+descriptor are loaded normally.
+
+`LoadCompositionWithMetadata` requires a metadata table and rejects negative
+duration/dimensions/frame rate/marker duration, nonfinite numeric metadata,
+invalid string/property-set indices and a theme index that refers to an owned
+property set. Missing markers mean an empty vector; the theme sentinel means
+`nullptr`. These are explicit format conventions, not exception fallbacks.
+`LoadComposition` retains its original Visual-only contract and can still load
+buffers without metadata.
+
 ## Validation and safety
 
 The reader verifies the FlatBuffer identifier and structure, range-checks every
@@ -100,3 +193,29 @@ with `--dump`, or displays and animates it with `--show`:
 .\source\LottieRuntime\x64\Release\LottieRuntime.exe Animation.lcomp --dump
 .\source\LottieRuntime\x64\Release\LottieRuntime.exe Animation.lcomp --show
 ```
+
+### Focused native metadata tests
+
+`tests\LottieRuntime.Tests\MetadataTests.cpp` exercises the native API, malformed
+metadata, buffer verification, the legacy no-metadata contract, and theme-cache
+identity, including a child's expression referencing its not-yet-initialized
+parent's owned properties, image/brush cache identity, image reuse across new
+trees, and invalid image-cache descriptors. It uses the existing generated schema
+and vendored FlatBuffers, without an additional test framework. The harness initializes XAML
+on its dispatcher thread and uses its host visual's compositor to exercise image
+assets through `LoadedImageSurface`; its manifest declares the Windows version
+required for desktop XAML hosting.
+From an x64 Visual Studio Developer Command Prompt at the repository root:
+
+```cmd
+mkdir tests\LottieRuntime.Tests\bin
+cl /nologo /std:c++20 /EHsc /W4 /WX /DWIN32_LEAN_AND_MEAN /DNOMINMAX /DLOTTIE_RUNTIME_WINUI2 /Iexternal\flatbuffers\include tests\LottieRuntime.Tests\MetadataTests.cpp /Fotests\LottieRuntime.Tests\bin\MetadataTests.obj /Fetests\LottieRuntime.Tests\bin\MetadataTests.exe /link /MANIFEST:EMBED /MANIFESTINPUT:tests\LottieRuntime.Tests\MetadataTests.manifest CoreMessaging.lib d2d1.lib dxguid.lib ole32.lib shcore.lib shlwapi.lib windowsapp.lib
+tests\LottieRuntime.Tests\bin\MetadataTests.exe
+```
+
+Pass optional `.lcomp` paths to also load real generator output and print its
+dimensions, duration, frame rate, marker count, and realized image count. For
+image-bearing files the runner also creates another tree with the returned image
+descriptors and asserts that every image object is reused rather than reloaded.
+Prefix the paths with `--legacy` to exercise the Visual-only `LoadComposition`
+path instead, separating graph-realization failures from metadata validation.
diff --git a/tests/LottieRuntime.Tests/MetadataTests.cpp b/tests/LottieRuntime.Tests/MetadataTests.cpp
new file mode 100644
index 00000000..8982eec8
--- /dev/null
+++ b/tests/LottieRuntime.Tests/MetadataTests.cpp
@@ -0,0 +1,393 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#include <unknwn.h>
+#include <Windows.h>
+#include <DispatcherQueue.h>
+
+// Include the implementation to test realization-cache identity as well as the API.
+#include "../../source/LottieRuntime/LottieRuntime.cpp"
+
+#include <winrt/Windows.System.h>
+#include <winrt/Windows.UI.Xaml.Hosting.h>
+#include <winrt/Windows.UI.Xaml.Controls.h>
+
+#include <fstream>
+#include <iostream>
+#include <limits>
+#include <stdexcept>
+
+namespace
+{
+    void Require(bool condition)
+    {
+        if (!condition)
+        {
+            throw std::runtime_error("Metadata assertion failed.");
+        }
+    }
+
+    struct Options
+    {
+        bool Metadata = true;
+        bool Markers = true;
+        bool ReferenceTheme = true;
+        bool ReferenceOwnerProperties = false;
+        bool Image = false;
+        uint32_t Theme = 0;
+        uint32_t ThemeOwner = NullIndex;
+        uint32_t Name = 0;
+        uint32_t MarkerName = 1;
+        uint32_t BindingName = 2;
+        uint32_t BindingDisplayName = 2;
+        Fb::PropertyValueType BindingType = Fb::PropertyValueType::Scalar;
+        float Width = 64;
+        float Height = 32;
+        int64_t Ticks = 12345678;
+        float Fps = 60;
+        float Progress = 0.25f;
+        float DurationProgress = 0.5f;
+        float DefaultScalar = 0.75f;
+        uint16_t SchemaVersion = 1;
+    };
+
+    std::vector<std::byte> Buffer(Options const& options = {})
+    {
+        flatbuffers::FlatBufferBuilder builder;
+        std::vector<flatbuffers::Offset<flatbuffers::String>> strings;
+        for (auto text : { "Animation", "Marker", "Opacity", "Theme", "Theme.Opacity", "Progress", "Theme.Progress" })
+        {
+            strings.push_back(builder.CreateString(text));
+        }
+        auto const stringsVector = builder.CreateVector(strings);
+
+        uint8_t const png[] = {
+            0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
+            0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,
+            0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+            0x08, 0x04, 0x00, 0x00, 0x00, 0xB5, 0x1C, 0x0C,
+            0x02, 0x00, 0x00, 0x00, 0x0B, 0x49, 0x44, 0x41,
+            0x54, 0x78, 0xDA, 0x63, 0xFC, 0xFF, 0x1F, 0x00,
+            0x03, 0x03, 0x02, 0x00, 0xEF, 0x9A, 0x2F, 0x5B,
+            0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44,
+            0xAE, 0x42, 0x60, 0x82,
+        };
+        auto const pngBytes = builder.CreateVector(png, std::size(png));
+        auto const image = Fb::CreateSurface(
+            builder, 0, Fb::SurfaceKind::LoadedImageFromStream, NullIndex, nullptr, nullptr, NullIndex, pngBytes);
+        auto const visualSurface = Fb::CreateSurface(builder);
+        auto const surfaces = builder.CreateVector(std::vector{ visualSurface, image, image });
+        Fb::BrushBuilder brushBuilder(builder);
+        brushBuilder.add_kind(Fb::BrushKind::Surface);
+        brushBuilder.add_surface(1);
+        auto const brush = brushBuilder.Finish();
+        auto const brushes = builder.CreateVector(std::vector{ brush });
+
+        auto const value = Fb::CreatePropertyValue(builder, 2, Fb::PropertyValueType::Scalar, 0.75f);
+        auto const themeValues = builder.CreateVector(std::vector{ value });
+        auto const theme = Fb::CreatePropertySet(builder, 0, options.ThemeOwner, themeValues);
+        auto const progressValue = Fb::CreatePropertyValue(builder, 5, Fb::PropertyValueType::Scalar, 0);
+        auto const progressValues = builder.CreateVector(std::vector{ progressValue });
+        auto const progress = Fb::CreatePropertySet(builder, 0, 0, progressValues);
+        auto const sets = builder.CreateVector(std::vector{ theme, progress });
+
+        auto const reference = Fb::CreateReferenceParameter(
+            builder, 3, (static_cast<uint32_t>(Fb::ObjectCategory::PropertySet) << CategoryShift) |
+                (options.ReferenceOwnerProperties ? 1u : 0u));
+        auto const references = builder.CreateVector(std::vector{ reference });
+        auto const animation = Fb::CreateAnimation(
+            builder, 0, Fb::AnimationKind::Expression, NullIndex, references,
+            options.ReferenceOwnerProperties ? 6 : 4);
+        auto const animations = builder.CreateVector(std::vector{ animation });
+        auto const animator = Fb::CreateAnimator(builder, 2, 0);
+        auto const animators = builder.CreateVector(std::vector{ animator });
+        auto const childBase = Fb::CreateCompObj(builder, NullIndex, animators);
+        auto const child = Fb::CreateVisual(builder, childBase);
+        auto const children = builder.CreateVector(std::vector<uint32_t>{ 1 });
+        auto const visualBase = Fb::CreateCompObj(
+            builder, NullIndex, options.ReferenceTheme && !options.ReferenceOwnerProperties ? animators : 0, 1);
+        Fb::VisualBuilder visualBuilder(builder);
+        visualBuilder.add_base(visualBase);
+        if (options.Image)
+        {
+            visualBuilder.add_kind(Fb::VisualKind::Sprite);
+            visualBuilder.add_brush(0);
+        }
+        if (options.ReferenceOwnerProperties)
+        {
+            visualBuilder.add_children(children);
+        }
+        auto const visual = visualBuilder.Finish();
+        auto const visuals = builder.CreateVector(std::vector{ visual, child });
+
+        auto const marker = Fb::CreateMarker(
+            builder, options.MarkerName, options.Progress, options.DurationProgress);
+        auto const markers = builder.CreateVector(std::vector{ marker, marker });
+        auto const binding = Fb::CreatePropertyBinding(
+            builder, options.BindingName, options.BindingDisplayName,
+            options.BindingType, options.BindingType, options.DefaultScalar);
+        auto const bindings = builder.CreateVector(std::vector{ binding });
+        auto const metadata = Fb::CreateMetadata(
+            builder, options.Name, options.Width, options.Height, options.Ticks,
+            options.Fps, bindings, options.Markers ? markers : 0, options.Theme);
+
+        Fb::LottieCompositionBuilder root(builder);
+        root.add_schema_version(options.SchemaVersion);
+        root.add_root_visual(0);
+        root.add_strings(stringsVector);
+        root.add_visuals(visuals);
+        root.add_property_sets(sets);
+        root.add_animations(animations);
+        root.add_surfaces(surfaces);
+        root.add_brushes(brushes);
+        if (options.Metadata)
+        {
+            root.add_metadata(metadata);
+        }
+        Fb::FinishLottieCompositionBuffer(builder, root.Finish());
+        auto const* first = reinterpret_cast<std::byte const*>(builder.GetBufferPointer());
+        return { first, first + builder.GetSize() };
+    }
+
+    void Invalid(
+        Compositor const& compositor,
+        std::vector<std::byte> const& bytes,
+        std::span<Runtime::CompositionImageSurface const> images = {})
+    {
+        try
+        {
+            Runtime::LoadCompositionWithMetadata(compositor, bytes, images);
+        }
+        catch (winrt::hresult_invalid_argument const&)
+        {
+            return;
+        }
+        throw std::runtime_error("Malformed input was not rejected with E_INVALIDARG.");
+    }
+
+    void Test(Compositor const& compositor)
+    {
+        auto bytes = Buffer();
+        auto loaded = Runtime::LoadCompositionWithMetadata(compositor, bytes);
+        Require(loaded.Root != nullptr);
+        Require(loaded.ImageSurfaces.empty());
+        Require(loaded.Duration.count() == 12345678);
+        Require(loaded.Size.x == 64 && loaded.Size.y == 32);
+        Require(loaded.FramesPerSecond == 60);
+        Require(loaded.Markers.size() == 2);
+        Require(loaded.Markers[0].Name == L"Marker");
+        Require(loaded.Markers[0].Progress == 0.25f);
+        Require(loaded.Markers[0].DurationProgress == 0.5f);
+        Require(loaded.Markers[1].Name == loaded.Markers[0].Name);
+        Require(loaded.ThemeProperties != nullptr);
+        Require(loaded.ThemeProperties != Runtime::ProgressPropertySet(loaded.Root));
+        float value = -1;
+        Require(loaded.ThemeProperties.TryGetScalar(L"Opacity", value) == CompositionGetValueStatus::Succeeded);
+        Require(value == 0.75f);
+        Require(Runtime::ProgressPropertySet(loaded.Root).TryGetScalar(L"Progress", value) ==
+            CompositionGetValueStatus::Succeeded && value == 0);
+
+        // The expression realizes the theme while loading the root. Metadata must
+        // return that same cached object, including changes made after realization.
+        Interpreter interpreter(compositor, VerifyComposition(bytes));
+        auto first = interpreter.RunWithMetadata();
+        first.ThemeProperties.InsertScalar(L"Opacity", 0.125f);
+        auto second = interpreter.RunWithMetadata();
+        Require(first.Root == second.Root && first.ThemeProperties == second.ThemeProperties);
+        Require(second.ThemeProperties.TryGetScalar(L"Opacity", value) ==
+            CompositionGetValueStatus::Succeeded && value == 0.125f);
+
+        bytes.clear();
+        Require(loaded.Markers[0].Name == L"Marker" && loaded.Duration.count() == 12345678);
+        loaded.ThemeProperties.InsertScalar(L"Opacity", 0.25f);
+
+        Options options;
+        options.Image = true;
+        bytes = Buffer(options);
+        loaded = Runtime::LoadCompositionWithMetadata(compositor, bytes);
+        Require(loaded.ImageSurfaces.size() == 1 && loaded.ImageSurfaces[0].Index == 1);
+        auto const image = loaded.ImageSurfaces[0].Surface;
+        Require(image.try_as<XamlMedia::LoadedImageSurface>() != nullptr);
+        Require(loaded.Root.as<SpriteVisual>().Brush().as<CompositionSurfaceBrush>().Surface() == image);
+        auto reused = Runtime::LoadCompositionWithMetadata(compositor, bytes, loaded.ImageSurfaces);
+        Require(reused.Root != loaded.Root && reused.ImageSurfaces.size() == 1);
+        Require(reused.ImageSurfaces[0].Index == 1 && reused.ImageSurfaces[0].Surface == image);
+        Require(reused.Root.as<SpriteVisual>().Brush().as<CompositionSurfaceBrush>().Surface() == image);
+        Interpreter imageInterpreter(compositor, VerifyComposition(bytes), loaded.ImageSurfaces);
+        auto cachedImages = imageInterpreter.RunWithMetadata();
+        Require(cachedImages.ImageSurfaces[0].Surface == image);
+        Require(imageInterpreter.RunWithMetadata().ImageSurfaces[0].Surface == image);
+
+        auto images = loaded.ImageSurfaces;
+        images.push_back(images[0]);
+        Invalid(compositor, bytes, images);
+        for (auto index : { 0u, 99u, NullIndex })
+        {
+            images = loaded.ImageSurfaces;
+            images[0].Index = index;
+            Invalid(compositor, bytes, images);
+        }
+        images = loaded.ImageSurfaces;
+        images[0].Surface = nullptr;
+        Invalid(compositor, bytes, images);
+        images[0].Surface = compositor.CreateVisualSurface();
+        Invalid(compositor, bytes, images);
+
+        options = {};
+        options.Theme = NullIndex;
+        options.Markers = false;
+        loaded = Runtime::LoadCompositionWithMetadata(compositor, Buffer(options));
+        Require(loaded.ThemeProperties == nullptr && loaded.Markers.empty());
+
+        options = {};
+        options.ReferenceTheme = false;
+        loaded = Runtime::LoadCompositionWithMetadata(compositor, Buffer(options));
+        Require(loaded.ThemeProperties != nullptr);
+        Require(loaded.ThemeProperties.TryGetScalar(L"Opacity", value) ==
+            CompositionGetValueStatus::Succeeded && value == 0.75f);
+
+        options = {};
+        options.ReferenceOwnerProperties = true;
+        loaded = Runtime::LoadCompositionWithMetadata(compositor, Buffer(options));
+        Require(loaded.Root.as<ContainerVisual>().Children().Count() == 1);
+        Require(Runtime::ProgressPropertySet(loaded.Root).TryGetScalar(L"Progress", value) ==
+            CompositionGetValueStatus::Succeeded && value == 0);
+
+        options = {};
+        options.Progress = -0.5f;
+        options.DurationProgress = 2;
+        loaded = Runtime::LoadCompositionWithMetadata(compositor, Buffer(options));
+        Require(loaded.Markers[0].Progress == -0.5f && loaded.Markers[0].DurationProgress == 2);
+
+        options = {};
+        options.Width = options.Height = options.Fps = 0;
+        options.Ticks = 0;
+        loaded = Runtime::LoadCompositionWithMetadata(compositor, Buffer(options));
+        Require(loaded.Duration.count() == 0 && loaded.Size.x == 0 && loaded.FramesPerSecond == 0);
+
+        options = {};
+        options.Metadata = false;
+        bytes = Buffer(options);
+        Require(Runtime::LoadComposition(compositor, bytes) != nullptr);
+        Invalid(compositor, bytes);
+
+        auto const nan = std::numeric_limits<float>::quiet_NaN();
+        auto const infinity = std::numeric_limits<float>::infinity();
+        for (auto bad : { -1.0f, nan, infinity })
+        {
+            options = {}; options.Width = bad; Invalid(compositor, Buffer(options));
+            options = {}; options.Height = bad; Invalid(compositor, Buffer(options));
+            options = {}; options.Fps = bad; Invalid(compositor, Buffer(options));
+            options = {}; options.DurationProgress = bad; Invalid(compositor, Buffer(options));
+        }
+        for (auto bad : { nan, infinity })
+        {
+            options = {}; options.Progress = bad; Invalid(compositor, Buffer(options));
+            options = {}; options.DefaultScalar = bad; Invalid(compositor, Buffer(options));
+        }
+        options = {}; options.Ticks = -1; Invalid(compositor, Buffer(options));
+        options = {}; options.Theme = 99; Invalid(compositor, Buffer(options));
+        options = {}; options.Theme = 1; Invalid(compositor, Buffer(options));
+        options = {}; options.ThemeOwner = 0; Invalid(compositor, Buffer(options));
+        options = {}; options.Name = 99; Invalid(compositor, Buffer(options));
+        for (auto bad : { 99u, NullIndex })
+        {
+            options = {}; options.MarkerName = bad; Invalid(compositor, Buffer(options));
+            options = {}; options.BindingName = bad; Invalid(compositor, Buffer(options));
+            options = {}; options.BindingDisplayName = bad; Invalid(compositor, Buffer(options));
+        }
+        options = {};
+        options.BindingType = static_cast<Fb::PropertyValueType>(255);
+        Invalid(compositor, Buffer(options));
+
+        bytes = Buffer();
+        for (size_t length = 0; length < bytes.size(); length += 8)
+        {
+            Invalid(compositor, { bytes.begin(), bytes.begin() + length });
+        }
+        bytes[4] = std::byte{ 'X' };
+        Invalid(compositor, bytes);
+        Invalid(compositor, {});
+
+        options = {}; options.SchemaVersion = 2;
+        try
+        {
+            Runtime::LoadCompositionWithMetadata(compositor, Buffer(options));
+            throw std::runtime_error("Unsupported schema was not rejected.");
+        }
+        catch (winrt::hresult_not_implemented const&)
+        {
+        }
+    }
+}
+
+int wmain(int argc, wchar_t** argv)
+{
+    try
+    {
+        winrt::init_apartment(winrt::apartment_type::single_threaded);
+        DispatcherQueueOptions const options{ sizeof(DispatcherQueueOptions), DQTYPE_THREAD_CURRENT, DQTAT_COM_NONE };
+        winrt::Windows::System::DispatcherQueueController queue{ nullptr };
+        winrt::check_hresult(CreateDispatcherQueueController(
+            options, reinterpret_cast<PDISPATCHERQUEUECONTROLLER*>(winrt::put_abi(queue))));
+        auto xaml = winrt::Windows::UI::Xaml::Hosting::WindowsXamlManager::InitializeForCurrentThread();
+        {
+            winrt::Windows::UI::Xaml::Controls::Grid host;
+            auto compositor = winrt::Windows::UI::Xaml::Hosting::ElementCompositionPreview::GetElementVisual(host).Compositor();
+            bool const legacy = argc > 1 && std::wstring_view(argv[1]) == L"--legacy";
+            if (!legacy)
+            {
+                Test(compositor);
+            }
+            for (int i = legacy ? 2 : 1; i < argc; ++i)
+            {
+                std::ifstream file(argv[i], std::ios::binary | std::ios::ate);
+                Require(file.good());
+                std::vector<std::byte> bytes(static_cast<size_t>(file.tellg()));
+                file.seekg(0);
+                file.read(reinterpret_cast<char*>(bytes.data()), static_cast<std::streamsize>(bytes.size()));
+                Require(file.good());
+                if (legacy)
+                {
+                    auto root = Runtime::LoadComposition(compositor, bytes);
+                    Require(root != nullptr);
+                    std::wcout << argv[i] << L": legacy composition loaded\n";
+                    continue;
+                }
+                auto loaded = Runtime::LoadCompositionWithMetadata(compositor, bytes);
+                Require(loaded.Root != nullptr);
+                auto const* metadata = VerifyComposition(bytes).metadata();
+                Require((loaded.ThemeProperties != nullptr) == (metadata->theming_property_set() != NullIndex));
+                if (!loaded.ImageSurfaces.empty())
+                {
+                    auto reused = Runtime::LoadCompositionWithMetadata(compositor, bytes, loaded.ImageSurfaces);
+                    Require(reused.Root != loaded.Root && reused.ImageSurfaces.size() == loaded.ImageSurfaces.size());
+                    for (size_t image = 0; image < loaded.ImageSurfaces.size(); ++image)
+                    {
+                        Require(loaded.ImageSurfaces[image].Surface.try_as<XamlMedia::LoadedImageSurface>() != nullptr);
+                        Require(reused.ImageSurfaces[image].Index == loaded.ImageSurfaces[image].Index);
+                        Require(reused.ImageSurfaces[image].Surface == loaded.ImageSurfaces[image].Surface);
+                    }
+                }
+                std::wcout << argv[i] << L": " << loaded.Size.x << L"x" << loaded.Size.y
+                    << L", ticks=" << loaded.Duration.count() << L", fps=" << loaded.FramesPerSecond
+                    << L", markers=" << loaded.Markers.size()
+                    << L", theme=" << (loaded.ThemeProperties != nullptr ? L"present" : L"absent")
+                    << L", images=" << loaded.ImageSurfaces.size() << L"\n";
+            }
+        }
+        queue.ShutdownQueueAsync();
+        std::cout << "Metadata tests passed.\n";
+        return 0;
+    }
+    catch (winrt::hresult_error const& error)
+    {
+        std::wcerr << error.message().c_str() << L"\n";
+    }
+    catch (std::exception const& error)
+    {
+        std::cerr << error.what() << "\n";
+    }
+    return 1;
+}
diff --git a/tests/LottieRuntime.Tests/MetadataTests.manifest b/tests/LottieRuntime.Tests/MetadataTests.manifest
new file mode 100644
index 00000000..e7fc0a80
--- /dev/null
+++ b/tests/LottieRuntime.Tests/MetadataTests.manifest
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+      <maxversiontested Id="10.0.26100.0" />
+    </application>
+  </compatibility>
+</assembly>

From 3f64a009eec7b9270da6c2fad59f5d41a9a5fad8 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@ntdev.microsoft.com>
Date: Sat, 17 Oct 2026 13:52:41 -0700
Subject: [PATCH 34/39] Add animation stop and restart support to LottieRuntime

Hosts can implement IAnimatedVisual2 by calling StopAnimations from
DestroyAnimations and StartAnimations from CreateAnimations, as LottieGen's
generated code did. Without it AnimatedVisualPlayer's Resources optimization
cannot release idle animations.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: cfdf7544-9ef9-4586-8d82-56d89206cc1d
---
 source/LottieRuntime/LottieRuntime.cpp      | 186 +++++++++++++++++++-
 source/LottieRuntime/LottieRuntime.h        |  24 +++
 source/LottieRuntime/README.md              |  24 +++
 tests/LottieRuntime.Tests/MetadataTests.cpp |  41 ++++-
 4 files changed, 273 insertions(+), 2 deletions(-)

diff --git a/source/LottieRuntime/LottieRuntime.cpp b/source/LottieRuntime/LottieRuntime.cpp
index 6a324d60..a16a22d0 100644
--- a/source/LottieRuntime/LottieRuntime.cpp
+++ b/source/LottieRuntime/LottieRuntime.cpp
@@ -332,6 +332,45 @@ namespace
     };
 }
 
+#if defined(LOTTIE_RUNTIME_WINUI3)
+namespace CommunityToolkit::WinUI3::Lottie
+#else
+namespace CommunityToolkit::WinUI2::Lottie
+#endif
+{
+    class CompositionAnimations
+    {
+    public:
+        struct ControllerAnimation
+        {
+            winrt::hstring Property;
+            CompositionAnimation Animation{ nullptr };
+        };
+
+        // One keyframe animation started on a graph object, with how to restart it.
+        struct Binding
+        {
+            CompositionObject Target{ nullptr };
+            winrt::hstring Property;
+            CompositionAnimation Animation{ nullptr };
+
+            // A custom controller outlives StopAnimation, so it is reused as is.
+            AnimationController Controller{ nullptr };
+
+            // An implicit controller is replaced on every StartAnimation, so it is
+            // realized again from this description.
+            bool HasImplicitController = false;
+            bool PauseImplicitController = false;
+            winrt::hstring ImplicitControllerComment;
+            std::vector<ControllerAnimation> ImplicitControllerAnimations;
+        };
+
+        std::vector<Binding> Bindings;
+        bool Restartable = true;
+        bool Running = true;
+    };
+}
+
 namespace
 {
     // ---------------------------------------------------------------------------
@@ -467,6 +506,11 @@ namespace
                 }
             }
 
+            auto animations = std::make_shared<Runtime::CompositionAnimations>();
+            animations->Bindings = m_animationBindings;
+            animations->Restartable = m_animationsRestartable;
+            result.Animations = std::move(animations);
+
             return result;
         }
 
@@ -604,11 +648,80 @@ namespace
                     target.StartAnimation(property, animation);
                 }
 
-                if (controllerIndex != NullIndex && customController == nullptr)
+                auto const implicitController = controllerIndex != NullIndex && customController == nullptr;
+                if (implicitController)
                 {
                     RealizeController(controllerIndex, target, property);
                 }
+
+                RecordAnimation(target, property, animation, customController,
+                    implicitController ? controllerIndex : NullIndex);
+            }
+        }
+
+        // Records a started keyframe animation so that StopAnimations and StartAnimations
+        // can replay it. Expression animations, and animations of the controllers
+        // themselves, are bindings that stay in place, as in LottieGen's generated code.
+        void RecordAnimation(
+            CompositionObject const& target,
+            winrt::hstring const& property,
+            CompositionAnimation const& animation,
+            AnimationController const& customController,
+            uint32_t implicitControllerIndex)
+        {
+            if (animation.try_as<ExpressionAnimation>() != nullptr ||
+                target.try_as<AnimationController>() != nullptr)
+            {
+                return;
+            }
+
+            Runtime::CompositionAnimations::Binding binding{ target, property, animation, customController };
+            if (implicitControllerIndex != NullIndex)
+            {
+                // Each implicit controller must belong to exactly one animation, or a
+                // restart could not reproduce which animations it paused.
+                if (m_implicitControllerUsed.empty())
+                {
+                    m_implicitControllerUsed.resize(m_controllers.size());
+                }
+                if (m_implicitControllerUsed[implicitControllerIndex])
+                {
+                    m_animationsRestartable = false;
+                }
+                m_implicitControllerUsed[implicitControllerIndex] = true;
+
+                auto const* source = At(m_root.controllers(), implicitControllerIndex);
+                binding.HasImplicitController = true;
+                binding.PauseImplicitController = source->is_paused();
+                if (auto const* base = source->base(); base != nullptr)
+                {
+                    if (base->properties() != NullIndex)
+                    {
+                        // Other expressions may reference the set the first controller owned.
+                        m_animationsRestartable = false;
+                    }
+                    if (auto comment = base->comment(); comment != NullIndex)
+                    {
+                        binding.ImplicitControllerComment = GetString(comment);
+                    }
+                    if (auto const* animators = base->animators(); animators != nullptr)
+                    {
+                        for (uint32_t i = 0; i != animators->size(); ++i)
+                        {
+                            auto const* animator = animators->Get(i);
+                            Check(animator != nullptr);
+                            if (animator->controller() != NullIndex)
+                            {
+                                m_animationsRestartable = false;
+                            }
+                            binding.ImplicitControllerAnimations.push_back({
+                                GetString(animator->property()), GetAnimation(animator->animation()) });
+                        }
+                    }
+                }
             }
+
+            m_animationBindings.push_back(std::move(binding));
         }
 
         bool IsCustomController(uint32_t index) const
@@ -770,6 +883,12 @@ namespace
                 }
             }
 
+            if (!source->is_custom())
+            {
+                // The reference would outlive the implicit controller a restart replaces.
+                m_animationsRestartable = false;
+            }
+
             Check(m_controllers[index] != nullptr);
             return m_controllers[index];
         }
@@ -2261,6 +2380,9 @@ namespace
         std::vector<CompositionAnimation> m_animations;
         std::vector<CompositionPropertySet> m_propertySets;
         std::vector<AnimationController> m_controllers;
+        std::vector<Runtime::CompositionAnimations::Binding> m_animationBindings;
+        std::vector<bool> m_implicitControllerUsed;
+        bool m_animationsRestartable = true;
         uint32_t m_traversalDepth = 0;
     };
 
@@ -2337,4 +2459,66 @@ namespace CommunityToolkit::WinUI2::Lottie
     {
         return root.Properties();
     }
+
+    bool CanRestartAnimations(LoadedComposition const& composition) noexcept
+    {
+        return composition.Animations != nullptr && composition.Animations->Restartable;
+    }
+
+    void StopAnimations(LoadedComposition const& composition)
+    {
+        if (!CanRestartAnimations(composition) || !composition.Animations->Running)
+        {
+            return;
+        }
+
+        for (auto const& binding : composition.Animations->Bindings)
+        {
+            binding.Target.StopAnimation(binding.Property);
+        }
+        composition.Animations->Running = false;
+    }
+
+    void StartAnimations(LoadedComposition const& composition)
+    {
+        if (!CanRestartAnimations(composition) || composition.Animations->Running)
+        {
+            return;
+        }
+
+        for (auto const& binding : composition.Animations->Bindings)
+        {
+            if (binding.Controller != nullptr)
+            {
+                binding.Target.StartAnimation(binding.Property, binding.Animation, binding.Controller);
+            }
+            else
+            {
+                binding.Target.StartAnimation(binding.Property, binding.Animation);
+            }
+
+            if (binding.HasImplicitController)
+            {
+                // Same order as the load: pause, then the controller's own state.
+                auto controller = binding.Target.TryGetAnimationController(binding.Property);
+                if (controller == nullptr)
+                {
+                    throw winrt::hresult_error(E_UNEXPECTED);
+                }
+                if (binding.PauseImplicitController)
+                {
+                    controller.Pause();
+                }
+                if (!binding.ImplicitControllerComment.empty())
+                {
+                    controller.Comment(binding.ImplicitControllerComment);
+                }
+                for (auto const& animation : binding.ImplicitControllerAnimations)
+                {
+                    controller.StartAnimation(animation.Property, animation.Animation);
+                }
+            }
+        }
+        composition.Animations->Running = true;
+    }
 }
diff --git a/source/LottieRuntime/LottieRuntime.h b/source/LottieRuntime/LottieRuntime.h
index b0f2bf1f..a4308d1c 100644
--- a/source/LottieRuntime/LottieRuntime.h
+++ b/source/LottieRuntime/LottieRuntime.h
@@ -8,6 +8,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <span>
 #include <vector>
 #include <winrt/Windows.Foundation.h>
@@ -65,6 +66,10 @@ namespace CommunityToolkit::WinUI2::Lottie
         ICompositionSurface Surface{ nullptr };
     };
 
+    // The keyframe animations a loaded tree started, recorded so that a host can stop
+    // and restart them. Shared by copies of the LoadedComposition that owns it.
+    class CompositionAnimations;
+
     struct LoadedComposition
     {
         Visual Root{ nullptr };
@@ -74,6 +79,7 @@ namespace CommunityToolkit::WinUI2::Lottie
         std::vector<CompositionMarker> Markers;
         CompositionPropertySet ThemeProperties{ nullptr };
         std::vector<CompositionImageSurface> ImageSurfaces;
+        std::shared_ptr<CompositionAnimations> Animations;
     };
 
     // Loads the same animated tree as LoadComposition, together with its serialized
@@ -112,4 +118,22 @@ namespace CommunityToolkit::WinUI2::Lottie
     //
     // Returns the root Visual's property set.
     CompositionPropertySet ProgressPropertySet(Visual const& root);
+
+    // Stop and restart support for IAnimatedVisual2::DestroyAnimations and
+    // CreateAnimations, matching LottieGen's generated C++ and C# sources.
+    //
+    // StopAnimations stops the keyframe animations the load started, leaving every
+    // animated property at its current value and keeping expression bindings (Progress,
+    // theme and other bindings) in place. StartAnimations starts them again with their
+    // original controllers, so the tree once more follows its Progress property. A loaded
+    // composition starts with its animations running. Both calls are idempotent.
+    //
+    // CanRestartAnimations returns false when the tree cannot be restarted faithfully:
+    // another object references an implicit animation controller, an implicit controller
+    // owns a property set, two animations share one implicit controller, or an implicit
+    // controller's own animation has a controller. For such trees, and for a default
+    // LoadedComposition, StopAnimations and StartAnimations do nothing.
+    bool CanRestartAnimations(LoadedComposition const& composition) noexcept;
+    void StopAnimations(LoadedComposition const& composition);
+    void StartAnimations(LoadedComposition const& composition);
 }
diff --git a/source/LottieRuntime/README.md b/source/LottieRuntime/README.md
index c6eb9f1a..a9ac8be8 100644
--- a/source/LottieRuntime/README.md
+++ b/source/LottieRuntime/README.md
@@ -153,6 +153,30 @@ and objects that are not the selected projection's `LoadedImageSurface` are
 rejected with `winrt::hresult_invalid_argument`. Images without a supplied
 descriptor are loaded normally.
 
+### Stopping and restarting animations
+
+Loading starts every animation, paused and driven by `Progress`. A host that
+implements `IAnimatedVisual2` (for `AnimatedVisualPlayer`'s
+`AnimationOptimization="Resources"`) can release and recreate them:
+
+```cpp
+void DestroyAnimations() { Lottie::StopAnimations(animation); }
+void CreateAnimations() { Lottie::StartAnimations(animation); }
+```
+
+`StopAnimations` stops every keyframe animation the load started; expression
+bindings, including those to `Progress` and `ThemeProperties`, stay live.
+`StartAnimations` restarts them on the same controllers, restoring each implicit
+controller's pause state, comment and controller animations, so playback
+resumes from the current `Progress`. Both calls are idempotent and no-ops on a
+default `LoadedComposition`.
+
+`CanRestartAnimations(animation)` returns false when the graph cannot be
+restarted faithfully, for example when another object references an implicit
+controller that a restart would replace. Both calls are then no-ops and the
+animations stay running, so a host can keep advertising `IAnimatedVisual2`.
+Restart state is shared by copies of the same `LoadedComposition`.
+
 `LoadCompositionWithMetadata` requires a metadata table and rejects negative
 duration/dimensions/frame rate/marker duration, nonfinite numeric metadata,
 invalid string/property-set indices and a theme index that refers to an owned
diff --git a/tests/LottieRuntime.Tests/MetadataTests.cpp b/tests/LottieRuntime.Tests/MetadataTests.cpp
index 8982eec8..e7bbb7a3 100644
--- a/tests/LottieRuntime.Tests/MetadataTests.cpp
+++ b/tests/LottieRuntime.Tests/MetadataTests.cpp
@@ -166,6 +166,37 @@ namespace
         throw std::runtime_error("Malformed input was not rejected with E_INVALIDARG.");
     }
 
+    // Every recorded animation is a keyframe animation, which always has a controller
+    // while it runs and none once it is stopped.
+    void RequireAnimationsRunning(Runtime::LoadedComposition const& loaded, bool running)
+    {
+        for (auto const& binding : loaded.Animations->Bindings)
+        {
+            Require(binding.Animation.try_as<ExpressionAnimation>() == nullptr);
+            Require((binding.Target.TryGetAnimationController(binding.Property) != nullptr) == running);
+        }
+    }
+
+    // Returns the number of recorded animations.
+    size_t TestRestart(Runtime::LoadedComposition const& loaded)
+    {
+        Require(Runtime::CanRestartAnimations(loaded));
+        RequireAnimationsRunning(loaded, true);
+        for (int cycle = 0; cycle != 2; ++cycle)
+        {
+            Runtime::StopAnimations(loaded);
+            Runtime::StopAnimations(loaded);
+            RequireAnimationsRunning(loaded, false);
+            Runtime::StartAnimations(loaded);
+            Runtime::StartAnimations(loaded);
+            RequireAnimationsRunning(loaded, true);
+        }
+
+        // Restarting must not disturb the expression that drives playback.
+        Runtime::ProgressPropertySet(loaded.Root).InsertScalar(L"Progress", 0.5f);
+        return loaded.Animations->Bindings.size();
+    }
+
     void Test(Compositor const& compositor)
     {
         auto bytes = Buffer();
@@ -188,6 +219,13 @@ namespace
         Require(Runtime::ProgressPropertySet(loaded.Root).TryGetScalar(L"Progress", value) ==
             CompositionGetValueStatus::Succeeded && value == 0);
 
+        // Expression bindings are not stopped, so this tree records no animations.
+        Require(TestRestart(loaded) == 0);
+        Runtime::LoadedComposition empty;
+        Require(!Runtime::CanRestartAnimations(empty));
+        Runtime::StopAnimations(empty);
+        Runtime::StartAnimations(empty);
+
         // The expression realizes the theme while loading the root. Metadata must
         // return that same cached object, including changes made after realization.
         Interpreter interpreter(compositor, VerifyComposition(bytes));
@@ -374,7 +412,8 @@ int wmain(int argc, wchar_t** argv)
                     << L", ticks=" << loaded.Duration.count() << L", fps=" << loaded.FramesPerSecond
                     << L", markers=" << loaded.Markers.size()
                     << L", theme=" << (loaded.ThemeProperties != nullptr ? L"present" : L"absent")
-                    << L", images=" << loaded.ImageSurfaces.size() << L"\n";
+                    << L", images=" << loaded.ImageSurfaces.size()
+                    << L", restartable animations=" << TestRestart(loaded) << L"\n";
             }
         }
         queue.ShutdownQueueAsync();

From c36b7b9821e1bc8003cf039f0a4024282dc5a061 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@ntdev.microsoft.com>
Date: Sat, 17 Oct 2026 14:31:45 -0700
Subject: [PATCH 35/39] Add shared AnimatedVisualPlayer source to LottieRuntime

Add LottieVisualSource, an IAnimatedVisualSource2 implementation over serialized
compositions for hosts that use AnimatedVisualPlayer. Visuals implement
IAnimatedVisual2 so AnimationOptimization="Resources" can stop animations while
idle, and IClosable. Sources with images also implement
IDynamicAnimatedVisualSource and report image loading progress.

The source selects the embedded variant for the running UAP contract, forwards
theme colors (and scalars through SetScalarProperty) to live and future visuals,
and builds markers using the options each host needs.

Add VisualSourceTests, which hosts XAML and checks animation stop and restart,
theme bindings, marker ranges, closing, and error reporting. Undefine
BUILD_WINDOWS in LottieRuntime.cpp so the vendored copy builds unchanged.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: cfdf7544-9ef9-4586-8d82-56d89206cc1d
---
 source/LottieRuntime/LottieRuntime.cpp        |   3 +
 source/LottieRuntime/LottieVisualSource.cpp   | 611 ++++++++++++++++++
 source/LottieRuntime/LottieVisualSource.h     |  93 +++
 source/LottieRuntime/README.md                |  79 ++-
 .../LottieRuntime.Tests/VisualSourceTests.cpp | 267 ++++++++
 5 files changed, 1051 insertions(+), 2 deletions(-)
 create mode 100644 source/LottieRuntime/LottieVisualSource.cpp
 create mode 100644 source/LottieRuntime/LottieVisualSource.h
 create mode 100644 tests/LottieRuntime.Tests/VisualSourceTests.cpp

diff --git a/source/LottieRuntime/LottieRuntime.cpp b/source/LottieRuntime/LottieRuntime.cpp
index a16a22d0..1041d478 100644
--- a/source/LottieRuntime/LottieRuntime.cpp
+++ b/source/LottieRuntime/LottieRuntime.cpp
@@ -29,6 +29,9 @@
 // to ask what a node actually is, because the buffer already said, and the answer was
 // consumed at the moment of creation.
 
+// Public SDK interop declarations must use ABI::Windows in every consumer.
+#undef BUILD_WINDOWS
+
 // C++/WinRT requires <unknwn.h> before projected headers.
 #include <unknwn.h>
 
diff --git a/source/LottieRuntime/LottieVisualSource.cpp b/source/LottieRuntime/LottieVisualSource.cpp
new file mode 100644
index 00000000..a429ec3d
--- /dev/null
+++ b/source/LottieRuntime/LottieVisualSource.cpp
@@ -0,0 +1,611 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// An IAnimatedVisualSource2 over the runtime, replacing the classes LottieGen generates
+// for each animation.
+
+#include <unknwn.h>
+#include <windows.h>
+#include <hstring.h>
+
+#if defined(LOTTIE_RUNTIME_WINUI2) == defined(LOTTIE_RUNTIME_WINUI3)
+#error Define exactly one of LOTTIE_RUNTIME_WINUI2 or LOTTIE_RUNTIME_WINUI3.
+#endif
+
+#include "LottieVisualSource.h"
+
+#include <algorithm>
+#include <cmath>
+#include <map>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <winrt/Windows.Foundation.Collections.h>
+#include <winrt/Windows.Foundation.Metadata.h>
+#include <winrt/Windows.UI.h>
+
+#undef GetCurrentTime
+#if defined(LOTTIE_RUNTIME_WINUI3)
+#include <winrt/Microsoft.UI.Xaml.Data.h>
+#include <winrt/Microsoft.UI.Xaml.Media.h>
+#else
+#include <winrt/Windows.UI.Xaml.Data.h>
+#include <winrt/Windows.UI.Xaml.Media.h>
+#endif
+
+#include "Generated/lottie_comp_generated.h"
+
+#if defined(LOTTIE_RUNTIME_WINUI3)
+namespace CommunityToolkit::WinUI3::Lottie
+#else
+namespace CommunityToolkit::WinUI2::Lottie
+#endif
+{
+    namespace
+    {
+        namespace Fb = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema;
+        using namespace winrt::Microsoft::UI::Xaml::Controls;
+        using namespace winrt::Windows::Foundation;
+        using namespace winrt::Windows::Foundation::Collections;
+        using namespace winrt::Windows::Foundation::Numerics;
+        using winrt::hstring;
+        using winrt::Windows::Foundation::IInspectable;
+#if defined(LOTTIE_RUNTIME_WINUI3)
+        namespace XamlData = winrt::Microsoft::UI::Xaml::Data;
+        namespace XamlMedia = winrt::Microsoft::UI::Xaml::Media;
+#else
+        namespace XamlData = winrt::Windows::UI::Xaml::Data;
+        namespace XamlMedia = winrt::Windows::UI::Xaml::Media;
+#endif
+
+        // IAnimatedVisualSource2 has no scalar setter, so sources expose it privately.
+#if defined(LOTTIE_RUNTIME_WINUI3)
+        struct __declspec(uuid("ae67b9f9-0afe-467c-9d06-f6a2dbaa46da")) __declspec(novtable) IScalarProperties : ::IUnknown
+#else
+        struct __declspec(uuid("c36aecea-4fd6-42ae-ac25-7cb9c564476e")) __declspec(novtable) IScalarProperties : ::IUnknown
+#endif
+        {
+            virtual HRESULT __stdcall SetScalar(HSTRING name, double value) noexcept = 0;
+        };
+
+        bool IsUapPresent(uint16_t version)
+        {
+            return winrt::Windows::Foundation::Metadata::ApiInformation::IsApiContractPresent(
+                L"Windows.Foundation.UniversalApiContract", version);
+        }
+
+        Fb::LottieComposition const* Verify(std::span<std::byte const> buffer)
+        {
+            flatbuffers::Verifier verifier(reinterpret_cast<uint8_t const*>(buffer.data()), buffer.size());
+            if (buffer.empty() || !Fb::VerifyLottieCompositionBuffer(verifier))
+            {
+                throw winrt::hresult_invalid_argument(L"Invalid serialized Lottie composition.");
+            }
+            return Fb::GetLottieComposition(buffer.data());
+        }
+
+        bool HasImages(Fb::LottieComposition const& composition)
+        {
+            if (auto surfaces = composition.surfaces())
+            {
+                for (auto surface : *surfaces)
+                {
+                    if (surface->kind() == Fb::SurfaceKind::LoadedImageFromStream ||
+                        surface->kind() == Fb::SurfaceKind::LoadedImageFromUri)
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        struct AnimatedVisual : winrt::implements<AnimatedVisual, IAnimatedVisual2, IAnimatedVisual, IClosable>
+        {
+            explicit AnimatedVisual(LoadedComposition composition) : m_composition(std::move(composition))
+            {
+            }
+
+            Visual RootVisual() const { return m_composition.Root; }
+            TimeSpan Duration() const { return m_composition.Duration; }
+            float2 Size() const { return m_composition.Size; }
+            CompositionPropertySet ThemeProperties() const { return m_composition.ThemeProperties; }
+
+            void CreateAnimations() { StartAnimations(m_composition); }
+            void DestroyAnimations() { StopAnimations(m_composition); }
+
+            void Close()
+            {
+                if (m_composition.Root)
+                {
+                    m_composition.Root.Close();
+                }
+                m_composition = {};
+            }
+
+        private:
+            LoadedComposition m_composition;
+        };
+
+        template<typename TSource, bool TImages>
+        struct SourceInterfaces : winrt::implements<TSource, IAnimatedVisualSource, IAnimatedVisualSource2,
+            IScalarProperties>
+        {
+        };
+
+        template<typename TSource>
+        struct SourceInterfaces<TSource, true> : winrt::implements<TSource,
+            IDynamicAnimatedVisualSource, IAnimatedVisualSource, IAnimatedVisualSource2,
+            XamlData::INotifyPropertyChanged, IScalarProperties>
+        {
+        };
+
+        template<bool TImages>
+        struct AnimatedVisualSource : SourceInterfaces<AnimatedVisualSource<TImages>, TImages>
+        {
+            AnimatedVisualSource(
+                std::span<std::byte const> buffer,
+                Fb::LottieComposition const* composition,
+                AnimatedVisualSourceOptions const& options) :
+                m_buffer(buffer), m_composition(composition), m_options(options)
+            {
+                auto metadata = m_composition->metadata();
+                if (!metadata)
+                {
+                    throw winrt::hresult_invalid_argument(L"Lottie composition has no metadata.");
+                }
+                auto duration = metadata->duration_ticks();
+                auto framerate = metadata->frames_per_second();
+                if (duration <= 0 || !std::isfinite(framerate) || framerate <= 0)
+                {
+                    throw winrt::hresult_invalid_argument(L"Lottie composition has no duration.");
+                }
+                m_frameCount = std::round(duration * static_cast<double>(framerate) / 10000000.0);
+                if (m_frameCount <= 0)
+                {
+                    throw winrt::hresult_invalid_argument(L"Lottie composition has no frames.");
+                }
+                if (auto bindings = metadata->property_bindings())
+                {
+                    for (auto binding : *bindings)
+                    {
+                        (void)StringAt(binding->name());
+                    }
+                }
+                m_markers = m_options.Markers == MarkerNames::Unique ? UniqueMarkers() : FirstWinsMarkers();
+            }
+
+            ~AnimatedVisualSource()
+            {
+                // The handlers hold weak references, so a failed unregistration (for example
+                // a release off the UI thread) is harmless and must not escape the destructor.
+                for (auto const& [surface, token] : m_imageSubscriptions)
+                {
+                    try
+                    {
+                        surface.LoadCompleted(token);
+                    }
+                    catch (...)
+                    {
+                    }
+                }
+            }
+
+            IAnimatedVisual TryCreateAnimatedVisual(Compositor const& compositor, IInspectable& diagnostics)
+            {
+                diagnostics = nullptr;
+                if (!IsUapPresent(m_composition->required_uap_version()))
+                {
+                    return nullptr;
+                }
+                if (!m_options.ReportLoadErrors)
+                {
+                    return CreateAnimatedVisual(compositor);
+                }
+                try
+                {
+                    return CreateAnimatedVisual(compositor);
+                }
+                catch (winrt::hresult_error const& error)
+                {
+                    diagnostics = winrt::box_value(error.message());
+                    return nullptr;
+                }
+            }
+
+            IMapView<hstring, double> Markers() const { return m_markers; }
+
+            void SetColorProperty(hstring const& name, winrt::Windows::UI::Color value)
+            {
+                if (HasBinding(name, Fb::PropertyValueType::Color))
+                {
+                    float4 color{ static_cast<float>(value.R), static_cast<float>(value.G),
+                        static_cast<float>(value.B), static_cast<float>(value.A) };
+                    m_colors.insert_or_assign(name, color);
+                    UpdateThemes([&](auto const& theme) { theme.InsertVector4(name, color); });
+                }
+            }
+
+            void SetScalarProperty(hstring const& name, double value)
+            {
+                if (HasBinding(name, Fb::PropertyValueType::Scalar))
+                {
+                    auto scalar = static_cast<float>(value);
+                    m_scalars.insert_or_assign(name, scalar);
+                    UpdateThemes([&](auto const& theme) { theme.InsertScalar(name, scalar); });
+                }
+            }
+
+            HRESULT __stdcall SetScalar(HSTRING name, double value) noexcept override
+            {
+                try
+                {
+                    SetScalarProperty(reinterpret_cast<hstring const&>(name), value);
+                    return S_OK;
+                }
+                catch (...)
+                {
+                    return winrt::to_hresult();
+                }
+            }
+
+            winrt::event_token AnimatedVisualInvalidated(
+                TypedEventHandler<IDynamicAnimatedVisualSource, IInspectable> const& handler)
+            {
+                return m_invalidated.add(handler);
+            }
+
+            void AnimatedVisualInvalidated(winrt::event_token const& token) noexcept
+            {
+                m_invalidated.remove(token);
+            }
+
+            winrt::event_token PropertyChanged(XamlData::PropertyChangedEventHandler const& handler)
+            {
+                return m_propertyChanged.add(handler);
+            }
+
+            void PropertyChanged(winrt::event_token const& token) noexcept
+            {
+                m_propertyChanged.remove(token);
+            }
+
+        private:
+            IAnimatedVisual CreateAnimatedVisual(Compositor const& compositor)
+            {
+                LoadedComposition composition;
+                if (m_pendingComposition)
+                {
+                    if (m_imageCompositor != compositor)
+                    {
+                        throw winrt::hresult_invalid_argument(L"Images were loaded with another compositor.");
+                    }
+                    if (!m_imageLoadingCompleted)
+                    {
+                        return nullptr;
+                    }
+                    composition = std::move(*m_pendingComposition);
+                    m_pendingComposition.reset();
+                }
+                else
+                {
+                    if (!m_imageSurfaces.empty() && m_imageCompositor != compositor)
+                    {
+                        throw winrt::hresult_invalid_argument(L"Images were loaded with another compositor.");
+                    }
+                    composition = LoadCompositionWithMetadata(compositor, m_buffer, m_imageSurfaces);
+                    if constexpr (TImages)
+                    {
+                        if (!m_imageLoadingStarted)
+                        {
+                            ObserveImages(compositor, composition.ImageSurfaces);
+                        }
+                        if (m_options.AsynchronousImageLoading && !m_imageLoadingCompleted)
+                        {
+                            m_pendingComposition.emplace(std::move(composition));
+                            return nullptr;
+                        }
+                    }
+                }
+
+                auto theme = composition.ThemeProperties;
+                auto visual = winrt::make_self<AnimatedVisual>(std::move(composition));
+                if (theme)
+                {
+                    for (auto const& [name, color] : m_colors)
+                    {
+                        theme.InsertVector4(name, color);
+                    }
+                    for (auto const& [name, scalar] : m_scalars)
+                    {
+                        theme.InsertScalar(name, scalar);
+                    }
+                    std::erase_if(m_visuals, [](auto const& weak) { return !weak.get(); });
+                    m_visuals.emplace_back(visual->get_weak());
+                }
+                return visual.as<IAnimatedVisual>();
+            }
+
+            void ObserveImages(Compositor const& compositor, std::vector<CompositionImageSurface> const& images)
+            {
+                m_imageLoadingStarted = true;
+                m_imageCompositor = compositor;
+                m_imageSurfaces = images;
+                m_imagesRemaining = m_imageSurfaces.size();
+                m_imageLoadingCompleted = m_imagesRemaining == 0;
+                auto weak = this->get_weak();
+                for (auto const& image : m_imageSurfaces)
+                {
+                    auto surface = image.Surface.as<XamlMedia::LoadedImageSurface>();
+                    auto token = surface.LoadCompleted([weak](auto const&, auto const&)
+                    {
+                        if (auto source = weak.get())
+                        {
+                            source->ImageLoadCompleted();
+                        }
+                    });
+                    m_imageSubscriptions.emplace_back(surface, token);
+                }
+            }
+
+            void ImageLoadCompleted()
+            {
+                if (m_imagesRemaining && --m_imagesRemaining == 0)
+                {
+                    m_imageLoadingCompleted = true;
+                    m_propertyChanged(*this, XamlData::PropertyChangedEventArgs(L"IsImageLoadingCompleted"));
+                    if (m_options.AsynchronousImageLoading)
+                    {
+                        m_invalidated(*this, nullptr);
+                    }
+                }
+            }
+
+            hstring StringAt(uint32_t index) const
+            {
+                auto strings = m_composition->strings();
+                if (!strings || index >= strings->size())
+                {
+                    throw winrt::hresult_invalid_argument(L"Invalid Lottie composition string index.");
+                }
+                return winrt::to_hstring(strings->Get(index)->string_view());
+            }
+
+            bool HasBinding(hstring const& name, Fb::PropertyValueType type) const
+            {
+                if (auto bindings = m_composition->metadata()->property_bindings())
+                {
+                    for (auto binding : *bindings)
+                    {
+                        if (binding->exposed_type() == type && StringAt(binding->name()) == name)
+                        {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+
+            template<typename TUpdate>
+            void UpdateThemes(TUpdate const& update)
+            {
+                std::erase_if(m_visuals, [&](auto const& weak)
+                {
+                    if (auto visual = weak.get())
+                    {
+                        if (auto theme = visual->ThemeProperties())
+                        {
+                            update(theme);
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            }
+
+            double MarkerProgress(double frame) const
+            {
+                return frame == 0 ? 0 : std::clamp((frame + 0.05) / m_frameCount, 0.0, 1.0);
+            }
+
+            IMapView<hstring, double> FirstWinsMarkers() const
+            {
+                auto markers = winrt::single_threaded_map<hstring, double>();
+                if (auto entries = m_composition->metadata()->markers())
+                {
+                    for (auto marker : *entries)
+                    {
+                        if (!std::isfinite(marker->progress()) || !std::isfinite(marker->duration_progress()))
+                        {
+                            throw winrt::hresult_invalid_argument(L"Invalid Lottie composition marker.");
+                        }
+                        auto name = StringAt(marker->name());
+                        auto frame = std::round(marker->progress() * m_frameCount);
+                        auto last = m_options.IncludeFinalFrameMarkers ? m_frameCount : m_frameCount - 1;
+                        if (frame >= 0 && frame <= last && !markers.HasKey(name))
+                        {
+                            markers.Insert(name, MarkerProgress(frame));
+                        }
+                    }
+                }
+                return markers.GetView();
+            }
+
+            IMapView<hstring, double> UniqueMarkers() const
+            {
+                struct Marker
+                {
+                    std::wstring Name;
+                    double Frame;
+                };
+                std::vector<Marker> markers;
+                if (auto entries = m_composition->metadata()->markers())
+                {
+                    for (auto entry : *entries)
+                    {
+                        if (!std::isfinite(entry->progress()) || !std::isfinite(entry->duration_progress()))
+                        {
+                            throw winrt::hresult_invalid_argument(L"Invalid Lottie composition marker.");
+                        }
+                        auto frame = std::round(entry->progress() * m_frameCount);
+                        auto end = frame + std::round(entry->duration_progress() * m_frameCount);
+                        auto last = m_options.IncludeFinalFrameMarkers ? m_frameCount : m_frameCount - 1;
+                        if ((frame < 0 && end < 0) || frame > last)
+                        {
+                            continue;
+                        }
+                        std::wstring name;
+                        for (auto ch : StringAt(entry->name()))
+                        {
+                            if (ch == L'\t')
+                            {
+                                name += L' ';
+                            }
+                            else if (ch >= 32 && (ch < 127 || ch > 159))
+                            {
+                                name += ch;
+                            }
+                        }
+                        if (name.find_first_not_of(L" \t\r\n") == std::wstring::npos)
+                        {
+                            name = L"anonymous";
+                        }
+                        markers.push_back({ std::move(name), std::max(0.0, frame) });
+                    }
+                }
+                std::stable_sort(markers.begin(), markers.end(),
+                    [](auto const& a, auto const& b) { return a.Frame < b.Frame; });
+
+                // Suffix every duplicate, repeating if a suffixed name collides with an authored one.
+                for (bool duplicate = true; duplicate;)
+                {
+                    duplicate = false;
+                    std::map<std::wstring, std::vector<size_t>> groups;
+                    for (size_t i = 0; i != markers.size(); ++i)
+                    {
+                        groups[markers[i].Name].push_back(i);
+                    }
+                    for (auto const& [name, indices] : groups)
+                    {
+                        if (indices.size() > 1)
+                        {
+                            duplicate = true;
+                            for (size_t i = 0; i != indices.size(); ++i)
+                            {
+                                markers[indices[i]].Name = name + L"_" + std::to_wstring(i);
+                            }
+                        }
+                    }
+                }
+
+                auto result = winrt::single_threaded_map<hstring, double>();
+                for (auto const& marker : markers)
+                {
+                    result.Insert(hstring(marker.Name), MarkerProgress(marker.Frame));
+                }
+                return result.GetView();
+            }
+
+            std::span<std::byte const> m_buffer;
+            Fb::LottieComposition const* m_composition{};
+            AnimatedVisualSourceOptions m_options;
+            double m_frameCount{};
+            IMapView<hstring, double> m_markers{ nullptr };
+            std::map<hstring, float4> m_colors;
+            std::map<hstring, float> m_scalars;
+            // Composition objects do not expose weak references; their owning visuals do.
+            std::vector<winrt::weak_ref<AnimatedVisual>> m_visuals;
+
+            bool m_imageLoadingStarted{};
+            bool m_imageLoadingCompleted{ !TImages };
+            size_t m_imagesRemaining{};
+            Compositor m_imageCompositor{ nullptr };
+            std::optional<LoadedComposition> m_pendingComposition;
+            std::vector<CompositionImageSurface> m_imageSurfaces;
+            std::vector<std::pair<XamlMedia::LoadedImageSurface, winrt::event_token>> m_imageSubscriptions;
+            winrt::event<TypedEventHandler<IDynamicAnimatedVisualSource, IInspectable>> m_invalidated;
+            winrt::event<XamlData::PropertyChangedEventHandler> m_propertyChanged;
+        };
+    }
+
+    std::span<std::byte const> LoadEmbeddedComposition(
+        void const* moduleAddress,
+        std::span<EmbeddedCompositionVariant const> variants)
+    {
+        EmbeddedCompositionVariant const* selected = nullptr;
+        EmbeddedCompositionVariant const* lowest = nullptr;
+        for (auto const& variant : variants)
+        {
+            if (!lowest || variant.RequiredUapVersion < lowest->RequiredUapVersion)
+            {
+                lowest = &variant;
+            }
+            if ((!selected || selected->RequiredUapVersion < variant.RequiredUapVersion) &&
+                IsUapPresent(variant.RequiredUapVersion))
+            {
+                selected = &variant;
+            }
+        }
+        if (!selected)
+        {
+            selected = lowest;
+        }
+        if (!selected || !selected->ResourceName)
+        {
+            throw winrt::hresult_invalid_argument(L"No embedded Lottie composition variant.");
+        }
+
+        HMODULE module{};
+        winrt::check_bool(GetModuleHandleExW(
+            GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+            static_cast<LPCWSTR>(moduleAddress), &module));
+        auto resource = FindResourceW(module, selected->ResourceName, MAKEINTRESOURCEW(10) /* RT_RCDATA */);
+        if (!resource)
+        {
+            throw winrt::hresult_error(HRESULT_FROM_WIN32(ERROR_RESOURCE_NAME_NOT_FOUND),
+                L"Missing embedded Lottie composition.");
+        }
+        auto size = SizeofResource(module, resource);
+        auto loaded = LoadResource(module, resource);
+        auto data = loaded ? LockResource(loaded) : nullptr;
+        if (!data || !size)
+        {
+            throw winrt::hresult_error(HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND),
+                L"Empty embedded Lottie composition.");
+        }
+        std::span<std::byte const> buffer{ static_cast<std::byte const*>(data), size };
+        if (Verify(buffer)->required_uap_version() != selected->RequiredUapVersion)
+        {
+            throw winrt::hresult_invalid_argument(L"Embedded Lottie composition has the wrong UAP version.");
+        }
+        return buffer;
+    }
+
+    IAnimatedVisualSource2 CreateAnimatedVisualSource(
+        std::span<std::byte const> buffer,
+        AnimatedVisualSourceOptions const& options)
+    {
+        auto composition = Verify(buffer);
+        if (HasImages(*composition))
+        {
+            return winrt::make<AnimatedVisualSource<true>>(buffer, composition, options).as<IAnimatedVisualSource2>();
+        }
+        return winrt::make<AnimatedVisualSource<false>>(buffer, composition, options).as<IAnimatedVisualSource2>();
+    }
+
+    void SetScalarProperty(
+        winrt::Windows::Foundation::IInspectable const& source,
+        winrt::hstring const& name,
+        double value)
+    {
+        auto properties = source.try_as<IScalarProperties>();
+        if (!properties)
+        {
+            throw winrt::hresult_invalid_argument(L"Source was not created by CreateAnimatedVisualSource.");
+        }
+        winrt::check_hresult(properties->SetScalar(static_cast<HSTRING>(winrt::get_abi(name)), value));
+    }
+}
diff --git a/source/LottieRuntime/LottieVisualSource.h b/source/LottieRuntime/LottieVisualSource.h
new file mode 100644
index 00000000..8198a375
--- /dev/null
+++ b/source/LottieRuntime/LottieVisualSource.h
@@ -0,0 +1,93 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#pragma once
+
+#include "LottieRuntime.h"
+
+#undef GetCurrentTime
+#include <winrt/Microsoft.UI.Xaml.Controls.h>
+
+#if defined(LOTTIE_RUNTIME_WINUI3)
+namespace CommunityToolkit::WinUI3::Lottie
+#else
+namespace CommunityToolkit::WinUI2::Lottie
+#endif
+{
+    // One UAP-specific serialization of an animation, embedded as an RCDATA resource.
+    struct EmbeddedCompositionVariant
+    {
+        uint16_t RequiredUapVersion = 0;
+        wchar_t const* ResourceName = nullptr;
+    };
+
+    // Returns the bytes of the variant with the highest UniversalApiContract version
+    // present, or of the lowest variant when none is present so that the source still
+    // has metadata and TryCreateAnimatedVisual returns null. The resource is read from
+    // the module containing moduleAddress and lives as long as that module.
+    //
+    // Throws winrt::hresult_error if there are no variants or the resource is missing or
+    // empty, and winrt::hresult_invalid_argument if the buffer is not a verified
+    // composition requiring exactly the variant's UAP version.
+    std::span<std::byte const> LoadEmbeddedComposition(
+        void const* moduleAddress,
+        std::span<EmbeddedCompositionVariant const> variants);
+
+    // How serialized markers become IAnimatedVisualSource2::Markers. Each policy matches a
+    // LottieGen version's generated code. Frames are recovered from the marker progress
+    // and the first nonzero frame is nudged by 0.05 frames, as LottieGen does.
+    enum class MarkerNames : uint8_t
+    {
+        // A marker whose frame lies outside the animation is dropped; the first marker
+        // of a name wins.
+        FirstWins,
+
+        // Names are sanitized as LottieGen does. A marker is dropped only when it lies
+        // entirely outside the animation. Markers are ordered by frame and every
+        // duplicate name gets a "_<n>" suffix.
+        Unique,
+    };
+
+    struct AnimatedVisualSourceOptions
+    {
+        MarkerNames Markers = MarkerNames::FirstWins;
+
+        // Whether a marker on the final frame is kept.
+        bool IncludeFinalFrameMarkers = true;
+
+        // When true, TryCreateAnimatedVisual returns null and reports the error message
+        // through diagnostics if loading fails. When false, the error propagates.
+        bool ReportLoadErrors = false;
+
+        // For animations with images: return null from TryCreateAnimatedVisual until
+        // every image has loaded, then raise AnimatedVisualInvalidated.
+        bool AsynchronousImageLoading = false;
+    };
+
+    // Creates an IAnimatedVisualSource2 that loads the serialized composition with the
+    // runtime. The buffer is not copied and must outlive the source; an embedded
+    // resource does.
+    //
+    // Created visuals implement IAnimatedVisual2, so AnimatedVisualPlayer's
+    // AnimationOptimization="Resources" stops their animations while idle.
+    // SetColorProperty and SetScalarProperty (below) update the theme properties of every
+    // live visual and of visuals created later; names that are not bound properties of that
+    // type are ignored. Animations with images also implement
+    // IDynamicAnimatedVisualSource and INotifyPropertyChanged, raising
+    // "IsImageLoadingCompleted" once every image has loaded.
+    //
+    // Throws winrt::hresult_invalid_argument if the buffer is not a verified composition
+    // with metadata, a positive duration and a positive frame rate.
+    winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2 CreateAnimatedVisualSource(
+        std::span<std::byte const> buffer,
+        AnimatedVisualSourceOptions const& options = {});
+
+    // Sets a bound scalar theme property, as LottieGen's generated SetScalarProperty does.
+    // IAnimatedVisualSource2 only declares SetColorProperty. Throws
+    // winrt::hresult_invalid_argument if source was not created by CreateAnimatedVisualSource.
+    void SetScalarProperty(
+        winrt::Windows::Foundation::IInspectable const& source,
+        winrt::hstring const& name,
+        double value);
+}
diff --git a/source/LottieRuntime/README.md b/source/LottieRuntime/README.md
index a9ac8be8..b19aa14f 100644
--- a/source/LottieRuntime/README.md
+++ b/source/LottieRuntime/README.md
@@ -65,8 +65,9 @@ The same projection definition must be visible to every file that includes
 projection-specific objects to be linked into the same binary.
 
 `LoadComposition` returns the root `Visual`. `ProgressPropertySet(root)` returns
-the Composition property set containing the `Progress` scalar. XAML integration
-and `IAnimatedVisual` wrapping remain the caller's responsibility.
+the Composition property set containing the `Progress` scalar. For
+`AnimatedVisualPlayer`, use `LottieVisualSource` (below) rather than wrapping the
+root yourself.
 
 Animations containing loaded image surfaces must be loaded on the XAML UI thread
 with the XAML host's compositor (for example, the compositor obtained from
@@ -177,6 +178,53 @@ controller that a restart would replace. Both calls are then no-ops and the
 animations stay running, so a host can keep advertising `IAnimatedVisual2`.
 Restart state is shared by copies of the same `LoadedComposition`.
 
+### Hosting in AnimatedVisualPlayer
+
+`LottieVisualSource.cpp` and `LottieVisualSource.h` adapt a buffer to
+`Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2`, replacing per-animation
+LottieGen classes. Compile `LottieVisualSource.cpp` alongside `LottieRuntime.cpp`
+with the same projection flag; it also needs the C++/WinRT projection of
+Microsoft.UI.Xaml 2.8 (WinUI 2) or the Windows App SDK (WinUI 3).
+
+```cpp
+#include <LottieVisualSource.h>
+
+namespace Lottie = CommunityToolkit::WinUI2::Lottie;
+
+// One RCDATA resource per UAP variant; the highest available contract wins.
+static constexpr Lottie::EmbeddedCompositionVariant variants[]{
+    { 15, L"SPINNER_UAP15" },
+    { 7, L"SPINNER_UAP7" },
+};
+
+static int anchor;
+auto bytes = Lottie::LoadEmbeddedComposition(&anchor, variants);
+player.Source(Lottie::CreateAnimatedVisualSource(bytes));
+```
+
+`CreateAnimatedVisualSource` does not copy the buffer, so pass one that outlives
+the source, such as an embedded resource. The source:
+
+- exposes the metadata's duration, frame rate, size and markers;
+- forwards `SetColorProperty` to every live and future visual, ignoring names
+  that are not bound properties. `IAnimatedVisualSource2` has no scalar setter,
+  so use the free function `SetScalarProperty(source, name, value)` for scalars;
+- creates visuals that implement `IAnimatedVisual2`, so
+  `AnimationOptimization="Resources"` stops their animations while idle, and
+  `IClosable`;
+- for animations with images, also implements `IDynamicAnimatedVisualSource`
+  and `INotifyPropertyChanged`.
+
+`AnimatedVisualSourceOptions` reproduces the behaviour of each LottieGen
+version's generated code:
+
+| Option | Default | Effect |
+|---|---|---|
+| `Markers` | `FirstWins` | `FirstWins` keeps the first marker of each name; `Unique` sanitizes names and suffixes duplicates with `_<n>`. |
+| `IncludeFinalFrameMarkers` | `true` | Whether a marker on the final frame is kept. |
+| `ReportLoadErrors` | `false` | Return null and report the message through `diagnostics` instead of throwing. |
+| `AsynchronousImageLoading` | `false` | Return null until every image has loaded, then raise `AnimatedVisualInvalidated`. |
+
 `LoadCompositionWithMetadata` requires a metadata table and rejects negative
 duration/dimensions/frame rate/marker duration, nonfinite numeric metadata,
 invalid string/property-set indices and a theme index that refers to an owned
@@ -243,3 +291,30 @@ image-bearing files the runner also creates another tree with the returned image
 descriptors and asserts that every image object is reused rather than reloaded.
 Prefix the paths with `--legacy` to exercise the Visual-only `LoadComposition`
 path instead, separating graph-realization failures from metadata validation.
+
+### Visual source tests
+
+`tests\LottieRuntime.Tests\VisualSourceTests.cpp` exercises `LottieVisualSource`
+on each `.lcomp` path passed to it, checking:
+
+- duration, markers and image detection;
+- that `IAnimatedVisual2` stops and restarts animations;
+- that bound theme colors and scalars reach live and later visuals, and unbound
+  names are ignored;
+- that `Close` releases the visual;
+- for image assets, that another compositor throws by default and is reported
+  through `diagnostics` with `ReportLoadErrors`.
+
+It includes `LottieVisualSource.cpp` directly so it can read each visual's theme
+properties.
+
+It needs a C++/WinRT projection that includes Microsoft.UI.Xaml 2.8. Generate it
+with cppwinrt from the `Microsoft.UI.Xaml` 2.8 and `Microsoft.Web.WebView2`
+NuGet packages (substitute their local paths):
+
+```cmd
+cppwinrt.exe -base -in sdk+ -in <Microsoft.UI.Xaml>\lib\uap10.0\Microsoft.UI.Xaml.winmd -in <Microsoft.Web.WebView2>\lib\Microsoft.Web.WebView2.Core.winmd -out tests\LottieRuntime.Tests\bin\mux
+mkdir tests\LottieRuntime.Tests\bin\vst
+cl /nologo /std:c++20 /EHsc /W4 /WX /bigobj /DWIN32_LEAN_AND_MEAN /DNOMINMAX /DLOTTIE_RUNTIME_WINUI2 /Itests\LottieRuntime.Tests\bin\mux /Iexternal\flatbuffers\include /Isource\LottieRuntime tests\LottieRuntime.Tests\VisualSourceTests.cpp source\LottieRuntime\LottieRuntime.cpp /Fotests\LottieRuntime.Tests\bin\vst\ /Fetests\LottieRuntime.Tests\bin\VisualSourceTests.exe /link /MANIFEST:EMBED /MANIFESTINPUT:tests\LottieRuntime.Tests\MetadataTests.manifest CoreMessaging.lib d2d1.lib dxguid.lib ole32.lib shcore.lib shlwapi.lib windowsapp.lib
+tests\LottieRuntime.Tests\bin\VisualSourceTests.exe Animation.lcomp
+```
diff --git a/tests/LottieRuntime.Tests/VisualSourceTests.cpp b/tests/LottieRuntime.Tests/VisualSourceTests.cpp
new file mode 100644
index 00000000..6588ea9f
--- /dev/null
+++ b/tests/LottieRuntime.Tests/VisualSourceTests.cpp
@@ -0,0 +1,267 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// Tests LottieVisualSource against serialized compositions passed on the command line.
+// Builds with the runtime and a C++/WinRT projection of Microsoft.UI.Xaml 2.8, and hosts XAML so image assets
+// load through LoadedImageSurface; see source\LottieRuntime\README.md.
+
+#include <unknwn.h>
+#include <Windows.h>
+#include <DispatcherQueue.h>
+
+// Include the implementation to read back each visual's theme properties.
+#include "../../source/LottieRuntime/LottieVisualSource.cpp"
+
+#include <winrt/Windows.Foundation.Collections.h>
+#include <winrt/Windows.System.h>
+#include <winrt/Windows.UI.h>
+#include <winrt/Windows.UI.Xaml.Hosting.h>
+#include <winrt/Windows.UI.Xaml.Controls.h>
+
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+
+namespace
+{
+    namespace Runtime = CommunityToolkit::WinUI2::Lottie;
+    namespace Fb = CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema;
+    namespace Mux = winrt::Microsoft::UI::Xaml::Controls;
+    using namespace winrt::Windows::UI::Composition;
+
+    void Require(bool condition, char const* message)
+    {
+        if (!condition)
+        {
+            throw std::runtime_error(message);
+        }
+    }
+
+    std::vector<std::byte> Read(wchar_t const* path)
+    {
+        std::ifstream file(path, std::ios::binary | std::ios::ate);
+        Require(file.good(), "Cannot open file.");
+        std::vector<std::byte> bytes(static_cast<size_t>(file.tellg()));
+        file.seekg(0);
+        file.read(reinterpret_cast<char*>(bytes.data()), static_cast<std::streamsize>(bytes.size()));
+        Require(file.good(), "Cannot read file.");
+        return bytes;
+    }
+
+    bool HasImages(Fb::LottieComposition const& composition)
+    {
+        if (auto surfaces = composition.surfaces())
+        {
+            for (auto surface : *surfaces)
+            {
+                if (surface->kind() == Fb::SurfaceKind::LoadedImageFromStream ||
+                    surface->kind() == Fb::SurfaceKind::LoadedImageFromUri)
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    bool AnimationsRunning(Visual const& visual)
+    {
+        // Every serialized tree animates a property somewhere; find a keyframe controller.
+        auto found = false;
+        auto check = [&](CompositionObject const& object, wchar_t const* property)
+        {
+            found = found || object.TryGetAnimationController(property) != nullptr;
+        };
+        std::function<void(Visual const&)> walk = [&](Visual const& node)
+        {
+            for (auto property : { L"Opacity", L"IsVisible", L"Offset", L"Scale", L"RotationAngleInDegrees",
+                L"TransformMatrix", L"Size" })
+            {
+                check(node, property);
+            }
+            if (auto container = node.try_as<ContainerVisual>())
+            {
+                for (auto child : container.Children())
+                {
+                    walk(child);
+                }
+            }
+        };
+        walk(visual);
+        return found;
+    }
+
+    void Test(Compositor const& compositor, wchar_t const* path)
+    {
+        auto bytes = Read(path);
+        auto composition = Fb::GetLottieComposition(bytes.data());
+        auto source = Runtime::CreateAnimatedVisualSource(bytes);
+        Require(source.try_as<Mux::IAnimatedVisualSource>() != nullptr, "Not an IAnimatedVisualSource.");
+
+        auto const images = HasImages(*composition);
+        Require((source.try_as<Mux::IDynamicAnimatedVisualSource>() != nullptr) == images, "Wrong dynamic source.");
+
+        winrt::Windows::Foundation::IInspectable diagnostics{ nullptr };
+        auto visual = source.TryCreateAnimatedVisual(compositor, diagnostics);
+        Require(diagnostics == nullptr, "Unexpected diagnostics.");
+        Require(visual != nullptr, "No visual.");
+        Require(visual.RootVisual() != nullptr, "No root.");
+        Require(visual.Duration().count() == composition->metadata()->duration_ticks(), "Wrong duration.");
+
+        auto visual2 = visual.try_as<Mux::IAnimatedVisual2>();
+        Require(visual2 != nullptr, "Not an IAnimatedVisual2.");
+        auto const animated = AnimationsRunning(visual.RootVisual());
+        for (int cycle = 0; cycle != 2; ++cycle)
+        {
+            visual2.DestroyAnimations();
+            visual2.DestroyAnimations();
+            Require(!AnimationsRunning(visual.RootVisual()), "Animations not destroyed.");
+            visual2.CreateAnimations();
+            visual2.CreateAnimations();
+            Require(AnimationsRunning(visual.RootVisual()) == animated, "Animations not recreated.");
+        }
+
+        auto markers = source.Markers();
+        for (auto const& marker : markers)
+        {
+            Require(marker.Value() >= 0 && marker.Value() <= 1, "Marker out of range.");
+        }
+
+        // Bound colors and scalars reach live and later visuals; unbound names are ignored.
+        auto theme = winrt::get_self<Runtime::AnimatedVisual>(visual)->ThemeProperties();
+        source.SetColorProperty(L"NotABinding", winrt::Windows::UI::Color{ 255, 1, 2, 3 });
+        Runtime::SetScalarProperty(source, L"NotABinding", 1);
+        winrt::Windows::Foundation::Numerics::float4 color{};
+        float scalar{};
+        if (theme)
+        {
+            Require(theme.TryGetVector4(L"NotABinding", color) != CompositionGetValueStatus::Succeeded,
+                "Unbound color applied.");
+            Require(theme.TryGetScalar(L"NotABinding", scalar) != CompositionGetValueStatus::Succeeded,
+                "Unbound scalar applied.");
+        }
+        std::vector<std::pair<winrt::hstring, Fb::PropertyValueType>> bound;
+        if (auto bindings = composition->metadata()->property_bindings())
+        {
+            for (auto binding : *bindings)
+            {
+                auto name = winrt::to_hstring(composition->strings()->Get(binding->name())->str());
+                if (binding->exposed_type() == Fb::PropertyValueType::Color)
+                {
+                    source.SetColorProperty(name, winrt::Windows::UI::Color{ 40, 10, 20, 30 });
+                    bound.emplace_back(name, binding->exposed_type());
+                }
+                else if (binding->exposed_type() == Fb::PropertyValueType::Scalar)
+                {
+                    Runtime::SetScalarProperty(source, name, 0.25);
+                    bound.emplace_back(name, binding->exposed_type());
+                }
+            }
+        }
+        Require(bound.empty() || theme, "Bindings without theme properties.");
+        auto later = source.TryCreateAnimatedVisual(compositor, diagnostics);
+        Require(later != nullptr, "No second visual.");
+        for (auto const& set : { theme, winrt::get_self<Runtime::AnimatedVisual>(later)->ThemeProperties() })
+        {
+            for (auto const& [name, type] : bound)
+            {
+                if (type == Fb::PropertyValueType::Color)
+                {
+                    Require(set.TryGetVector4(name, color) == CompositionGetValueStatus::Succeeded &&
+                        color == winrt::Windows::Foundation::Numerics::float4{ 10, 20, 30, 40 }, "Color not applied.");
+                }
+                else
+                {
+                    Require(set.TryGetScalar(name, scalar) == CompositionGetValueStatus::Succeeded && scalar == 0.25f,
+                        "Scalar not applied.");
+                }
+            }
+        }
+        later.as<winrt::Windows::Foundation::IClosable>().Close();
+
+        visual.as<winrt::Windows::Foundation::IClosable>().Close();
+        Require(visual.RootVisual() == nullptr, "Root not released.");
+        visual2.DestroyAnimations();
+        visual2.CreateAnimations();
+
+        // Image surfaces are tied to their compositor. Using another one throws by default
+        // and becomes diagnostics on request.
+        if (images)
+        {
+            Compositor other;
+            try
+            {
+                source.TryCreateAnimatedVisual(other, diagnostics);
+                throw std::runtime_error("Another compositor accepted.");
+            }
+            catch (winrt::hresult_invalid_argument const&)
+            {
+            }
+
+            Runtime::AnimatedVisualSourceOptions options;
+            options.ReportLoadErrors = true;
+            source = Runtime::CreateAnimatedVisualSource(bytes, options);
+            Require(source.TryCreateAnimatedVisual(compositor, diagnostics) != nullptr && !diagnostics,
+                "No visual with diagnostics.");
+            Require(source.TryCreateAnimatedVisual(other, diagnostics) == nullptr, "Error not reported.");
+            Require(winrt::unbox_value_or<winrt::hstring>(diagnostics, L"") != L"", "No diagnostics.");
+        }
+
+        try
+        {
+            Runtime::SetScalarProperty(compositor.CreatePropertySet(), L"Name", 1);
+            throw std::runtime_error("Foreign source accepted.");
+        }
+        catch (winrt::hresult_invalid_argument const&)
+        {
+        }
+        std::wcout << path << L": markers=" << markers.Size()
+            << L", animated=" << (animated ? L"yes" : L"no") << (images ? L", images" : L"") << L"\n";
+    }
+}
+
+int wmain(int argc, wchar_t** argv)
+{
+    try
+    {
+        winrt::init_apartment(winrt::apartment_type::single_threaded);
+        DispatcherQueueOptions const options{ sizeof(DispatcherQueueOptions), DQTYPE_THREAD_CURRENT, DQTAT_COM_NONE };
+        winrt::Windows::System::DispatcherQueueController queue{ nullptr };
+        winrt::check_hresult(CreateDispatcherQueueController(
+            options, reinterpret_cast<PDISPATCHERQUEUECONTROLLER*>(winrt::put_abi(queue))));
+        auto xaml = winrt::Windows::UI::Xaml::Hosting::WindowsXamlManager::InitializeForCurrentThread();
+        {
+            winrt::Windows::UI::Xaml::Controls::Grid host;
+            auto compositor = winrt::Windows::UI::Xaml::Hosting::ElementCompositionPreview::GetElementVisual(host).Compositor();
+
+            try
+            {
+                Runtime::CreateAnimatedVisualSource({});
+                throw std::runtime_error("Empty buffer accepted.");
+            }
+            catch (winrt::hresult_invalid_argument const&)
+            {
+            }
+
+            for (int i = 1; i < argc; ++i)
+            {
+                Test(compositor, argv[i]);
+            }
+        }
+        queue.ShutdownQueueAsync();
+        std::cout << "Visual source tests passed.\n";
+        return 0;
+    }
+    catch (winrt::hresult_error const& error)
+    {
+        std::wcerr << error.message().c_str() << L"\n";
+    }
+    catch (std::exception const& error)
+    {
+        std::cerr << error.what() << "\n";
+    }
+    return 1;
+}

From 28a5166dc2844b092e58cc4da954754a73e6979c Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@ntdev.microsoft.com>
Date: Sun, 18 Oct 2026 21:08:21 -0700
Subject: [PATCH 36/39] Accept flatbuffer language in LottieGen MSBuild task

The task rejected -Language flatbuffer even though LottieGen.exe supports it.
Accept it in validation and report the generated .lcomp files (one per UAP
version variant) as OutputFiles, using the paths LottieGen prints.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: cfdf7544-9ef9-4586-8d82-56d89206cc1d
---
 LottieGen/MSBuildTask/LottieGen.cs | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/LottieGen/MSBuildTask/LottieGen.cs b/LottieGen/MSBuildTask/LottieGen.cs
index e0100fbf..1e38ab75 100644
--- a/LottieGen/MSBuildTask/LottieGen.cs
+++ b/LottieGen/MSBuildTask/LottieGen.cs
@@ -42,7 +42,7 @@ public sealed class LottieGen : Microsoft.Build.Utilities.ToolTask
         public string? InputFile { get; set; }
 
         /// <summary>
-        /// cs, cppcx, or cppwinrt.
+        /// cs, cppcx, cppwinrt, or flatbuffer.
         /// </summary>
         [Required]
         public string? Language { get; set; }
@@ -190,6 +190,13 @@ public override bool Execute()
                         }
 
                         break;
+
+                    case Lang.Flatbuffer:
+                        // The number of .lcomp variants depends on the UAP versions
+                        // required by the animation, so use the paths LottieGen reported.
+                        OutputFiles = _outputFiles.ConvertAll(f => (ITaskItem)new TaskItem(f)).ToArray();
+                        break;
+
                     default:
                         throw new InvalidOperationException();
                 }
@@ -341,6 +348,7 @@ protected override bool ValidateParameters()
                 case Lang.Cppwinrt:
                 case Lang.CSharp:
                 case Lang.Cx:
+                case Lang.Flatbuffer:
                     break;
 
                 default:
@@ -379,7 +387,8 @@ protected override void LogEventsFromTextOutput(string singleLine, MessageImport
                 singleLine.StartsWith("C# code for class ") ||
                 singleLine.StartsWith("Cppwinrt header for class ") ||
                 singleLine.StartsWith("Cppwinrt source for class ") ||
-                singleLine.StartsWith("Cppwinrt IDL for class ");
+                singleLine.StartsWith("Cppwinrt IDL for class ") ||
+                singleLine.StartsWith("Flatbuffer data for class ");
         }
 
         Lang GetNormalizedLanguage()
@@ -397,6 +406,9 @@ Lang GetNormalizedLanguage()
                 case "cx":
                     return Lang.Cx;
 
+                case "flatbuffer":
+                    return Lang.Flatbuffer;
+
                 default:
                     return Lang.Unknown;
             }
@@ -408,6 +420,7 @@ enum Lang
             CSharp,
             Cx,
             Cppwinrt,
+            Flatbuffer,
         }
     }
 }

From 287736cb93094ad2bb091673f1a5520efc15ee48 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Wed, 21 Oct 2026 10:23:36 -0700
Subject: [PATCH 37/39] Consume FlatBuffers through vcpkg and package native
 headers

Restore pinned FlatBuffers dependencies for MSBuild, bootstrap vcpkg when needed, and replace vendored headers. Package the schema, native sources, headers, and license under the documented consumer layout.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d33f7269-9a0c-4437-aadd-0da22dcee956
---
 .github/workflows/dotnet-build.yml            |    7 +
 .gitignore                                    |    4 +
 LottieGen/DotnetTool/LottieGen.csproj         |   25 +-
 build/FlatBuffers.targets                     |   27 +
 build/RegenerateFlatbuffers.ps1               |   70 +-
 build/RestoreFlatBuffers.ps1                  |   57 +
 build/build.cake                              |    2 +
 external/flatbuffers/LICENSE                  |  202 --
 external/flatbuffers/UPSTREAM.md              |   11 -
 .../include/flatbuffers/allocator.h           |   68 -
 .../flatbuffers/include/flatbuffers/array.h   |  258 --
 .../flatbuffers/include/flatbuffers/base.h    |  503 ----
 .../flatbuffers/include/flatbuffers/buffer.h  |  225 --
 .../include/flatbuffers/buffer_ref.h          |   54 -
 .../include/flatbuffers/code_generator.h      |   99 -
 .../include/flatbuffers/code_generators.h     |  238 --
 .../include/flatbuffers/default_allocator.h   |   64 -
 .../include/flatbuffers/detached_buffer.h     |  121 -
 .../include/flatbuffers/file_manager.h        |   70 -
 .../include/flatbuffers/flatbuffer_builder.h  | 1518 ------------
 .../include/flatbuffers/flatbuffers.h         |  284 ---
 .../flatbuffers/include/flatbuffers/flatc.h   |  131 --
 .../include/flatbuffers/flex_flat_util.h      |   37 -
 .../include/flatbuffers/flexbuffers.h         | 2086 -----------------
 .../flatbuffers/include/flatbuffers/grpc.h    |  303 ---
 .../flatbuffers/include/flatbuffers/hash.h    |  135 --
 .../flatbuffers/include/flatbuffers/idl.h     | 1329 -----------
 .../include/flatbuffers/minireflect.h         |  441 ----
 .../include/flatbuffers/pch/flatc_pch.h       |   39 -
 .../flatbuffers/include/flatbuffers/pch/pch.h |   38 -
 .../include/flatbuffers/reflection.h          |  530 -----
 .../flatbuffers/reflection_generated.h        | 1541 ------------
 .../include/flatbuffers/registry.h            |  130 -
 .../include/flatbuffers/stl_emulation.h       |  516 ----
 .../flatbuffers/include/flatbuffers/string.h  |   69 -
 .../flatbuffers/include/flatbuffers/struct.h  |   55 -
 .../flatbuffers/include/flatbuffers/table.h   |  263 ---
 .../flatbuffers/include/flatbuffers/util.h    |  781 ------
 .../flatbuffers/include/flatbuffers/vector.h  |  455 ----
 .../include/flatbuffers/vector_downward.h     |  298 ---
 .../include/flatbuffers/verifier.h            |  370 ---
 source/LottieFlatbuffer/README.md             |   14 +-
 .../LottieRuntime/LottieRuntimeTool.vcxproj   |    7 +-
 source/LottieRuntime/README.md                |   62 +-
 tests/LottieRuntime.Tests/PackageTests.ps1    |   71 +
 vcpkg.json                                    |   14 +
 46 files changed, 278 insertions(+), 13344 deletions(-)
 create mode 100644 build/FlatBuffers.targets
 create mode 100644 build/RestoreFlatBuffers.ps1
 delete mode 100644 external/flatbuffers/LICENSE
 delete mode 100644 external/flatbuffers/UPSTREAM.md
 delete mode 100644 external/flatbuffers/include/flatbuffers/allocator.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/array.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/base.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/buffer.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/buffer_ref.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/code_generator.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/code_generators.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/default_allocator.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/detached_buffer.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/file_manager.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/flatbuffer_builder.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/flatbuffers.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/flatc.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/flex_flat_util.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/flexbuffers.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/grpc.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/hash.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/idl.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/minireflect.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/pch/flatc_pch.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/pch/pch.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/reflection.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/reflection_generated.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/registry.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/stl_emulation.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/string.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/struct.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/table.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/util.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/vector.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/vector_downward.h
 delete mode 100644 external/flatbuffers/include/flatbuffers/verifier.h
 create mode 100644 tests/LottieRuntime.Tests/PackageTests.ps1
 create mode 100644 vcpkg.json

diff --git a/.github/workflows/dotnet-build.yml b/.github/workflows/dotnet-build.yml
index 1e4e4c7d..190342e9 100644
--- a/.github/workflows/dotnet-build.yml
+++ b/.github/workflows/dotnet-build.yml
@@ -65,6 +65,13 @@ jobs:
         shell: pwsh
         working-directory: .\build
 
+      - name: Validate LottieGen native package content
+        shell: pwsh
+        run: |
+          $package = Get-ChildItem .\bin\nupkg\LottieGen.*.nupkg | Where-Object Name -notlike 'LottieGen.MsBuild.*' | Where-Object Name -notlike 'LottieGen.win-x64.*'
+          if (@($package).Count -ne 1) { throw "Expected one LottieGen tool package." }
+          .\tests\LottieRuntime.Tests\PackageTests.ps1 -PackagePath $package.FullName
+
       - name: Upload Package List
         uses: actions/upload-artifact@v4
         with:
diff --git a/.gitignore b/.gitignore
index 203b9893..ed41585a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -238,3 +238,7 @@ launchSettings.json
 
 # Nuget Package files.
 pack/
+
+# Native dependencies restored by MSBuild.
+/.vcpkg/
+/vcpkg_installed/
diff --git a/LottieGen/DotnetTool/LottieGen.csproj b/LottieGen/DotnetTool/LottieGen.csproj
index 00f3dfc4..b82eebeb 100644
--- a/LottieGen/DotnetTool/LottieGen.csproj
+++ b/LottieGen/DotnetTool/LottieGen.csproj
@@ -9,7 +9,9 @@
     <IsPackable>true</IsPackable>
     <PackAsTool>true</PackAsTool>
     <ToolCommandName>LottieGen</ToolCommandName>
+    <FlatBuffersVcpkgTriplet Condition="'$(FlatBuffersVcpkgTriplet)' == ''">x64-windows</FlatBuffersVcpkgTriplet>
   </PropertyGroup>
+  <Import Project="..\..\build\FlatBuffers.targets" />
 
   <PropertyGroup>
     <_SourceDir>..\..\source\</_SourceDir>
@@ -39,12 +41,27 @@
   </ItemGroup>
 
   <ItemGroup>
-    <None Include="..\..\source\LottieRuntime\LottieRuntime.h" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\source\LottieRuntime\LottieRuntime.h" Pack="true" PackagePath="inc\lottiecomp\" />
+    <None Include="..\..\source\LottieRuntime\LottieVisualSource.h" Pack="true" PackagePath="inc\lottiecomp\" />
     <None Include="..\..\source\LottieRuntime\LottieRuntime.cpp" Pack="true" PackagePath="LottieRuntime\" />
+    <None Include="..\..\source\LottieRuntime\LottieVisualSource.cpp" Pack="true" PackagePath="LottieRuntime\" />
     <None Include="..\..\source\LottieRuntime\README.md" Pack="true" PackagePath="LottieRuntime\" />
-    <None Include="..\..\source\LottieRuntime\Generated\lottie_comp_generated.h" Pack="true" PackagePath="LottieRuntime\Generated\" />
-    <None Include="..\..\external\flatbuffers\include\**\*" Pack="true" PackagePath="LottieRuntime\flatbuffers\include\" />
-    <None Include="..\..\external\flatbuffers\LICENSE" Pack="true" PackagePath="LottieRuntime\flatbuffers\" />
+    <None Include="..\..\source\LottieRuntime\Generated\lottie_comp_generated.h" Pack="true" PackagePath="inc\lottiecomp\Generated\" />
+    <None Include="..\..\source\LottieFlatbuffer\lottie_comp.fbs" Pack="true" PackagePath="LottieRuntime\" />
     <None Include="..\..\LICENSE.md" Pack="true" PackagePath="LottieRuntime\" />
   </ItemGroup>
+
+  <Target Name="CollectLottieRuntimePackageContent" BeforeTargets="_GetPackageFiles"
+          DependsOnTargets="RestoreFlatBuffers">
+    <Error Condition="!Exists('$(FlatBuffersVcpkgInstalledDir)\$(FlatBuffersVcpkgTriplet)\share\flatbuffers\copyright')"
+           Text="The restored FlatBuffers license is required to package LottieGen." />
+    <Copy SourceFiles="$(FlatBuffersVcpkgInstalledDir)\$(FlatBuffersVcpkgTriplet)\share\flatbuffers\copyright"
+          DestinationFiles="$(IntermediateOutputPath)flatbuffers.LICENSE.txt" />
+    <ItemGroup>
+      <None Include="$(FlatBuffersIncludeDirectory)\flatbuffers\**\*"
+            Pack="true" PackagePath="inc\lottiecomp\flatbuffers\%(RecursiveDir)" />
+      <None Include="$(IntermediateOutputPath)flatbuffers.LICENSE.txt"
+            Pack="true" PackagePath="LottieRuntime\" />
+    </ItemGroup>
+  </Target>
 </Project>
diff --git a/build/FlatBuffers.targets b/build/FlatBuffers.targets
new file mode 100644
index 00000000..87c152a1
--- /dev/null
+++ b/build/FlatBuffers.targets
@@ -0,0 +1,27 @@
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <_FlatBuffersRepoRoot>$(MSBuildThisFileDirectory)..\</_FlatBuffersRepoRoot>
+    <_RestoreFlatBuffers Condition="'$(FlatBuffersIncludeDirectory)' == ''">true</_RestoreFlatBuffers>
+    <FlatBuffersVcpkgRoot Condition="'$(FlatBuffersVcpkgRoot)' == '' and '$(VcpkgRoot)' != ''">$(VcpkgRoot)</FlatBuffersVcpkgRoot>
+    <FlatBuffersVcpkgRoot Condition="'$(FlatBuffersVcpkgRoot)' == '' and '$(VCPKG_ROOT)' != ''">$(VCPKG_ROOT)</FlatBuffersVcpkgRoot>
+    <FlatBuffersVcpkgRoot Condition="'$(FlatBuffersVcpkgRoot)' == '' and Exists('$(VSInstallRoot)\VC\vcpkg\vcpkg.exe')">$(VSInstallRoot)\VC\vcpkg</FlatBuffersVcpkgRoot>
+    <FlatBuffersVcpkgRoot Condition="'$(FlatBuffersVcpkgRoot)' == ''">$(_FlatBuffersRepoRoot).vcpkg</FlatBuffersVcpkgRoot>
+    <FlatBuffersVcpkgInstalledDir Condition="'$(FlatBuffersVcpkgInstalledDir)' == ''">$(_FlatBuffersRepoRoot)vcpkg_installed</FlatBuffersVcpkgInstalledDir>
+    <FlatBuffersVcpkgTriplet Condition="'$(FlatBuffersVcpkgTriplet)' == '' and '$(Platform)' == 'x64'">x64-windows</FlatBuffersVcpkgTriplet>
+    <FlatBuffersVcpkgTriplet Condition="'$(FlatBuffersVcpkgTriplet)' == '' and '$(Platform)' == 'ARM64'">arm64-windows</FlatBuffersVcpkgTriplet>
+    <FlatBuffersVcpkgHostTriplet Condition="'$(FlatBuffersVcpkgHostTriplet)' == '' and ('$(PROCESSOR_ARCHITECTURE)' == 'ARM64' or '$(PROCESSOR_ARCHITEW6432)' == 'ARM64')">arm64-windows</FlatBuffersVcpkgHostTriplet>
+    <FlatBuffersVcpkgHostTriplet Condition="'$(FlatBuffersVcpkgHostTriplet)' == ''">x64-windows</FlatBuffersVcpkgHostTriplet>
+    <FlatBuffersIncludeDirectory Condition="'$(_RestoreFlatBuffers)' == 'true'">$(FlatBuffersVcpkgInstalledDir)\$(FlatBuffersVcpkgTriplet)\include</FlatBuffersIncludeDirectory>
+  </PropertyGroup>
+
+  <!-- Invoke vcpkg explicitly so a first-build bootstrap works without evaluation-time imports. -->
+  <Target Name="RestoreFlatBuffers" BeforeTargets="$(FlatBuffersRestoreBeforeTargets)"
+          Condition="'$(DesignTimeBuild)' != 'true'">
+    <Error Condition="'$(_RestoreFlatBuffers)' == 'true' and '$(FlatBuffersVcpkgTriplet)' == ''"
+           Text="Set FlatBuffersVcpkgTriplet for platform '$(Platform)'. Supported defaults are x64 and ARM64." />
+    <Exec Condition="'$(_RestoreFlatBuffers)' == 'true'"
+          Command="powershell.exe -NoProfile -ExecutionPolicy Bypass -File &quot;$(MSBuildThisFileDirectory)RestoreFlatBuffers.ps1&quot; -VcpkgRoot &quot;$(FlatBuffersVcpkgRoot)\.&quot; -InstalledDir &quot;$(FlatBuffersVcpkgInstalledDir)\.&quot; -Triplet &quot;$(FlatBuffersVcpkgTriplet)&quot; -HostTriplet &quot;$(FlatBuffersVcpkgHostTriplet)&quot;" />
+    <Error Condition="!Exists('$(FlatBuffersIncludeDirectory)\flatbuffers\flatbuffers.h')"
+           Text="FlatBuffers headers were not found at '$(FlatBuffersIncludeDirectory)'. Restore vcpkg dependencies or set FlatBuffersIncludeDirectory to the include directory for FlatBuffers 25.12.19." />
+  </Target>
+</Project>
diff --git a/build/RegenerateFlatbuffers.ps1 b/build/RegenerateFlatbuffers.ps1
index 134f1e10..2e7f5ec4 100644
--- a/build/RegenerateFlatbuffers.ps1
+++ b/build/RegenerateFlatbuffers.ps1
@@ -5,60 +5,30 @@
 # source/LottieFlatbuffer/lottie_comp.fbs, and check in the result.
 #
 # C# output must match the Google.FlatBuffers package available through the
-# configured Microsoft feed. C++ output must match external/flatbuffers.
+# configured Microsoft feed. C++ output must match the vcpkg manifest.
 #
-# To obtain the matching C++ compiler and headers:
-# 1. Download the Windows flatc binary for v25.12.19 from
-#    https://github.com/google/flatbuffers/releases/tag/v25.12.19.
-# 2. Download and extract the source archive for commit
-#    5761d6e67af841d15ee21bc1ce9a78ffa9cf939e.
-# 3. Pass the extracted source directory as -CppSource. The script validates
-#    its version, copies include/flatbuffers and LICENSE into external/flatbuffers,
-#    and regenerates the checked-in C++ binding with the matching flatc.exe.
+# RestoreFlatBuffers installs the matching C++ compiler under
+# vcpkg_installed/<host-triplet>/tools/flatbuffers/flatc.exe.
 
 [CmdletBinding()]
 param(
     # C# code must match the Google.FlatBuffers package version.
     [string]$CSharpFlatc = "flatc",
 
-    # C++ code must match the headers in external/flatbuffers.
-    [Parameter(Mandatory)]
-    [string]$CppFlatc,
-
-    # Optional extracted FlatBuffers source tree. Supply this when updating the
-    # vendored headers and license.
-    [string]$CppSource
+    # C++ code must match the headers restored by vcpkg.
+    [string]$CppFlatc = (Join-Path $PSScriptRoot "..\vcpkg_installed\x64-windows\tools\flatbuffers\flatc.exe")
 )
 
 $ErrorActionPreference = "Stop"
 
 $expectedCSharpVersion = "25.2.10"
-$expectedCppVersion = "25.12.19"
-$expectedCppCommit = "5761d6e67af841d15ee21bc1ce9a78ffa9cf939e"
 
 $repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..")
 $schema = Join-Path $repoRoot "source/LottieFlatbuffer/lottie_comp.fbs"
 $csharpOut = Join-Path $repoRoot "source/CompDataFlatbuffer/Generated"
 $cppOut = Join-Path $repoRoot "source/LottieRuntime/Generated"
-$vendoredFlatBuffers = Join-Path $repoRoot "external/flatbuffers"
-
-function Get-HeaderVersion([string]$sourceRoot) {
-    $baseHeader = Join-Path $sourceRoot "include/flatbuffers/base.h"
-    if (!(Test-Path $baseHeader)) {
-        throw "FlatBuffers header not found: $baseHeader"
-    }
-
-    $contents = Get-Content $baseHeader -Raw
-    $major = [regex]::Match($contents, '#define FLATBUFFERS_VERSION_MAJOR\s+(\d+)').Groups[1].Value
-    $minor = [regex]::Match($contents, '#define FLATBUFFERS_VERSION_MINOR\s+(\d+)').Groups[1].Value
-    $revision = [regex]::Match($contents, '#define FLATBUFFERS_VERSION_REVISION\s+(\d+)').Groups[1].Value
-
-    if (!$major -or !$minor -or !$revision) {
-        throw "Could not read the FlatBuffers version from $baseHeader."
-    }
-
-    return "$major.$minor.$revision"
-}
+$manifest = Get-Content (Join-Path $repoRoot "vcpkg.json") -Raw | ConvertFrom-Json
+$expectedCppVersion = ($manifest.overrides | Where-Object name -eq "flatbuffers").version
 
 $actualCSharpVersion = (& $CSharpFlatc --version) -replace '^flatc version ', ''
 if ($actualCSharpVersion.Trim() -ne $expectedCSharpVersion) {
@@ -70,32 +40,6 @@ if ($actualCppVersion.Trim() -ne $expectedCppVersion) {
     throw "C++ flatc version $expectedCppVersion is required, but '$CppFlatc' is version $($actualCppVersion.Trim())."
 }
 
-if ($CppSource) {
-    $resolvedCppSource = Resolve-Path $CppSource
-    $sourceVersion = Get-HeaderVersion $resolvedCppSource
-    if ($sourceVersion -ne $expectedCppVersion) {
-        throw "FlatBuffers headers version $expectedCppVersion is required, but '$resolvedCppSource' contains version $sourceVersion."
-    }
-
-    $sourceLicense = Join-Path $resolvedCppSource "LICENSE"
-    if (!(Test-Path $sourceLicense)) {
-        throw "FlatBuffers license not found: $sourceLicense"
-    }
-
-    $vendoredHeaders = Join-Path $vendoredFlatBuffers "include/flatbuffers"
-    Remove-Item -LiteralPath $vendoredHeaders -Recurse -Force -ErrorAction SilentlyContinue
-    New-Item -ItemType Directory -Force -Path (Split-Path $vendoredHeaders) | Out-Null
-    Copy-Item -LiteralPath (Join-Path $resolvedCppSource "include/flatbuffers") -Destination $vendoredHeaders -Recurse
-    Copy-Item -LiteralPath $sourceLicense -Destination (Join-Path $vendoredFlatBuffers "LICENSE") -Force
-
-    Write-Host "Updated vendored FlatBuffers headers from commit $expectedCppCommit"
-}
-
-$vendoredVersion = Get-HeaderVersion $vendoredFlatBuffers
-if ($vendoredVersion -ne $expectedCppVersion) {
-    throw "Vendored FlatBuffers headers must be version $expectedCppVersion, but they are version $vendoredVersion."
-}
-
 New-Item -ItemType Directory -Force -Path $csharpOut, $cppOut | Out-Null
 
 # --gen-onefile keeps the checked in C# to a single file rather than one file
diff --git a/build/RestoreFlatBuffers.ps1 b/build/RestoreFlatBuffers.ps1
new file mode 100644
index 00000000..1b21ebc7
--- /dev/null
+++ b/build/RestoreFlatBuffers.ps1
@@ -0,0 +1,57 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)]
+    [string]$VcpkgRoot,
+
+    [Parameter(Mandatory)]
+    [string]$InstalledDir,
+
+    [Parameter(Mandatory)]
+    [string]$Triplet,
+
+    [string]$HostTriplet = "x64-windows"
+)
+
+$ErrorActionPreference = "Stop"
+$repoRoot = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot ".."))
+$VcpkgRoot = [IO.Path]::GetFullPath($VcpkgRoot)
+$InstalledDir = [IO.Path]::GetFullPath($InstalledDir)
+$localRoot = Join-Path $repoRoot ".vcpkg"
+$vcpkg = Join-Path $VcpkgRoot "vcpkg.exe"
+
+function Invoke-Checked([string]$Program, [string[]]$Arguments) {
+    & $Program @Arguments
+    if ($LASTEXITCODE -ne 0) {
+        throw "'$Program $($Arguments -join ' ')' failed with exit code $LASTEXITCODE."
+    }
+}
+
+if (!(Test-Path -LiteralPath $vcpkg)) {
+    if ($VcpkgRoot -ne $localRoot) {
+        throw "vcpkg.exe was not found at '$VcpkgRoot'. Bootstrap that installation or omit FlatBuffersVcpkgRoot to use automatic discovery."
+    }
+
+    $baseline = (Get-Content (Join-Path $repoRoot "vcpkg.json") -Raw | ConvertFrom-Json).'builtin-baseline'
+    if (!(Test-Path -LiteralPath $VcpkgRoot)) {
+        Invoke-Checked "git" @("init", $VcpkgRoot)
+        Invoke-Checked "git" @("-C", $VcpkgRoot, "remote", "add", "origin", "https://github.com/microsoft/vcpkg.git")
+    }
+
+    $remote = & git -C $VcpkgRoot remote get-url origin
+    if ($LASTEXITCODE -ne 0 -or $remote -ne "https://github.com/microsoft/vcpkg.git") {
+        throw "'$VcpkgRoot' must be a checkout of https://github.com/microsoft/vcpkg.git."
+    }
+
+    Invoke-Checked "git" @("-C", $VcpkgRoot, "fetch", "--depth=1", "origin", $baseline)
+    Invoke-Checked "git" @("-C", $VcpkgRoot, "checkout", "--detach", $baseline)
+    Invoke-Checked (Join-Path $VcpkgRoot "bootstrap-vcpkg.bat") @("-disableMetrics")
+}
+
+Invoke-Checked $vcpkg @(
+    "install",
+    "--triplet=$Triplet",
+    "--host-triplet=$HostTriplet",
+    "--x-wait-for-lock",
+    "--x-manifest-root=$repoRoot",
+    "--x-install-root=$InstalledDir"
+)
diff --git a/build/build.cake b/build/build.cake
index 1c27469a..438cb353 100644
--- a/build/build.cake
+++ b/build/build.cake
@@ -101,6 +101,8 @@ static bool IsExcludedDirectory(FilePath path)
     return
         segments.Contains("bin") ||
         segments.Contains("external") ||
+        segments.Contains(".vcpkg") ||
+        segments.Contains("vcpkg_installed") ||
         segments.Contains("internal") ||
         segments.Contains("obj");
 }
diff --git a/external/flatbuffers/LICENSE b/external/flatbuffers/LICENSE
deleted file mode 100644
index d6456956..00000000
--- a/external/flatbuffers/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/external/flatbuffers/UPSTREAM.md b/external/flatbuffers/UPSTREAM.md
deleted file mode 100644
index 751489c9..00000000
--- a/external/flatbuffers/UPSTREAM.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# FlatBuffers headers
-
-The files in this directory are vendored from:
-
-- Repository: <https://github.com/google/flatbuffers>
-- Commit: `5761d6e67af841d15ee21bc1ce9a78ffa9cf939e`
-- Header and `flatc` version: `25.12.19`
-
-Only the C++ headers under `include/flatbuffers` and the upstream `LICENSE` are
-included. Use `build/RegenerateFlatbuffers.ps1` to validate and update this copy
-alongside the generated C++ binding.
diff --git a/external/flatbuffers/include/flatbuffers/allocator.h b/external/flatbuffers/include/flatbuffers/allocator.h
deleted file mode 100644
index d4518185..00000000
--- a/external/flatbuffers/include/flatbuffers/allocator.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_ALLOCATOR_H_
-#define FLATBUFFERS_ALLOCATOR_H_
-
-#include "flatbuffers/base.h"
-
-namespace flatbuffers {
-
-// Allocator interface. This is flatbuffers-specific and meant only for
-// `vector_downward` usage.
-class Allocator {
- public:
-  virtual ~Allocator() {}
-
-  // Allocate `size` bytes of memory.
-  virtual uint8_t* allocate(size_t size) = 0;
-
-  // Deallocate `size` bytes of memory at `p` allocated by this allocator.
-  virtual void deallocate(uint8_t* p, size_t size) = 0;
-
-  // Reallocate `new_size` bytes of memory, replacing the old region of size
-  // `old_size` at `p`. In contrast to a normal realloc, this grows downwards,
-  // and is intended specifcally for `vector_downward` use.
-  // `in_use_back` and `in_use_front` indicate how much of `old_size` is
-  // actually in use at each end, and needs to be copied.
-  virtual uint8_t* reallocate_downward(uint8_t* old_p, size_t old_size,
-                                       size_t new_size, size_t in_use_back,
-                                       size_t in_use_front) {
-    FLATBUFFERS_ASSERT(new_size > old_size);  // vector_downward only grows
-    uint8_t* new_p = allocate(new_size);
-    memcpy_downward(old_p, old_size, new_p, new_size, in_use_back,
-                    in_use_front);
-    deallocate(old_p, old_size);
-    return new_p;
-  }
-
- protected:
-  // Called by `reallocate_downward` to copy memory from `old_p` of `old_size`
-  // to `new_p` of `new_size`. Only memory of size `in_use_front` and
-  // `in_use_back` will be copied from the front and back of the old memory
-  // allocation.
-  void memcpy_downward(uint8_t* old_p, size_t old_size, uint8_t* new_p,
-                       size_t new_size, size_t in_use_back,
-                       size_t in_use_front) {
-    memcpy(new_p + new_size - in_use_back, old_p + old_size - in_use_back,
-           in_use_back);
-    memcpy(new_p, old_p, in_use_front);
-  }
-};
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_ALLOCATOR_H_
diff --git a/external/flatbuffers/include/flatbuffers/array.h b/external/flatbuffers/include/flatbuffers/array.h
deleted file mode 100644
index 163d8c36..00000000
--- a/external/flatbuffers/include/flatbuffers/array.h
+++ /dev/null
@@ -1,258 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_ARRAY_H_
-#define FLATBUFFERS_ARRAY_H_
-
-#include <cstdint>
-#include <memory>
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/stl_emulation.h"
-#include "flatbuffers/vector.h"
-
-namespace flatbuffers {
-
-// This is used as a helper type for accessing arrays.
-template <typename T, uint16_t length>
-class Array {
-  // Array<T> can carry only POD data types (scalars or structs).
-  typedef typename flatbuffers::bool_constant<flatbuffers::is_scalar<T>::value>
-      scalar_tag;
-
- public:
-  typedef uint16_t size_type;
-  typedef typename IndirectHelper<T>::return_type return_type;
-  typedef VectorConstIterator<T, return_type, uoffset_t> const_iterator;
-  typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
-
-  // If T is a non-pointer and a LE-scalar or a struct (!scalar_tag::value).
-  static FLATBUFFERS_CONSTEXPR bool is_span_observable =
-      !std::is_pointer<T>::value &&
-      ((scalar_tag::value && (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1)) ||
-       !scalar_tag::value);
-
-  FLATBUFFERS_CONSTEXPR uint16_t size() const { return length; }
-
-  return_type Get(uoffset_t i) const {
-    FLATBUFFERS_ASSERT(i < size());
-    return IndirectHelper<T>::Read(Data(), i);
-  }
-
-  return_type operator[](uoffset_t i) const { return Get(i); }
-
-  // If this is a Vector of enums, T will be its storage type, not the enum
-  // type. This function makes it convenient to retrieve value with enum
-  // type E.
-  template <typename E>
-  E GetEnum(uoffset_t i) const {
-    return static_cast<E>(Get(i));
-  }
-
-  const_iterator begin() const { return const_iterator(Data(), 0); }
-  const_iterator end() const { return const_iterator(Data(), size()); }
-
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin());
-  }
-
-  const_iterator cbegin() const { return begin(); }
-  const_iterator cend() const { return end(); }
-
-  const_reverse_iterator crbegin() const { return rbegin(); }
-  const_reverse_iterator crend() const { return rend(); }
-
-  // Get a mutable pointer to elements inside this array.
-  // This method used to mutate arrays of structs followed by a @p Mutate
-  // operation. For primitive types use @p Mutate directly.
-  // @warning Assignments and reads to/from the dereferenced pointer are not
-  //  automatically converted to the correct endianness.
-  typename flatbuffers::conditional<scalar_tag::value, void, T*>::type
-  GetMutablePointer(uoffset_t i) const {
-    FLATBUFFERS_ASSERT(i < size());
-    return const_cast<T*>(&data()[i]);
-  }
-
-  // Change elements if you have a non-const pointer to this object.
-  void Mutate(uoffset_t i, const T& val) { MutateImpl(scalar_tag(), i, val); }
-
-  // The raw data in little endian format. Use with care.
-  const uint8_t* Data() const { return data_; }
-
-  uint8_t* Data() { return data_; }
-
-  // Similarly, but typed, much like std::vector::data
-  const T* data() const { return reinterpret_cast<const T*>(Data()); }
-  T* data() { return reinterpret_cast<T*>(Data()); }
-
-  // Copy data from a span with endian conversion.
-  // If this Array and the span overlap, the behavior is undefined.
-  void CopyFromSpan(flatbuffers::span<const T, length> src) {
-    const auto p1 = reinterpret_cast<const uint8_t*>(src.data());
-    const auto p2 = Data();
-    FLATBUFFERS_ASSERT(!(p1 >= p2 && p1 < (p2 + length)) &&
-                       !(p2 >= p1 && p2 < (p1 + length)));
-    (void)p1;
-    (void)p2;
-    CopyFromSpanImpl(flatbuffers::bool_constant<is_span_observable>(), src);
-  }
-
- protected:
-  void MutateImpl(flatbuffers::true_type, uoffset_t i, const T& val) {
-    FLATBUFFERS_ASSERT(i < size());
-    WriteScalar(data() + i, val);
-  }
-
-  void MutateImpl(flatbuffers::false_type, uoffset_t i, const T& val) {
-    *(GetMutablePointer(i)) = val;
-  }
-
-  void CopyFromSpanImpl(flatbuffers::true_type,
-                        flatbuffers::span<const T, length> src) {
-    // Use std::memcpy() instead of std::copy() to avoid performance degradation
-    // due to aliasing if T is char or unsigned char.
-    // The size is known at compile time, so memcpy would be inlined.
-    std::memcpy(data(), src.data(), length * sizeof(T));
-  }
-
-  // Copy data from flatbuffers::span with endian conversion.
-  void CopyFromSpanImpl(flatbuffers::false_type,
-                        flatbuffers::span<const T, length> src) {
-    for (size_type k = 0; k < length; k++) {
-      Mutate(k, src[k]);
-    }
-  }
-
-  // This class is only used to access pre-existing data. Don't ever
-  // try to construct these manually.
-  // 'constexpr' allows us to use 'size()' at compile time.
-  // @note Must not use 'FLATBUFFERS_CONSTEXPR' here, as const is not allowed on
-  //  a constructor.
-#if defined(__cpp_constexpr)
-  constexpr Array();
-#else
-  Array();
-#endif
-
-  uint8_t data_[length * sizeof(T)];
-
- private:
-  // This class is a pointer. Copying will therefore create an invalid object.
-  // Private and unimplemented copy constructor.
-  Array(const Array&);
-  Array& operator=(const Array&);
-};
-
-// Specialization for Array[struct] with access using Offset<void> pointer.
-// This specialization used by idl_gen_text.cpp.
-template <typename T, uint16_t length, template <typename> class OffsetT>
-class Array<OffsetT<T>, length> {
-  static_assert(flatbuffers::is_same<T, void>::value, "unexpected type T");
-
- public:
-  typedef const void* return_type;
-  typedef uint16_t size_type;
-
-  const uint8_t* Data() const { return data_; }
-
-  // Make idl_gen_text.cpp::PrintContainer happy.
-  return_type operator[](uoffset_t) const {
-    FLATBUFFERS_ASSERT(false);
-    return nullptr;
-  }
-
- private:
-  // This class is only used to access pre-existing data.
-  Array();
-  Array(const Array&);
-  Array& operator=(const Array&);
-
-  uint8_t data_[1];
-};
-
-template <class U, uint16_t N>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U, N> make_span(Array<U, N>& arr)
-    FLATBUFFERS_NOEXCEPT {
-  static_assert(
-      Array<U, N>::is_span_observable,
-      "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
-  return span<U, N>(arr.data(), N);
-}
-
-template <class U, uint16_t N>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U, N> make_span(
-    const Array<U, N>& arr) FLATBUFFERS_NOEXCEPT {
-  static_assert(
-      Array<U, N>::is_span_observable,
-      "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
-  return span<const U, N>(arr.data(), N);
-}
-
-template <class U, uint16_t N>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<uint8_t, sizeof(U) * N>
-make_bytes_span(Array<U, N>& arr) FLATBUFFERS_NOEXCEPT {
-  static_assert(Array<U, N>::is_span_observable,
-                "internal error, Array<T> might hold only scalars or structs");
-  return span<uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
-}
-
-template <class U, uint16_t N>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const uint8_t, sizeof(U) * N>
-make_bytes_span(const Array<U, N>& arr) FLATBUFFERS_NOEXCEPT {
-  static_assert(Array<U, N>::is_span_observable,
-                "internal error, Array<T> might hold only scalars or structs");
-  return span<const uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
-}
-
-// Cast a raw T[length] to a raw flatbuffers::Array<T, length>
-// without endian conversion. Use with care.
-// TODO: move these Cast-methods to `internal` namespace.
-template <typename T, uint16_t length>
-Array<T, length>& CastToArray(T (&arr)[length]) {
-  return *reinterpret_cast<Array<T, length>*>(arr);
-}
-
-template <typename T, uint16_t length>
-const Array<T, length>& CastToArray(const T (&arr)[length]) {
-  return *reinterpret_cast<const Array<T, length>*>(arr);
-}
-
-template <typename E, typename T, uint16_t length>
-Array<E, length>& CastToArrayOfEnum(T (&arr)[length]) {
-  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
-  return *reinterpret_cast<Array<E, length>*>(arr);
-}
-
-template <typename E, typename T, uint16_t length>
-const Array<E, length>& CastToArrayOfEnum(const T (&arr)[length]) {
-  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
-  return *reinterpret_cast<const Array<E, length>*>(arr);
-}
-
-template <typename T, uint16_t length>
-bool operator==(const Array<T, length>& lhs,
-                const Array<T, length>& rhs) noexcept {
-  return std::addressof(lhs) == std::addressof(rhs) ||
-         (lhs.size() == rhs.size() &&
-          std::memcmp(lhs.Data(), rhs.Data(), rhs.size() * sizeof(T)) == 0);
-}
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_ARRAY_H_
diff --git a/external/flatbuffers/include/flatbuffers/base.h b/external/flatbuffers/include/flatbuffers/base.h
deleted file mode 100644
index 1d2ab585..00000000
--- a/external/flatbuffers/include/flatbuffers/base.h
+++ /dev/null
@@ -1,503 +0,0 @@
-#ifndef FLATBUFFERS_BASE_H_
-#define FLATBUFFERS_BASE_H_
-
-// clang-format off
-
-// If activate should be declared and included first.
-#if defined(FLATBUFFERS_MEMORY_LEAK_TRACKING) && \
-    defined(_MSC_VER) && defined(_DEBUG)
-  // The _CRTDBG_MAP_ALLOC inside <crtdbg.h> will replace
-  // calloc/free (etc) to its debug version using #define directives.
-  #define _CRTDBG_MAP_ALLOC
-  #include <stdlib.h>
-  #include <crtdbg.h>
-  // Replace operator new by trace-enabled version.
-  #define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
-  #define new DEBUG_NEW
-#endif
-
-#if !defined(FLATBUFFERS_ASSERT)
-#include <assert.h>
-#define FLATBUFFERS_ASSERT assert
-#elif defined(FLATBUFFERS_ASSERT_INCLUDE)
-// Include file with forward declaration
-#include FLATBUFFERS_ASSERT_INCLUDE
-#endif
-
-#ifndef ARDUINO
-#include <cstdint>
-#endif
-
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-
-#if defined(ARDUINO) && !defined(ARDUINOSTL_M_H) && defined(__AVR__)
-  #include <utility.h>
-#else
-  #include <utility>
-#endif
-
-#include <string>
-#include <type_traits>
-#include <vector>
-#include <set>
-#include <algorithm>
-#include <limits>
-#include <iterator>
-#include <memory>
-
-#if defined(__unix__) && !defined(FLATBUFFERS_LOCALE_INDEPENDENT)
-  #include <unistd.h>
-#endif
-
-#ifdef __ANDROID__
-  #include <android/api-level.h>
-#endif
-
-#if defined(__ICCARM__)
-#include <intrinsics.h>
-#endif
-
-// Note the __clang__ check is needed, because clang presents itself
-// as an older GNUC compiler (4.2).
-// Clang 3.3 and later implement all of the ISO C++ 2011 standard.
-// Clang 3.4 and later implement all of the ISO C++ 2014 standard.
-// http://clang.llvm.org/cxx_status.html
-
-// Note the MSVC value '__cplusplus' may be incorrect:
-// The '__cplusplus' predefined macro in the MSVC stuck at the value 199711L,
-// indicating (erroneously!) that the compiler conformed to the C++98 Standard.
-// This value should be correct starting from MSVC2017-15.7-Preview-3.
-// The '__cplusplus' will be valid only if MSVC2017-15.7-P3 and the `/Zc:__cplusplus` switch is set.
-// Workaround (for details see MSDN):
-// Use the _MSC_VER and _MSVC_LANG definition instead of the __cplusplus  for compatibility.
-// The _MSVC_LANG macro reports the Standard version regardless of the '/Zc:__cplusplus' switch.
-
-#if defined(__GNUC__) && !defined(__clang__)
-  #define FLATBUFFERS_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-#else
-  #define FLATBUFFERS_GCC 0
-#endif
-
-#if defined(__clang__)
-  #define FLATBUFFERS_CLANG (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
-#else
-  #define FLATBUFFERS_CLANG 0
-#endif
-
-/// @cond FLATBUFFERS_INTERNAL
-#if __cplusplus <= 199711L && \
-    (!defined(_MSC_VER) || _MSC_VER < 1600) && \
-    (!defined(__GNUC__) || \
-      (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 40400))
-  #error A C++11 compatible compiler with support for the auto typing is \
-         required for FlatBuffers.
-  #error __cplusplus _MSC_VER __GNUC__  __GNUC_MINOR__  __GNUC_PATCHLEVEL__
-#endif
-
-#if !defined(__clang__) && \
-    defined(__GNUC__) && \
-    (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 40600)
-  // Backwards compatibility for g++ 4.4, and 4.5 which don't have the nullptr
-  // and constexpr keywords. Note the __clang__ check is needed, because clang
-  // presents itself as an older GNUC compiler.
-  #ifndef nullptr_t
-    const class nullptr_t {
-    public:
-      template<class T> inline operator T*() const { return 0; }
-    private:
-      void operator&() const;
-    } nullptr = {};
-  #endif
-  #ifndef constexpr
-    #define constexpr const
-  #endif
-#endif
-
-// The wire format uses a little endian encoding (since that's efficient for
-// the common platforms).
-#if defined(__s390x__)
-  #define FLATBUFFERS_LITTLEENDIAN 0
-#endif // __s390x__
-#if !defined(FLATBUFFERS_LITTLEENDIAN)
-  #if defined(__GNUC__) || defined(__clang__) || defined(__ICCARM__)
-    #if (defined(__BIG_ENDIAN__) || \
-         (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
-      #define FLATBUFFERS_LITTLEENDIAN 0
-    #else
-      #define FLATBUFFERS_LITTLEENDIAN 1
-    #endif // __BIG_ENDIAN__
-  #elif defined(_MSC_VER)
-    #if defined(_M_PPC)
-      #define FLATBUFFERS_LITTLEENDIAN 0
-    #else
-      #define FLATBUFFERS_LITTLEENDIAN 1
-    #endif
-  #else
-    #error Unable to determine endianness, define FLATBUFFERS_LITTLEENDIAN.
-  #endif
-#endif // !defined(FLATBUFFERS_LITTLEENDIAN)
-
-#define FLATBUFFERS_VERSION_MAJOR 25
-#define FLATBUFFERS_VERSION_MINOR 12
-#define FLATBUFFERS_VERSION_REVISION 19
-#define FLATBUFFERS_STRING_EXPAND(X) #X
-#define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
-namespace flatbuffers {
-  // Returns version as string  "MAJOR.MINOR.REVISION".
-  const char* FLATBUFFERS_VERSION();
-}
-
-#if (!defined(_MSC_VER) || _MSC_VER > 1600) && \
-    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 407)) || \
-    defined(__clang__)
-  #define FLATBUFFERS_FINAL_CLASS final
-  #define FLATBUFFERS_OVERRIDE override
-  #define FLATBUFFERS_EXPLICIT_CPP11 explicit
-  #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE : ::flatbuffers::voffset_t
-#else
-  #define FLATBUFFERS_FINAL_CLASS
-  #define FLATBUFFERS_OVERRIDE
-  #define FLATBUFFERS_EXPLICIT_CPP11
-  #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE
-#endif
-
-#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && \
-    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)) || \
-    (defined(__cpp_constexpr) && __cpp_constexpr >= 200704)
-  #define FLATBUFFERS_CONSTEXPR constexpr
-  #define FLATBUFFERS_CONSTEXPR_CPP11 constexpr
-  #define FLATBUFFERS_CONSTEXPR_DEFINED
-#else
-  #define FLATBUFFERS_CONSTEXPR const
-  #define FLATBUFFERS_CONSTEXPR_CPP11
-#endif
-
-#if (defined(__cplusplus) && __cplusplus >= 201402L) || \
-    (defined(__cpp_constexpr) && __cpp_constexpr >= 201304)
-  #define FLATBUFFERS_CONSTEXPR_CPP14 FLATBUFFERS_CONSTEXPR_CPP11
-#else
-  #define FLATBUFFERS_CONSTEXPR_CPP14
-#endif
-
-#if (defined(__GXX_EXPERIMENTAL_CXX0X__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)) || \
-    (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 190023026)) || \
-    defined(__clang__)
-  #define FLATBUFFERS_NOEXCEPT noexcept
-#else
-  #define FLATBUFFERS_NOEXCEPT
-#endif
-
-// NOTE: the FLATBUFFERS_DELETE_FUNC macro may change the access mode to
-// private, so be sure to put it at the end or reset access mode explicitly.
-#if (!defined(_MSC_VER) || _MSC_FULL_VER >= 180020827) && \
-    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 404)) || \
-    defined(__clang__)
-  #define FLATBUFFERS_DELETE_FUNC(func) func = delete
-#else
-  #define FLATBUFFERS_DELETE_FUNC(func) private: func
-#endif
-
-#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && \
-    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || \
-    defined(__clang__)
-  #define FLATBUFFERS_DEFAULT_DECLARATION
-#endif
-
-// Check if we can use template aliases
-// Not possible if Microsoft Compiler before 2012
-// Possible is the language feature __cpp_alias_templates is defined well
-// Or possible if the C++ std is C+11 or newer
-#if (defined(_MSC_VER) && _MSC_VER > 1700 /* MSVC2012 */) \
-    || (defined(__cpp_alias_templates) && __cpp_alias_templates >= 200704) \
-    || (defined(__cplusplus) && __cplusplus >= 201103L)
-  #define FLATBUFFERS_TEMPLATES_ALIASES
-#endif
-
-#ifndef FLATBUFFERS_HAS_STRING_VIEW
-  // Only provide flatbuffers::string_view if __has_include can be used
-  // to detect a header that provides an implementation
-  #if defined(__has_include)
-    // Check for std::string_view (in c++17)
-    #if __has_include(<string_view>) && (__cplusplus >= 201606 || (defined(_HAS_CXX17) && _HAS_CXX17))
-      #include <string_view>
-      namespace flatbuffers {
-        typedef std::string_view string_view;
-      }
-      #define FLATBUFFERS_HAS_STRING_VIEW 1
-    // Check for std::experimental::string_view (in c++14, compiler-dependent)
-    #elif __has_include(<experimental/string_view>) && (__cplusplus >= 201411)
-      #include <experimental/string_view>
-      namespace flatbuffers {
-        typedef std::experimental::string_view string_view;
-      }
-      #define FLATBUFFERS_HAS_STRING_VIEW 1
-    // Check for absl::string_view
-    #elif __has_include("absl/strings/string_view.h") && \
-          __has_include("absl/base/config.h") && \
-          (__cplusplus >= 201411)
-      #include "absl/base/config.h"
-      #if !defined(ABSL_USES_STD_STRING_VIEW)
-        #include "absl/strings/string_view.h"
-        namespace flatbuffers {
-          typedef absl::string_view string_view;
-        }
-        #define FLATBUFFERS_HAS_STRING_VIEW 1
-      #endif
-    #endif
-  #endif // __has_include
-#endif // !FLATBUFFERS_HAS_STRING_VIEW
-
-#ifndef FLATBUFFERS_GENERAL_HEAP_ALLOC_OK
-  // Allow heap allocations to be used
-  #define FLATBUFFERS_GENERAL_HEAP_ALLOC_OK 1
-#endif // !FLATBUFFERS_GENERAL_HEAP_ALLOC_OK
-
-#ifndef FLATBUFFERS_HAS_NEW_STRTOD
-  // Modern (C++11) strtod and strtof functions are available for use.
-  // 1) nan/inf strings as argument of strtod;
-  // 2) hex-float  as argument of  strtod/strtof.
-  #if (defined(_MSC_VER) && _MSC_VER >= 1900) || \
-      (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || \
-      (defined(__clang__))
-    #define FLATBUFFERS_HAS_NEW_STRTOD 1
-  #endif
-#endif // !FLATBUFFERS_HAS_NEW_STRTOD
-
-#ifndef FLATBUFFERS_LOCALE_INDEPENDENT
-  // Enable locale independent functions {strtof_l, strtod_l,strtoll_l,
-  // strtoull_l} on platforms that support them.
-  #if (defined(_MSC_VER) && _MSC_VER >= 1800) || \
-      (defined(__ANDROID__) && defined(__ANDROID_API__) && __ANDROID_API__>= 26) || \
-      (defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 700)) && \
-      !defined(__Fuchsia__)
-    #define FLATBUFFERS_LOCALE_INDEPENDENT 1
-  #else
-    #define FLATBUFFERS_LOCALE_INDEPENDENT 0
-  #endif
-#endif  // !FLATBUFFERS_LOCALE_INDEPENDENT
-
-// Suppress Undefined Behavior Sanitizer (recoverable only). Usage:
-// - FLATBUFFERS_SUPPRESS_UBSAN("undefined")
-// - FLATBUFFERS_SUPPRESS_UBSAN("signed-integer-overflow")
-#if defined(__clang__) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >=7))
-  #define FLATBUFFERS_SUPPRESS_UBSAN(type) __attribute__((no_sanitize(type)))
-#elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)
-  #define FLATBUFFERS_SUPPRESS_UBSAN(type) __attribute__((no_sanitize_undefined))
-#else
-  #define FLATBUFFERS_SUPPRESS_UBSAN(type)
-#endif
-
-namespace flatbuffers {
-  // This is constexpr function used for checking compile-time constants.
-  // Avoid `#pragma warning(disable: 4127) // C4127: expression is constant`.
-  template<typename T> FLATBUFFERS_CONSTEXPR inline bool IsConstTrue(T t) {
-    return !!t;
-  }
-}
-
-// Enable C++ attribute [[]] if std:c++17 or higher.
-#if ((__cplusplus >= 201703L) \
-    || (defined(_MSVC_LANG) &&  (_MSVC_LANG >= 201703L)))
-  // All attributes unknown to an implementation are ignored without causing an error.
-  #define FLATBUFFERS_ATTRIBUTE(attr) attr
-
-  #define FLATBUFFERS_FALLTHROUGH() [[fallthrough]]
-#else
-  #define FLATBUFFERS_ATTRIBUTE(attr)
-
-  #if FLATBUFFERS_CLANG >= 30800
-    #define FLATBUFFERS_FALLTHROUGH() [[clang::fallthrough]]
-  #elif FLATBUFFERS_GCC >= 70300
-    #define FLATBUFFERS_FALLTHROUGH() [[gnu::fallthrough]]
-  #else
-    #define FLATBUFFERS_FALLTHROUGH()
-  #endif
-#endif
-
-/// @endcond
-
-/// @file
-namespace flatbuffers {
-
-/// @cond FLATBUFFERS_INTERNAL
-// Our default offset / size type, 32bit on purpose on 64bit systems.
-// Also, using a consistent offset type maintains compatibility of serialized
-// offset values between 32bit and 64bit systems.
-typedef uint32_t uoffset_t;
-typedef uint64_t uoffset64_t;
-
-// Signed offsets for references that can go in both directions.
-typedef int32_t soffset_t;
-typedef int64_t soffset64_t;
-
-// Offset/index used in v-tables, can be changed to uint8_t in
-// format forks to save a bit of space if desired.
-typedef uint16_t voffset_t;
-
-typedef uintmax_t largest_scalar_t;
-
-// In 32bits, this evaluates to 2GB - 1
-#define FLATBUFFERS_MAX_BUFFER_SIZE (std::numeric_limits<::flatbuffers::soffset_t>::max)()
-#define FLATBUFFERS_MAX_64_BUFFER_SIZE (std::numeric_limits<::flatbuffers::soffset64_t>::max)()
-
-// The minimum size buffer that can be a valid flatbuffer.
-// Includes the offset to the root table (uoffset_t), the offset to the vtable
-// of the root table (soffset_t), the size of the vtable (uint16_t), and the
-// size of the referring table (uint16_t).
-#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(::flatbuffers::uoffset_t) + \
-  sizeof(::flatbuffers::soffset_t) + sizeof(uint16_t) + sizeof(uint16_t)
-
-// We support aligning the contents of buffers up to this size.
-#ifndef FLATBUFFERS_MAX_ALIGNMENT
-  #define FLATBUFFERS_MAX_ALIGNMENT 32
-#endif
-
-/// @brief The length of a FlatBuffer file header.
-static const size_t kFileIdentifierLength = 4;
-
-inline bool VerifyAlignmentRequirements(size_t align, size_t min_align = 1) {
-  return (min_align <= align) && (align <= (FLATBUFFERS_MAX_ALIGNMENT)) &&
-         (align & (align - 1)) == 0;  // must be power of 2
-}
-
-#if defined(_MSC_VER)
-  #pragma warning(push)
-  #pragma warning(disable: 4127) // C4127: conditional expression is constant
-#endif
-
-template<typename T> T EndianSwap(T t) {
-  #if defined(_MSC_VER)
-    #define FLATBUFFERS_BYTESWAP16 _byteswap_ushort
-    #define FLATBUFFERS_BYTESWAP32 _byteswap_ulong
-    #define FLATBUFFERS_BYTESWAP64 _byteswap_uint64
-  #elif defined(__ICCARM__)
-    #define FLATBUFFERS_BYTESWAP16 __REV16
-    #define FLATBUFFERS_BYTESWAP32 __REV
-    #define FLATBUFFERS_BYTESWAP64(x) \
-       ((__REV(static_cast<uint32_t>(x >> 32U))) | (static_cast<uint64_t>(__REV(static_cast<uint32_t>(x)))) << 32U)
-  #else
-    #if defined(__GNUC__) && __GNUC__ * 100 + __GNUC_MINOR__ < 408 && !defined(__clang__)
-      // __builtin_bswap16 was missing prior to GCC 4.8.
-      #define FLATBUFFERS_BYTESWAP16(x) \
-        static_cast<uint16_t>(__builtin_bswap32(static_cast<uint32_t>(x) << 16))
-    #else
-      #define FLATBUFFERS_BYTESWAP16 __builtin_bswap16
-    #endif
-    #define FLATBUFFERS_BYTESWAP32 __builtin_bswap32
-    #define FLATBUFFERS_BYTESWAP64 __builtin_bswap64
-  #endif
-  if (sizeof(T) == 1) {   // Compile-time if-then's.
-    return t;
-  } else if (sizeof(T) == 2) {
-    union { T t; uint16_t i; } u = { t };
-    u.i = FLATBUFFERS_BYTESWAP16(u.i);
-    return u.t;
-  } else if (sizeof(T) == 4) {
-    union { T t; uint32_t i; } u = { t };
-    u.i = FLATBUFFERS_BYTESWAP32(u.i);
-    return u.t;
-  } else if (sizeof(T) == 8) {
-    union { T t; uint64_t i; } u = { t };
-    u.i = FLATBUFFERS_BYTESWAP64(u.i);
-    return u.t;
-  } else {
-    FLATBUFFERS_ASSERT(0);
-    return t;
-  }
-}
-
-#if defined(_MSC_VER)
-  #pragma warning(pop)
-#endif
-
-
-template<typename T> T EndianScalar(T t) {
-  #if FLATBUFFERS_LITTLEENDIAN
-    return t;
-  #else
-    return EndianSwap(t);
-  #endif
-}
-
-template<typename T>
-// UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
-FLATBUFFERS_SUPPRESS_UBSAN("alignment")
-T ReadScalar(const void *p) {
-  return EndianScalar(*reinterpret_cast<const T *>(p));
-}
-
-// See https://github.com/google/flatbuffers/issues/5950
-
-#if (FLATBUFFERS_GCC >= 100000) && (FLATBUFFERS_GCC < 110000)
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-
-template<typename T>
-// UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
-FLATBUFFERS_SUPPRESS_UBSAN("alignment")
-void WriteScalar(void *p, T t) {
-  *reinterpret_cast<T *>(p) = EndianScalar(t);
-}
-
-template<typename T> struct Offset;
-template<typename T> FLATBUFFERS_SUPPRESS_UBSAN("alignment") void WriteScalar(void *p, Offset<T> t) {
-  *reinterpret_cast<uoffset_t *>(p) = EndianScalar(t.o);
-}
-
-#if (FLATBUFFERS_GCC >= 100000) && (FLATBUFFERS_GCC < 110000)
-  #pragma GCC diagnostic pop
-#endif
-
-// Computes how many bytes you'd have to pad to be able to write an
-// "scalar_size" scalar if the buffer had grown to "buf_size" (downwards in
-// memory).
-FLATBUFFERS_SUPPRESS_UBSAN("unsigned-integer-overflow")
-inline size_t PaddingBytes(size_t buf_size, size_t scalar_size) {
-  return ((~buf_size) + 1) & (scalar_size - 1);
-}
-
-#if !defined(_MSC_VER)
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-// Generic 'operator==' with conditional specialisations.
-// T e - new value of a scalar field.
-// T def - default of scalar (is known at compile-time).
-template<typename T> inline bool IsTheSameAs(T e, T def) { return e == def; }
-#if !defined(_MSC_VER)
-  #pragma GCC diagnostic pop
-#endif
-
-#if defined(FLATBUFFERS_NAN_DEFAULTS) && \
-    defined(FLATBUFFERS_HAS_NEW_STRTOD) && (FLATBUFFERS_HAS_NEW_STRTOD > 0)
-// Like `operator==(e, def)` with weak NaN if T=(float|double).
-template<typename T> inline bool IsFloatTheSameAs(T e, T def) {
-  return (e == def) || ((def != def) && (e != e));
-}
-template<> inline bool IsTheSameAs<float>(float e, float def) {
-  return IsFloatTheSameAs(e, def);
-}
-template<> inline bool IsTheSameAs<double>(double e, double def) {
-  return IsFloatTheSameAs(e, def);
-}
-#endif
-
-// Check 'v' is out of closed range [low; high].
-// Workaround for GCC warning [-Werror=type-limits]:
-// comparison is always true due to limited range of data type.
-template<typename T>
-inline bool IsOutRange(const T &v, const T &low, const T &high) {
-  return (v < low) || (high < v);
-}
-
-// Check 'v' is in closed range [low; high].
-template<typename T>
-inline bool IsInRange(const T &v, const T &low, const T &high) {
-  return !IsOutRange(v, low, high);
-}
-
-}  // namespace flatbuffers
-#endif  // FLATBUFFERS_BASE_H_
diff --git a/external/flatbuffers/include/flatbuffers/buffer.h b/external/flatbuffers/include/flatbuffers/buffer.h
deleted file mode 100644
index 154d187a..00000000
--- a/external/flatbuffers/include/flatbuffers/buffer.h
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_BUFFER_H_
-#define FLATBUFFERS_BUFFER_H_
-
-#include <algorithm>
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/stl_emulation.h"
-
-namespace flatbuffers {
-
-// Wrapper for uoffset_t to allow safe template specialization.
-// Value is allowed to be 0 to indicate a null object (see e.g. AddOffset).
-template <typename T = void>
-struct Offset {
-  // The type of offset to use.
-  typedef uoffset_t offset_type;
-
-  offset_type o;
-  Offset() : o(0) {}
-  Offset(const offset_type _o) : o(_o) {}
-  Offset<> Union() const { return o; }
-  bool IsNull() const { return !o; }
-};
-
-template <typename T>
-struct is_specialisation_of_Offset : false_type {};
-template <typename T>
-struct is_specialisation_of_Offset<Offset<T>> : true_type {};
-
-// Wrapper for uoffset64_t Offsets.
-template <typename T = void>
-struct Offset64 {
-  // The type of offset to use.
-  typedef uoffset64_t offset_type;
-
-  offset_type o;
-  Offset64() : o(0) {}
-  Offset64(const offset_type offset) : o(offset) {}
-  Offset64<> Union() const { return o; }
-  bool IsNull() const { return !o; }
-};
-
-template <typename T>
-struct is_specialisation_of_Offset64 : false_type {};
-template <typename T>
-struct is_specialisation_of_Offset64<Offset64<T>> : true_type {};
-
-// Litmus check for ensuring the Offsets are the expected size.
-static_assert(sizeof(Offset<>) == 4, "Offset has wrong size");
-static_assert(sizeof(Offset64<>) == 8, "Offset64 has wrong size");
-
-inline void EndianCheck() {
-  int endiantest = 1;
-  // If this fails, see FLATBUFFERS_LITTLEENDIAN above.
-  FLATBUFFERS_ASSERT(*reinterpret_cast<char*>(&endiantest) ==
-                     FLATBUFFERS_LITTLEENDIAN);
-  (void)endiantest;
-}
-
-template <typename T>
-FLATBUFFERS_CONSTEXPR size_t AlignOf() {
-  // clang-format off
-  #ifdef _MSC_VER
-    return __alignof(T);
-  #else
-    #ifndef alignof
-      return __alignof__(T);
-    #else
-      return alignof(T);
-    #endif
-  #endif
-  // clang-format on
-}
-
-// Lexicographically compare two strings (possibly containing nulls), and
-// return true if the first is less than the second.
-static inline bool StringLessThan(const char* a_data, uoffset_t a_size,
-                                  const char* b_data, uoffset_t b_size) {
-  const auto cmp = memcmp(a_data, b_data, (std::min)(a_size, b_size));
-  return cmp == 0 ? a_size < b_size : cmp < 0;
-}
-
-// When we read serialized data from memory, in the case of most scalars,
-// we want to just read T, but in the case of Offset, we want to actually
-// perform the indirection and return a pointer.
-// The template specialization below does just that.
-// It is wrapped in a struct since function templates can't overload on the
-// return type like this.
-// The typedef is for the convenience of callers of this function
-// (avoiding the need for a trailing return decltype)
-template <typename T, typename Enable = void>
-struct IndirectHelper {
-  typedef T return_type;
-  typedef T mutable_return_type;
-  static const size_t element_stride = sizeof(T);
-
-  static return_type Read(const uint8_t* p, const size_t i) {
-    return EndianScalar((reinterpret_cast<const T*>(p))[i]);
-  }
-  static mutable_return_type Read(uint8_t* p, const size_t i) {
-    return reinterpret_cast<mutable_return_type>(
-        Read(const_cast<const uint8_t*>(p), i));
-  }
-};
-
-// For vector of Offsets.
-template <typename T, template <typename> class OffsetT>
-struct IndirectHelper<OffsetT<T>> {
-  typedef const T* return_type;
-  typedef T* mutable_return_type;
-  typedef typename OffsetT<T>::offset_type offset_type;
-  static const offset_type element_stride = sizeof(offset_type);
-
-  static return_type Read(const uint8_t* const p, const offset_type i) {
-    // Offsets are relative to themselves, so first update the pointer to
-    // point to the offset location.
-    const uint8_t* const offset_location = p + i * element_stride;
-
-    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
-    // then determine the relative location from the offset location.
-    return reinterpret_cast<return_type>(
-        offset_location + ReadScalar<offset_type>(offset_location));
-  }
-  static mutable_return_type Read(uint8_t* const p, const offset_type i) {
-    // Offsets are relative to themselves, so first update the pointer to
-    // point to the offset location.
-    uint8_t* const offset_location = p + i * element_stride;
-
-    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
-    // then determine the relative location from the offset location.
-    return reinterpret_cast<mutable_return_type>(
-        offset_location + ReadScalar<offset_type>(offset_location));
-  }
-};
-
-// For vector of structs.
-template <typename T>
-struct IndirectHelper<
-    T, typename std::enable_if<
-           !std::is_scalar<typename std::remove_pointer<T>::type>::value &&
-           !is_specialisation_of_Offset<T>::value &&
-           !is_specialisation_of_Offset64<T>::value>::type> {
- private:
-  typedef typename std::remove_pointer<typename std::remove_cv<T>::type>::type
-      pointee_type;
-
- public:
-  typedef const pointee_type* return_type;
-  typedef pointee_type* mutable_return_type;
-  static const size_t element_stride = sizeof(pointee_type);
-
-  static return_type Read(const uint8_t* const p, const size_t i) {
-    // Structs are stored inline, relative to the first struct pointer.
-    return reinterpret_cast<return_type>(p + i * element_stride);
-  }
-  static mutable_return_type Read(uint8_t* const p, const size_t i) {
-    // Structs are stored inline, relative to the first struct pointer.
-    return reinterpret_cast<mutable_return_type>(p + i * element_stride);
-  }
-};
-
-/// @brief Get a pointer to the file_identifier section of the buffer.
-/// @return Returns a const char pointer to the start of the file_identifier
-/// characters in the buffer.  The returned char * has length
-/// 'flatbuffers::FlatBufferBuilder::kFileIdentifierLength'.
-/// This function is UNDEFINED for FlatBuffers whose schema does not include
-/// a file_identifier (likely points at padding or the start of a the root
-/// vtable).
-inline const char* GetBufferIdentifier(const void* buf,
-                                       bool size_prefixed = false) {
-  return reinterpret_cast<const char*>(buf) +
-         ((size_prefixed) ? 2 * sizeof(uoffset_t) : sizeof(uoffset_t));
-}
-
-// Helper to see if the identifier in a buffer has the expected value.
-inline bool BufferHasIdentifier(const void* buf, const char* identifier,
-                                bool size_prefixed = false) {
-  return strncmp(GetBufferIdentifier(buf, size_prefixed), identifier,
-                 flatbuffers::kFileIdentifierLength) == 0;
-}
-
-/// @cond FLATBUFFERS_INTERNAL
-// Helpers to get a typed pointer to the root object contained in the buffer.
-template <typename T>
-T* GetMutableRoot(void* buf) {
-  if (!buf) return nullptr;
-  EndianCheck();
-  return reinterpret_cast<T*>(reinterpret_cast<uint8_t*>(buf) +
-                              EndianScalar(*reinterpret_cast<uoffset_t*>(buf)));
-}
-
-template <typename T, typename SizeT = uoffset_t>
-T* GetMutableSizePrefixedRoot(void* buf) {
-  return GetMutableRoot<T>(reinterpret_cast<uint8_t*>(buf) + sizeof(SizeT));
-}
-
-template <typename T>
-const T* GetRoot(const void* buf) {
-  return GetMutableRoot<T>(const_cast<void*>(buf));
-}
-
-template <typename T, typename SizeT = uoffset_t>
-const T* GetSizePrefixedRoot(const void* buf) {
-  return GetRoot<T>(reinterpret_cast<const uint8_t*>(buf) + sizeof(SizeT));
-}
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_BUFFER_H_
diff --git a/external/flatbuffers/include/flatbuffers/buffer_ref.h b/external/flatbuffers/include/flatbuffers/buffer_ref.h
deleted file mode 100644
index 746903eb..00000000
--- a/external/flatbuffers/include/flatbuffers/buffer_ref.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_BUFFER_REF_H_
-#define FLATBUFFERS_BUFFER_REF_H_
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/verifier.h"
-
-namespace flatbuffers {
-
-// Convenient way to bundle a buffer and its length, to pass it around
-// typed by its root.
-// A BufferRef does not own its buffer.
-struct BufferRefBase {};  // for std::is_base_of
-
-template <typename T>
-struct BufferRef : BufferRefBase {
-  BufferRef() : buf(nullptr), len(0), must_free(false) {}
-  BufferRef(uint8_t* _buf, uoffset_t _len)
-      : buf(_buf), len(_len), must_free(false) {}
-
-  ~BufferRef() {
-    if (must_free) free(buf);
-  }
-
-  const T* GetRoot() const { return flatbuffers::GetRoot<T>(buf); }
-
-  bool Verify() {
-    Verifier verifier(buf, len);
-    return verifier.VerifyBuffer<T>(nullptr);
-  }
-
-  uint8_t* buf;
-  uoffset_t len;
-  bool must_free;
-};
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_BUFFER_REF_H_
diff --git a/external/flatbuffers/include/flatbuffers/code_generator.h b/external/flatbuffers/include/flatbuffers/code_generator.h
deleted file mode 100644
index bfd771da..00000000
--- a/external/flatbuffers/include/flatbuffers/code_generator.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 2023 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_CODE_GENERATOR_H_
-#define FLATBUFFERS_CODE_GENERATOR_H_
-
-#include <string>
-
-#include "flatbuffers/file_manager.h"
-#include "flatbuffers/idl.h"
-
-namespace flatbuffers {
-
-struct CodeGenOptions {
-  std::string output_path;
-  FileSaver* file_saver{nullptr};
-};
-
-// A code generator interface for producing converting flatbuffer schema into
-// code.
-class CodeGenerator {
- public:
-  virtual ~CodeGenerator() = default;
-
-  enum Status {
-    OK = 0,
-    ERROR = 1,
-    FAILED_VERIFICATION = 2,
-    NOT_IMPLEMENTED = 3
-  };
-
-  std::string status_detail;
-
-  // Generate code from the provided `parser`.
-  //
-  // DEPRECATED: prefer using the other overload of GenerateCode for bfbs.
-  virtual Status GenerateCode(const Parser& parser, const std::string& path,
-                              const std::string& filename) = 0;
-
-  // Generate code from the provided `parser` and place it in the output.
-  virtual Status GenerateCodeString(const Parser& parser,
-                                    const std::string& filename,
-                                    std::string& output) {
-    (void)parser;
-    (void)filename;
-    (void)output;
-    return Status::NOT_IMPLEMENTED;
-  }
-
-  // Generate code from the provided `buffer` of given `length`. The buffer is a
-  // serialized reflection.fbs.
-  virtual Status GenerateCode(const uint8_t* buffer, int64_t length,
-                              const CodeGenOptions& options) = 0;
-
-  virtual Status GenerateMakeRule(const Parser& parser, const std::string& path,
-                                  const std::string& filename,
-                                  std::string& output) = 0;
-
-  virtual Status GenerateGrpcCode(const Parser& parser, const std::string& path,
-                                  const std::string& filename) = 0;
-
-  virtual Status GenerateRootFile(const Parser& parser,
-                                  const std::string& path) = 0;
-
-  virtual bool IsSchemaOnly() const = 0;
-
-  virtual bool SupportsBfbsGeneration() const = 0;
-
-  virtual bool SupportsRootFileGeneration() const = 0;
-
-  virtual IDLOptions::Language Language() const = 0;
-
-  virtual std::string LanguageName() const = 0;
-
- protected:
-  CodeGenerator() = default;
-
- private:
-  // Copying is not supported.
-  CodeGenerator(const CodeGenerator&) = delete;
-  CodeGenerator& operator=(const CodeGenerator&) = delete;
-};
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_CODE_GENERATOR_H_
diff --git a/external/flatbuffers/include/flatbuffers/code_generators.h b/external/flatbuffers/include/flatbuffers/code_generators.h
deleted file mode 100644
index d284ac5a..00000000
--- a/external/flatbuffers/include/flatbuffers/code_generators.h
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- * Copyright 2014 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_CODE_GENERATORS_H_
-#define FLATBUFFERS_CODE_GENERATORS_H_
-
-#include <map>
-#include <sstream>
-
-#include "flatbuffers/idl.h"
-
-namespace flatbuffers {
-
-// Utility class to assist in generating code through use of text templates.
-//
-// Example code:
-//   CodeWriter code("\t");
-//   code.SetValue("NAME", "Foo");
-//   code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
-//   code.SetValue("NAME", "Bar");
-//   code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
-//   std::cout << code.ToString() << std::endl;
-//
-// Output:
-//  void Foo() { printf("%s", "Foo"); }
-//  void Bar() { printf("%s", "Bar"); }
-class CodeWriter {
- public:
-  CodeWriter(std::string pad = std::string())
-      : pad_(pad), cur_ident_lvl_(0), ignore_ident_(false) {}
-
-  // Clears the current "written" code.
-  void Clear() {
-    stream_.str("");
-    stream_.clear();
-  }
-
-  // Associates a key with a value.  All subsequent calls to operator+=, where
-  // the specified key is contained in {{ and }} delimiters will be replaced by
-  // the given value.
-  void SetValue(const std::string& key, const std::string& value) {
-    value_map_[key] = value;
-  }
-
-  std::string GetValue(const std::string& key) const {
-    const auto it = value_map_.find(key);
-    return it == value_map_.end() ? "" : it->second;
-  }
-
-  // Appends the given text to the generated code as well as a newline
-  // character.  Any text within {{ and }} delimiters is replaced by values
-  // previously stored in the CodeWriter by calling SetValue above.  The newline
-  // will be suppressed if the text ends with the \\ character.
-  void operator+=(std::string text);
-
-  // Returns the current contents of the CodeWriter as a std::string.
-  std::string ToString() const { return stream_.str(); }
-
-  // Increase ident level for writing code
-  void IncrementIdentLevel() { cur_ident_lvl_++; }
-  // Decrease ident level for writing code
-  void DecrementIdentLevel() {
-    if (cur_ident_lvl_) cur_ident_lvl_--;
-  }
-
-  void SetPadding(const std::string& padding) { pad_ = padding; }
-
- private:
-  std::map<std::string, std::string> value_map_;
-  std::stringstream stream_;
-  std::string pad_;
-  int cur_ident_lvl_;
-  bool ignore_ident_;
-
-  // Add ident padding (tab or space) based on ident level
-  void AppendIdent(std::stringstream& stream);
-};
-
-class BaseGenerator {
- public:
-  virtual bool generate() = 0;
-
-  static std::string NamespaceDir(const Parser& parser, const std::string& path,
-                                  const Namespace& ns,
-                                  const bool dasherize = false);
-
-  std::string GeneratedFileName(const std::string& path,
-                                const std::string& file_name,
-                                const IDLOptions& options) const;
-
- protected:
-  BaseGenerator(const Parser& parser, const std::string& path,
-                const std::string& file_name, std::string qualifying_start,
-                std::string qualifying_separator, std::string default_extension)
-      : parser_(parser),
-        path_(path),
-        file_name_(file_name),
-        qualifying_start_(qualifying_start),
-        qualifying_separator_(qualifying_separator),
-        default_extension_(default_extension) {}
-  virtual ~BaseGenerator() {}
-
-  // No copy/assign.
-  BaseGenerator& operator=(const BaseGenerator&);
-  BaseGenerator(const BaseGenerator&);
-
-  std::string NamespaceDir(const Namespace& ns,
-                           const bool dasherize = false) const;
-
-  static const char* FlatBuffersGeneratedWarning();
-
-  static std::string FullNamespace(const char* separator, const Namespace& ns);
-
-  static std::string LastNamespacePart(const Namespace& ns);
-
-  // tracks the current namespace for early exit in WrapInNameSpace
-  // c++, java and csharp returns a different namespace from
-  // the following default (no early exit, always fully qualify),
-  // which works for js and php
-  virtual const Namespace* CurrentNameSpace() const { return nullptr; }
-
-  // Ensure that a type is prefixed with its namespace even within
-  // its own namespace to avoid conflict between generated method
-  // names and similarly named classes or structs
-  std::string WrapInNameSpace(const Namespace* ns,
-                              const std::string& name) const;
-
-  std::string WrapInNameSpace(const Definition& def,
-                              const std::string& suffix = "") const;
-
-  std::string GetNameSpace(const Definition& def) const;
-
-  const Parser& parser_;
-  const std::string& path_;
-  const std::string& file_name_;
-  const std::string qualifying_start_;
-  const std::string qualifying_separator_;
-  const std::string default_extension_;
-};
-
-struct CommentConfig {
-  const char* first_line;
-  const char* content_line_prefix;
-  const char* last_line;
-};
-
-extern void GenComment(const std::vector<std::string>& dc,
-                       std::string* code_ptr, const CommentConfig* config,
-                       const char* prefix = "");
-
-class FloatConstantGenerator {
- public:
-  virtual ~FloatConstantGenerator() {}
-  std::string GenFloatConstant(const FieldDef& field) const;
-
- private:
-  virtual std::string Value(double v, const std::string& src) const = 0;
-  virtual std::string Inf(double v) const = 0;
-  virtual std::string NaN(double v) const = 0;
-
-  virtual std::string Value(float v, const std::string& src) const = 0;
-  virtual std::string Inf(float v) const = 0;
-  virtual std::string NaN(float v) const = 0;
-
-  template <typename T>
-  std::string GenFloatConstantImpl(const FieldDef& field) const;
-};
-
-class SimpleFloatConstantGenerator : public FloatConstantGenerator {
- public:
-  SimpleFloatConstantGenerator(const char* nan_number,
-                               const char* pos_inf_number,
-                               const char* neg_inf_number);
-
- private:
-  std::string Value(double v,
-                    const std::string& src) const FLATBUFFERS_OVERRIDE;
-  std::string Inf(double v) const FLATBUFFERS_OVERRIDE;
-  std::string NaN(double v) const FLATBUFFERS_OVERRIDE;
-
-  std::string Value(float v, const std::string& src) const FLATBUFFERS_OVERRIDE;
-  std::string Inf(float v) const FLATBUFFERS_OVERRIDE;
-  std::string NaN(float v) const FLATBUFFERS_OVERRIDE;
-
-  const std::string nan_number_;
-  const std::string pos_inf_number_;
-  const std::string neg_inf_number_;
-};
-
-// C++, C#, Java like generator.
-class TypedFloatConstantGenerator : public FloatConstantGenerator {
- public:
-  TypedFloatConstantGenerator(const char* double_prefix,
-                              const char* single_prefix, const char* nan_number,
-                              const char* pos_inf_number,
-                              const char* neg_inf_number = "");
-
- private:
-  std::string Value(double v,
-                    const std::string& src) const FLATBUFFERS_OVERRIDE;
-  std::string Inf(double v) const FLATBUFFERS_OVERRIDE;
-
-  std::string NaN(double v) const FLATBUFFERS_OVERRIDE;
-
-  std::string Value(float v, const std::string& src) const FLATBUFFERS_OVERRIDE;
-  std::string Inf(float v) const FLATBUFFERS_OVERRIDE;
-  std::string NaN(float v) const FLATBUFFERS_OVERRIDE;
-
-  std::string MakeNaN(const std::string& prefix) const;
-  std::string MakeInf(bool neg, const std::string& prefix) const;
-
-  const std::string double_prefix_;
-  const std::string single_prefix_;
-  const std::string nan_number_;
-  const std::string pos_inf_number_;
-  const std::string neg_inf_number_;
-};
-
-std::string JavaCSharpMakeRule(const bool java, const Parser& parser,
-                               const std::string& path,
-                               const std::string& file_name);
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_CODE_GENERATORS_H_
diff --git a/external/flatbuffers/include/flatbuffers/default_allocator.h b/external/flatbuffers/include/flatbuffers/default_allocator.h
deleted file mode 100644
index d1cab08d..00000000
--- a/external/flatbuffers/include/flatbuffers/default_allocator.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_DEFAULT_ALLOCATOR_H_
-#define FLATBUFFERS_DEFAULT_ALLOCATOR_H_
-
-#include "flatbuffers/allocator.h"
-#include "flatbuffers/base.h"
-
-namespace flatbuffers {
-
-// DefaultAllocator uses new/delete to allocate memory regions
-class DefaultAllocator : public Allocator {
- public:
-  uint8_t* allocate(size_t size) FLATBUFFERS_OVERRIDE {
-    return new uint8_t[size];
-  }
-
-  void deallocate(uint8_t* p, size_t) FLATBUFFERS_OVERRIDE { delete[] p; }
-
-  static void dealloc(void* p, size_t) { delete[] static_cast<uint8_t*>(p); }
-};
-
-// These functions allow for a null allocator to mean use the default allocator,
-// as used by DetachedBuffer and vector_downward below.
-// This is to avoid having a statically or dynamically allocated default
-// allocator, or having to move it between the classes that may own it.
-inline uint8_t* Allocate(Allocator* allocator, size_t size) {
-  return allocator ? allocator->allocate(size)
-                   : DefaultAllocator().allocate(size);
-}
-
-inline void Deallocate(Allocator* allocator, uint8_t* p, size_t size) {
-  if (allocator)
-    allocator->deallocate(p, size);
-  else
-    DefaultAllocator().deallocate(p, size);
-}
-
-inline uint8_t* ReallocateDownward(Allocator* allocator, uint8_t* old_p,
-                                   size_t old_size, size_t new_size,
-                                   size_t in_use_back, size_t in_use_front) {
-  return allocator ? allocator->reallocate_downward(old_p, old_size, new_size,
-                                                    in_use_back, in_use_front)
-                   : DefaultAllocator().reallocate_downward(
-                         old_p, old_size, new_size, in_use_back, in_use_front);
-}
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_DEFAULT_ALLOCATOR_H_
diff --git a/external/flatbuffers/include/flatbuffers/detached_buffer.h b/external/flatbuffers/include/flatbuffers/detached_buffer.h
deleted file mode 100644
index 0577a42d..00000000
--- a/external/flatbuffers/include/flatbuffers/detached_buffer.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_DETACHED_BUFFER_H_
-#define FLATBUFFERS_DETACHED_BUFFER_H_
-
-#include "flatbuffers/allocator.h"
-#include "flatbuffers/base.h"
-#include "flatbuffers/default_allocator.h"
-
-namespace flatbuffers {
-
-// DetachedBuffer is a finished flatbuffer memory region, detached from its
-// builder. The original memory region and allocator are also stored so that
-// the DetachedBuffer can manage the memory lifetime.
-class DetachedBuffer {
- public:
-  DetachedBuffer()
-      : allocator_(nullptr),
-        own_allocator_(false),
-        buf_(nullptr),
-        reserved_(0),
-        cur_(nullptr),
-        size_(0) {}
-
-  DetachedBuffer(Allocator* allocator, bool own_allocator, uint8_t* buf,
-                 size_t reserved, uint8_t* cur, size_t sz)
-      : allocator_(allocator),
-        own_allocator_(own_allocator),
-        buf_(buf),
-        reserved_(reserved),
-        cur_(cur),
-        size_(sz) {}
-
-  DetachedBuffer(DetachedBuffer&& other) noexcept
-      : allocator_(other.allocator_),
-        own_allocator_(other.own_allocator_),
-        buf_(other.buf_),
-        reserved_(other.reserved_),
-        cur_(other.cur_),
-        size_(other.size_) {
-    other.reset();
-  }
-
-  DetachedBuffer& operator=(DetachedBuffer&& other) noexcept {
-    if (this == &other) return *this;
-
-    destroy();
-
-    allocator_ = other.allocator_;
-    own_allocator_ = other.own_allocator_;
-    buf_ = other.buf_;
-    reserved_ = other.reserved_;
-    cur_ = other.cur_;
-    size_ = other.size_;
-
-    other.reset();
-
-    return *this;
-  }
-
-  ~DetachedBuffer() { destroy(); }
-
-  const uint8_t* data() const { return cur_; }
-
-  uint8_t* data() { return cur_; }
-
-  size_t size() const { return size_; }
-
-  uint8_t* begin() { return data(); }
-  const uint8_t* begin() const { return data(); }
-  uint8_t* end() { return data() + size(); }
-  const uint8_t* end() const { return data() + size(); }
-
-  // These may change access mode, leave these at end of public section
-  FLATBUFFERS_DELETE_FUNC(DetachedBuffer(const DetachedBuffer& other));
-  FLATBUFFERS_DELETE_FUNC(
-      DetachedBuffer& operator=(const DetachedBuffer& other));
-
- protected:
-  Allocator* allocator_;
-  bool own_allocator_;
-  uint8_t* buf_;
-  size_t reserved_;
-  uint8_t* cur_;
-  size_t size_;
-
-  inline void destroy() {
-    if (buf_) Deallocate(allocator_, buf_, reserved_);
-    if (own_allocator_ && allocator_) {
-      delete allocator_;
-    }
-    reset();
-  }
-
-  inline void reset() {
-    allocator_ = nullptr;
-    own_allocator_ = false;
-    buf_ = nullptr;
-    reserved_ = 0;
-    cur_ = nullptr;
-    size_ = 0;
-  }
-};
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_DETACHED_BUFFER_H_
diff --git a/external/flatbuffers/include/flatbuffers/file_manager.h b/external/flatbuffers/include/flatbuffers/file_manager.h
deleted file mode 100644
index bafe6f29..00000000
--- a/external/flatbuffers/include/flatbuffers/file_manager.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright 2023 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_FILE_MANAGER_H_
-#define FLATBUFFERS_FILE_MANAGER_H_
-
-#include <cstddef>
-#include <set>
-#include <string>
-
-namespace flatbuffers {
-
-// A File interface to write data to file by default or
-// save only file names
-class FileSaver {
- public:
-  FileSaver() = default;
-  virtual ~FileSaver() = default;
-
-  virtual bool SaveFile(const char* name, const char* buf, size_t len,
-                        bool binary) = 0;
-
-  bool SaveFile(const char* name, const std::string& buf, bool binary) {
-    return SaveFile(name, buf.c_str(), buf.size(), binary);
-  }
-
-  virtual void Finish() {}
-
- private:
-  // Copying is not supported.
-  FileSaver(const FileSaver&) = delete;
-  FileSaver& operator=(const FileSaver&) = delete;
-  // Rule of 5
-  FileSaver(FileSaver&&) = default;
-  FileSaver& operator=(FileSaver&&) = default;
-};
-
-class RealFileSaver final : public FileSaver {
- public:
-  bool SaveFile(const char* name, const char* buf, size_t len,
-                bool binary) final;
-};
-
-class FileNameSaver final : public FileSaver {
- public:
-  bool SaveFile(const char* name, const char* buf, size_t len,
-                bool binary) final;
-
-  void Finish() final;
-
- private:
-  std::set<std::string> file_names_{};
-};
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_FILE_MANAGER_H_
diff --git a/external/flatbuffers/include/flatbuffers/flatbuffer_builder.h b/external/flatbuffers/include/flatbuffers/flatbuffer_builder.h
deleted file mode 100644
index 636d3776..00000000
--- a/external/flatbuffers/include/flatbuffers/flatbuffer_builder.h
+++ /dev/null
@@ -1,1518 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_FLATBUFFER_BUILDER_H_
-#define FLATBUFFERS_FLATBUFFER_BUILDER_H_
-
-#include <algorithm>
-#include <cstdint>
-#include <functional>
-#include <initializer_list>
-#include <type_traits>
-
-#include "flatbuffers/allocator.h"
-#include "flatbuffers/array.h"
-#include "flatbuffers/base.h"
-#include "flatbuffers/buffer.h"
-#include "flatbuffers/buffer_ref.h"
-#include "flatbuffers/default_allocator.h"
-#include "flatbuffers/detached_buffer.h"
-#include "flatbuffers/stl_emulation.h"
-#include "flatbuffers/string.h"
-#include "flatbuffers/struct.h"
-#include "flatbuffers/table.h"
-#include "flatbuffers/vector.h"
-#include "flatbuffers/vector_downward.h"
-#include "flatbuffers/verifier.h"
-
-namespace flatbuffers {
-
-// Converts a Field ID to a virtual table offset.
-inline voffset_t FieldIndexToOffset(voffset_t field_id) {
-  // Should correspond to what EndTable() below builds up.
-  const voffset_t fixed_fields =
-      2 * sizeof(voffset_t);  // Vtable size and Object Size.
-  size_t offset = fixed_fields + field_id * sizeof(voffset_t);
-  FLATBUFFERS_ASSERT(offset < std::numeric_limits<voffset_t>::max());
-  return static_cast<voffset_t>(offset);
-}
-
-template <typename T, typename Alloc = std::allocator<T>>
-const T* data(const std::vector<T, Alloc>& v) {
-  // Eventually the returned pointer gets passed down to memcpy, so
-  // we need it to be non-null to avoid undefined behavior.
-  static uint8_t t;
-  return v.empty() ? reinterpret_cast<const T*>(&t) : &v.front();
-}
-template <typename T, typename Alloc = std::allocator<T>>
-T* data(std::vector<T, Alloc>& v) {
-  // Eventually the returned pointer gets passed down to memcpy, so
-  // we need it to be non-null to avoid undefined behavior.
-  static uint8_t t;
-  return v.empty() ? reinterpret_cast<T*>(&t) : &v.front();
-}
-
-/// @addtogroup flatbuffers_cpp_api
-/// @{
-/// @class FlatBufferBuilder
-/// @brief Helper class to hold data needed in creation of a FlatBuffer.
-/// To serialize data, you typically call one of the `Create*()` functions in
-/// the generated code, which in turn call a sequence of `StartTable`/
-/// `PushElement`/`AddElement`/`EndTable`, or the builtin `CreateString`/
-/// `CreateVector` functions. Do this is depth-first order to build up a tree to
-/// the root. `Finish()` wraps up the buffer ready for transport.
-template <bool Is64Aware = false>
-class FlatBufferBuilderImpl {
- public:
-  // This switches the size type of the builder, based on if its 64-bit aware
-  // (uoffset64_t) or not (uoffset_t).
-  typedef
-      typename std::conditional<Is64Aware, uoffset64_t, uoffset_t>::type SizeT;
-
-  /// @brief Default constructor for FlatBufferBuilder.
-  /// @param[in] initial_size The initial size of the buffer, in bytes. Defaults
-  /// to `1024`.
-  /// @param[in] allocator An `Allocator` to use. If null will use
-  /// `DefaultAllocator`.
-  /// @param[in] own_allocator Whether the builder/vector should own the
-  /// allocator. Defaults to / `false`.
-  /// @param[in] buffer_minalign Force the buffer to be aligned to the given
-  /// minimum alignment upon reallocation. Only needed if you intend to store
-  /// types with custom alignment AND you wish to read the buffer in-place
-  /// directly after creation.
-  explicit FlatBufferBuilderImpl(
-      size_t initial_size = 1024, Allocator* allocator = nullptr,
-      bool own_allocator = false,
-      size_t buffer_minalign = AlignOf<largest_scalar_t>())
-      : buf_(initial_size, allocator, own_allocator, buffer_minalign,
-             static_cast<SizeT>(Is64Aware ? FLATBUFFERS_MAX_64_BUFFER_SIZE
-                                          : FLATBUFFERS_MAX_BUFFER_SIZE)),
-        num_field_loc(0),
-        max_voffset_(0),
-        length_of_64_bit_region_(0),
-        nested(false),
-        finished(false),
-        minalign_(1),
-        force_defaults_(false),
-        dedup_vtables_(true),
-        string_pool(nullptr) {
-    EndianCheck();
-  }
-
-  /// @brief Move constructor for FlatBufferBuilder.
-  FlatBufferBuilderImpl(FlatBufferBuilderImpl&& other) noexcept
-      : buf_(1024, nullptr, false, AlignOf<largest_scalar_t>(),
-             static_cast<SizeT>(Is64Aware ? FLATBUFFERS_MAX_64_BUFFER_SIZE
-                                          : FLATBUFFERS_MAX_BUFFER_SIZE)),
-        num_field_loc(0),
-        max_voffset_(0),
-        length_of_64_bit_region_(0),
-        nested(false),
-        finished(false),
-        minalign_(1),
-        force_defaults_(false),
-        dedup_vtables_(true),
-        string_pool(nullptr) {
-    EndianCheck();
-    // Default construct and swap idiom.
-    // Lack of delegating constructors in vs2010 makes it more verbose than
-    // needed.
-    Swap(other);
-  }
-
-  /// @brief Move assignment operator for FlatBufferBuilder.
-  FlatBufferBuilderImpl& operator=(FlatBufferBuilderImpl&& other) noexcept {
-    // Move construct a temporary and swap idiom
-    FlatBufferBuilderImpl temp(std::move(other));
-    Swap(temp);
-    return *this;
-  }
-
-  void Swap(FlatBufferBuilderImpl& other) {
-    using std::swap;
-    buf_.swap(other.buf_);
-    swap(num_field_loc, other.num_field_loc);
-    swap(max_voffset_, other.max_voffset_);
-    swap(length_of_64_bit_region_, other.length_of_64_bit_region_);
-    swap(nested, other.nested);
-    swap(finished, other.finished);
-    swap(minalign_, other.minalign_);
-    swap(force_defaults_, other.force_defaults_);
-    swap(dedup_vtables_, other.dedup_vtables_);
-    swap(string_pool, other.string_pool);
-  }
-
-  ~FlatBufferBuilderImpl() {
-    if (string_pool) delete string_pool;
-  }
-
-  void Reset() {
-    Clear();       // clear builder state
-    buf_.reset();  // deallocate buffer
-  }
-
-  /// @brief Reset all the state in this FlatBufferBuilder so it can be reused
-  /// to construct another buffer.
-  void Clear() {
-    ClearOffsets();
-    buf_.clear();
-    nested = false;
-    finished = false;
-    minalign_ = 1;
-    length_of_64_bit_region_ = 0;
-    if (string_pool) string_pool->clear();
-  }
-
-  /// @brief The current size of the serialized buffer, counting from the end.
-  /// @return Returns an `SizeT` with the current size of the buffer.
-  SizeT GetSize() const { return buf_.size(); }
-
-  /// @brief The current size of the serialized buffer relative to the end of
-  /// the 32-bit region.
-  /// @return Returns an `uoffset_t` with the current size of the buffer.
-  template <bool is_64 = Is64Aware>
-  // Only enable this method for the 64-bit builder, as only that builder is
-  // concerned with the 32/64-bit boundary, and should be the one to bare any
-  // run time costs.
-  typename std::enable_if<is_64, uoffset_t>::type GetSizeRelative32BitRegion()
-      const {
-    //[32-bit region][64-bit region]
-    //         [XXXXXXXXXXXXXXXXXXX] GetSize()
-    //               [YYYYYYYYYYYYY] length_of_64_bit_region_
-    //         [ZZZZ]                return size
-    return static_cast<uoffset_t>(GetSize() - length_of_64_bit_region_);
-  }
-
-  template <bool is_64 = Is64Aware>
-  // Only enable this method for the 32-bit builder.
-  typename std::enable_if<!is_64, uoffset_t>::type GetSizeRelative32BitRegion()
-      const {
-    return static_cast<uoffset_t>(GetSize());
-  }
-
-  /// @brief Get the serialized buffer (after you call `Finish()`).
-  /// @return Returns an `uint8_t` pointer to the FlatBuffer data inside the
-  /// buffer.
-  uint8_t* GetBufferPointer() const {
-    Finished();
-    return buf_.data();
-  }
-
-  /// @brief Get the serialized buffer (after you call `Finish()`) as a span.
-  /// @return Returns a constructed flatbuffers::span that is a view over the
-  /// FlatBuffer data inside the buffer.
-  flatbuffers::span<uint8_t> GetBufferSpan() const {
-    Finished();
-    return flatbuffers::span<uint8_t>(buf_.data(), buf_.size());
-  }
-
-  /// @brief Get a pointer to an unfinished buffer.
-  /// @return Returns a `uint8_t` pointer to the unfinished buffer.
-  uint8_t* GetCurrentBufferPointer() const { return buf_.data(); }
-
-  /// @brief Get the released DetachedBuffer.
-  /// @return A `DetachedBuffer` that owns the buffer and its allocator.
-  DetachedBuffer Release() {
-    Finished();
-    DetachedBuffer buffer = buf_.release();
-    Clear();
-    return buffer;
-  }
-
-  /// @brief Get the released pointer to the serialized buffer.
-  /// @param size The size of the memory block containing
-  /// the serialized `FlatBuffer`.
-  /// @param offset The offset from the released pointer where the finished
-  /// `FlatBuffer` starts.
-  /// @return A raw pointer to the start of the memory block containing
-  /// the serialized `FlatBuffer`.
-  /// @remark If the allocator is owned, it gets deleted when the destructor is
-  /// called.
-  uint8_t* ReleaseRaw(size_t& size, size_t& offset) {
-    Finished();
-    uint8_t* raw = buf_.release_raw(size, offset);
-    Clear();
-    return raw;
-  }
-
-  /// @brief get the minimum alignment this buffer needs to be accessed
-  /// properly. This is only known once all elements have been written (after
-  /// you call Finish()). You can use this information if you need to embed
-  /// a FlatBuffer in some other buffer, such that you can later read it
-  /// without first having to copy it into its own buffer.
-  size_t GetBufferMinAlignment() const {
-    Finished();
-    return minalign_;
-  }
-
-  /// @cond FLATBUFFERS_INTERNAL
-  void Finished() const {
-    // If you get this assert, you're attempting to get access a buffer
-    // which hasn't been finished yet. Be sure to call
-    // FlatBufferBuilder::Finish with your root table.
-    // If you really need to access an unfinished buffer, call
-    // GetCurrentBufferPointer instead.
-    FLATBUFFERS_ASSERT(finished);
-  }
-  /// @endcond
-
-  /// @brief In order to save space, fields that are set to their default value
-  /// don't get serialized into the buffer.
-  /// @param[in] fd When set to `true`, always serializes default values that
-  /// are set. Optional fields which are not set explicitly, will still not be
-  /// serialized.
-  void ForceDefaults(bool fd) { force_defaults_ = fd; }
-
-  /// @brief By default vtables are deduped in order to save space.
-  /// @param[in] dedup When set to `true`, dedup vtables.
-  void DedupVtables(bool dedup) { dedup_vtables_ = dedup; }
-
-  /// @cond FLATBUFFERS_INTERNAL
-  void Pad(size_t num_bytes) { buf_.fill(num_bytes); }
-
-  void TrackMinAlign(size_t elem_size) {
-    if (elem_size > minalign_) minalign_ = elem_size;
-  }
-
-  void Align(size_t elem_size) {
-    TrackMinAlign(elem_size);
-    buf_.fill(PaddingBytes(buf_.size(), elem_size));
-  }
-
-  void PushFlatBuffer(const uint8_t* bytes, size_t size) {
-    PushBytes(bytes, size);
-    finished = true;
-  }
-
-  void PushBytes(const uint8_t* bytes, size_t size) { buf_.push(bytes, size); }
-
-  void PopBytes(size_t amount) { buf_.pop(amount); }
-
-  template <typename T>
-  void AssertScalarT() {
-    // The code assumes power of 2 sizes and endian-swap-ability.
-    static_assert(flatbuffers::is_scalar<T>::value, "T must be a scalar type");
-  }
-
-  // Write a single aligned scalar to the buffer
-  template <typename T, typename ReturnT = uoffset_t>
-  ReturnT PushElement(T element) {
-    AssertScalarT<T>();
-    Align(sizeof(T));
-    buf_.push_small(EndianScalar(element));
-    return CalculateOffset<ReturnT>();
-  }
-
-  template <typename T, template <typename> class OffsetT = Offset>
-  uoffset_t PushElement(OffsetT<T> off) {
-    // Special case for offsets: see ReferTo below.
-    return PushElement(ReferTo(off.o));
-  }
-
-  // When writing fields, we track where they are, so we can create correct
-  // vtables later.
-  void TrackField(voffset_t field, uoffset_t off) {
-    FieldLoc fl = {off, field};
-    buf_.scratch_push_small(fl);
-    num_field_loc++;
-    if (field > max_voffset_) {
-      max_voffset_ = field;
-    }
-  }
-
-  // Like PushElement, but additionally tracks the field this represents.
-  template <typename T>
-  void AddElement(voffset_t field, T e, T def) {
-    // We don't serialize values equal to the default.
-    if (IsTheSameAs(e, def) && !force_defaults_) return;
-    TrackField(field, PushElement(e));
-  }
-
-  template <typename T>
-  void AddElement(voffset_t field, T e) {
-    TrackField(field, PushElement(e));
-  }
-
-  template <typename T>
-  void AddOffset(voffset_t field, Offset<T> off) {
-    if (off.IsNull()) return;  // Don't store.
-    AddElement(field, ReferTo(off.o), static_cast<uoffset_t>(0));
-  }
-
-  template <typename T>
-  void AddOffset(voffset_t field, Offset64<T> off) {
-    if (off.IsNull()) return;  // Don't store.
-    AddElement(field, ReferTo(off.o), static_cast<uoffset64_t>(0));
-  }
-
-  template <typename T>
-  void AddStruct(voffset_t field, const T* structptr) {
-    if (!structptr) return;  // Default, don't store.
-    Align(AlignOf<T>());
-    buf_.push_small(*structptr);
-    TrackField(field, CalculateOffset<uoffset_t>());
-  }
-
-  void AddStructOffset(voffset_t field, uoffset_t off) {
-    TrackField(field, off);
-  }
-
-  // Offsets initially are relative to the end of the buffer (downwards).
-  // This function converts them to be relative to the current location
-  // in the buffer (when stored here), pointing upwards.
-  uoffset_t ReferTo(uoffset_t off) {
-    // Align to ensure GetSizeRelative32BitRegion() below is correct.
-    Align(sizeof(uoffset_t));
-    // 32-bit offsets are relative to the tail of the 32-bit region of the
-    // buffer. For most cases (without 64-bit entities) this is equivalent to
-    // size of the whole buffer (e.g. GetSize())
-    return ReferTo(off, GetSizeRelative32BitRegion());
-  }
-
-  uoffset64_t ReferTo(uoffset64_t off) {
-    // Align to ensure GetSize() below is correct.
-    Align(sizeof(uoffset64_t));
-    // 64-bit offsets are relative to tail of the whole buffer
-    return ReferTo(off, GetSize());
-  }
-
-  template <typename T, typename T2>
-  T ReferTo(const T off, const T2 size) {
-    FLATBUFFERS_ASSERT(off && off <= size);
-    return size - off + static_cast<T>(sizeof(T));
-  }
-
-  template <typename T>
-  T ReferTo(const T off, const T size) {
-    FLATBUFFERS_ASSERT(off && off <= size);
-    return size - off + static_cast<T>(sizeof(T));
-  }
-
-  void NotNested() {
-    // If you hit this, you're trying to construct a Table/Vector/String
-    // during the construction of its parent table (between the MyTableBuilder
-    // and table.Finish().
-    // Move the creation of these sub-objects to above the MyTableBuilder to
-    // not get this assert.
-    // Ignoring this assert may appear to work in simple cases, but the reason
-    // it is here is that storing objects in-line may cause vtable offsets
-    // to not fit anymore. It also leads to vtable duplication.
-    FLATBUFFERS_ASSERT(!nested);
-    // If you hit this, fields were added outside the scope of a table.
-    FLATBUFFERS_ASSERT(!num_field_loc);
-  }
-
-  // From generated code (or from the parser), we call StartTable/EndTable
-  // with a sequence of AddElement calls in between.
-  uoffset_t StartTable() {
-    NotNested();
-    nested = true;
-    return GetSizeRelative32BitRegion();
-  }
-
-  // This finishes one serialized object by generating the vtable if it's a
-  // table, comparing it against existing vtables, and writing the
-  // resulting vtable offset.
-  uoffset_t EndTable(uoffset_t start) {
-    // If you get this assert, a corresponding StartTable wasn't called.
-    FLATBUFFERS_ASSERT(nested);
-    // Write the vtable offset, which is the start of any Table.
-    // We fill its value later.
-    // This is relative to the end of the 32-bit region.
-    const uoffset_t vtable_offset_loc =
-        static_cast<uoffset_t>(PushElement<soffset_t>(0));
-    // Write a vtable, which consists entirely of voffset_t elements.
-    // It starts with the number of offsets, followed by a type id, followed
-    // by the offsets themselves. In reverse:
-    // Include space for the last offset and ensure empty tables have a
-    // minimum size.
-    max_voffset_ =
-        (std::max)(static_cast<voffset_t>(max_voffset_ + sizeof(voffset_t)),
-                   FieldIndexToOffset(0));
-    buf_.fill_big(max_voffset_);
-    const uoffset_t table_object_size = vtable_offset_loc - start;
-    // Vtable use 16bit offsets.
-    FLATBUFFERS_ASSERT(table_object_size < 0x10000);
-    WriteScalar<voffset_t>(buf_.data() + sizeof(voffset_t),
-                           static_cast<voffset_t>(table_object_size));
-    WriteScalar<voffset_t>(buf_.data(), max_voffset_);
-    // Write the offsets into the table
-    for (auto it = buf_.scratch_end() - num_field_loc * sizeof(FieldLoc);
-         it < buf_.scratch_end(); it += sizeof(FieldLoc)) {
-      auto field_location = reinterpret_cast<FieldLoc*>(it);
-      const voffset_t pos =
-          static_cast<voffset_t>(vtable_offset_loc - field_location->off);
-      // If this asserts, it means you've set a field twice.
-      FLATBUFFERS_ASSERT(
-          !ReadScalar<voffset_t>(buf_.data() + field_location->id));
-      WriteScalar<voffset_t>(buf_.data() + field_location->id, pos);
-    }
-    ClearOffsets();
-    auto vt1 = reinterpret_cast<voffset_t*>(buf_.data());
-    auto vt1_size = ReadScalar<voffset_t>(vt1);
-    auto vt_use = GetSizeRelative32BitRegion();
-    // See if we already have generated a vtable with this exact same
-    // layout before. If so, make it point to the old one, remove this one.
-    if (dedup_vtables_) {
-      for (auto it = buf_.scratch_data(); it < buf_.scratch_end();
-           it += sizeof(uoffset_t)) {
-        auto vt_offset_ptr = reinterpret_cast<uoffset_t*>(it);
-        auto vt2 = reinterpret_cast<voffset_t*>(
-            buf_.data_at(*vt_offset_ptr + length_of_64_bit_region_));
-        auto vt2_size = ReadScalar<voffset_t>(vt2);
-        if (vt1_size != vt2_size || 0 != memcmp(vt2, vt1, vt1_size)) continue;
-        vt_use = *vt_offset_ptr;
-        buf_.pop(GetSizeRelative32BitRegion() - vtable_offset_loc);
-        break;
-      }
-    }
-    // If this is a new vtable, remember it.
-    if (vt_use == GetSizeRelative32BitRegion()) {
-      buf_.scratch_push_small(vt_use);
-    }
-    // Fill the vtable offset we created above.
-    // The offset points from the beginning of the object to where the vtable is
-    // stored.
-    // Offsets default direction is downward in memory for future format
-    // flexibility (storing all vtables at the start of the file).
-    WriteScalar(buf_.data_at(vtable_offset_loc + length_of_64_bit_region_),
-                static_cast<soffset_t>(vt_use) -
-                    static_cast<soffset_t>(vtable_offset_loc));
-    nested = false;
-    return vtable_offset_loc;
-  }
-
-  FLATBUFFERS_ATTRIBUTE([[deprecated("call the version above instead")]])
-  uoffset_t EndTable(uoffset_t start, voffset_t /*numfields*/) {
-    return EndTable(start);
-  }
-
-  // This checks a required field has been set in a given table that has
-  // just been constructed.
-  template <typename T>
-  void Required(Offset<T> table, voffset_t field) {
-    auto table_ptr = reinterpret_cast<const Table*>(buf_.data_at(table.o));
-    bool ok = table_ptr->GetOptionalFieldOffset(field) != 0;
-    // If this fails, the caller will show what field needs to be set.
-    FLATBUFFERS_ASSERT(ok);
-    (void)ok;
-  }
-
-  uoffset_t StartStruct(size_t alignment) {
-    Align(alignment);
-    return GetSizeRelative32BitRegion();
-  }
-
-  uoffset_t EndStruct() { return GetSizeRelative32BitRegion(); }
-
-  void ClearOffsets() {
-    buf_.scratch_pop(num_field_loc * sizeof(FieldLoc));
-    num_field_loc = 0;
-    max_voffset_ = 0;
-  }
-
-  // Aligns such that when "len" bytes are written, an object can be written
-  // after it (forward in the buffer) with "alignment" without padding.
-  void PreAlign(size_t len, size_t alignment) {
-    if (len == 0) return;
-    TrackMinAlign(alignment);
-    buf_.fill(PaddingBytes(GetSize() + len, alignment));
-  }
-
-  // Aligns such than when "len" bytes are written, an object of type `AlignT`
-  // can be written after it (forward in the buffer) without padding.
-  template <typename AlignT>
-  void PreAlign(size_t len) {
-    AssertScalarT<AlignT>();
-    PreAlign(len, AlignOf<AlignT>());
-  }
-  /// @endcond
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const char pointer to the data to be stored as a string.
-  /// @param[in] len The number of bytes that should be stored from `str`.
-  /// @return Returns the offset in the buffer where the string starts.
-  template <template <typename> class OffsetT = Offset>
-  OffsetT<String> CreateString(const char* str, size_t len) {
-    CreateStringImpl(str, len);
-    return OffsetT<String>(
-        CalculateOffset<typename OffsetT<String>::offset_type>());
-  }
-
-  /// @brief Store a string in the buffer, which is null-terminated.
-  /// @param[in] str A const char pointer to a C-string to add to the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  template <template <typename> class OffsetT = Offset>
-  OffsetT<String> CreateString(const char* str) {
-    return CreateString<OffsetT>(str, strlen(str));
-  }
-
-  /// @brief Store a string in the buffer, which is null-terminated.
-  /// @param[in] str A char pointer to a C-string to add to the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  template <template <typename> class OffsetT = Offset>
-  OffsetT<String> CreateString(char* str) {
-    return CreateString<OffsetT>(str, strlen(str));
-  }
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const reference to a std::string to store in the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  template <template <typename> class OffsetT = Offset>
-  OffsetT<String> CreateString(const std::string& str) {
-    return CreateString<OffsetT>(str.c_str(), str.length());
-  }
-
-  // clang-format off
-  #ifdef FLATBUFFERS_HAS_STRING_VIEW
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const string_view to copy in to the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  template<template <typename> class OffsetT = Offset>
-  OffsetT<String>CreateString(flatbuffers::string_view str) {
-    return CreateString<OffsetT>(str.data(), str.size());
-  }
-  #endif // FLATBUFFERS_HAS_STRING_VIEW
-  // clang-format on
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const pointer to a `String` struct to add to the buffer.
-  /// @return Returns the offset in the buffer where the string starts
-  template <template <typename> class OffsetT = Offset>
-  OffsetT<String> CreateString(const String* str) {
-    return str ? CreateString<OffsetT>(str->c_str(), str->size()) : 0;
-  }
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const reference to a std::string like type with support
-  /// of T::data() and T::length() to store in the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  template <template <typename> class OffsetT = Offset,
-            // No need to explicitly declare the T type, let the compiler deduce
-            // it.
-            int&... ExplicitArgumentBarrier, typename T>
-  OffsetT<String> CreateString(const T& str) {
-    return CreateString<OffsetT>(str.data(), str.length());
-  }
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string. This uses a map
-  /// stored on the heap, but only stores the numerical offsets.
-  /// @param[in] str A const char pointer to the data to be stored as a string.
-  /// @param[in] len The number of bytes that should be stored from `str`.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateSharedString(const char* str, size_t len) {
-    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
-    if (!string_pool) {
-      string_pool = new StringOffsetMap(StringOffsetCompare(buf_));
-    }
-
-    const size_t size_before_string = buf_.size();
-    // Must first serialize the string, since the set is all offsets into
-    // buffer.
-    const Offset<String> off = CreateString<Offset>(str, len);
-    auto it = string_pool->find(off);
-    // If it exists we reuse existing serialized data!
-    if (it != string_pool->end()) {
-      // We can remove the string we serialized.
-      buf_.pop(buf_.size() - size_before_string);
-      return *it;
-    }
-    // Record this string for future use.
-    string_pool->insert(off);
-    return off;
-  }
-
-#ifdef FLATBUFFERS_HAS_STRING_VIEW
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string. This uses a map
-  /// stored on the heap, but only stores the numerical offsets.
-  /// @param[in] str A const std::string_view to store in the buffer.
-  /// @return Returns the offset in the buffer where the string starts
-  Offset<String> CreateSharedString(const flatbuffers::string_view str) {
-    return CreateSharedString(str.data(), str.size());
-  }
-#else
-  /// @brief Store a string in the buffer, which null-terminated.
-  /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string. This uses a map
-  /// stored on the heap, but only stores the numerical offsets.
-  /// @param[in] str A const char pointer to a C-string to add to the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateSharedString(const char* str) {
-    return CreateSharedString(str, strlen(str));
-  }
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string. This uses a map
-  /// stored on the heap, but only stores the numerical offsets.
-  /// @param[in] str A const reference to a std::string to store in the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateSharedString(const std::string& str) {
-    return CreateSharedString(str.c_str(), str.length());
-  }
-#endif
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string. This uses a map
-  /// stored on the heap, but only stores the numerical offsets.
-  /// @param[in] str A const pointer to a `String` struct to add to the buffer.
-  /// @return Returns the offset in the buffer where the string starts
-  Offset<String> CreateSharedString(const String* str) {
-    return str ? CreateSharedString(str->c_str(), str->size()) : 0;
-  }
-
-  /// @cond FLATBUFFERS_INTERNAL
-  template <typename LenT = uoffset_t, typename ReturnT = uoffset_t>
-  ReturnT EndVector(size_t len) {
-    FLATBUFFERS_ASSERT(nested);  // Hit if no corresponding StartVector.
-    nested = false;
-    return PushElement<LenT, ReturnT>(static_cast<LenT>(len));
-  }
-
-  template <template <typename> class OffsetT = Offset,
-            typename LenT = uint32_t>
-  void StartVector(size_t len, size_t elemsize, size_t alignment) {
-    NotNested();
-    nested = true;
-    // Align to the Length type of the vector (either 32-bit or 64-bit), so
-    // that the length of the buffer can be added without padding.
-    PreAlign<LenT>(len * elemsize);
-    PreAlign(len * elemsize, alignment);  // Just in case elemsize > uoffset_t.
-  }
-
-  template <typename T, template <typename> class OffsetT = Offset,
-            typename LenT = uint32_t>
-  void StartVector(size_t len) {
-    return StartVector<OffsetT, LenT>(len, sizeof(T), AlignOf<T>());
-  }
-
-  // Call this right before StartVector/CreateVector if you want to force the
-  // alignment to be something different than what the element size would
-  // normally dictate.
-  // This is useful when storing a nested_flatbuffer in a vector of bytes,
-  // or when storing SIMD floats, etc.
-  void ForceVectorAlignment(const size_t len, const size_t elemsize,
-                            const size_t alignment) {
-    if (len == 0) return;
-    FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
-    PreAlign(len * elemsize, alignment);
-  }
-
-  template <bool is_64 = Is64Aware>
-  typename std::enable_if<is_64, void>::type ForceVectorAlignment64(
-      const size_t len, const size_t elemsize, const size_t alignment) {
-    // If you hit this assertion, you are trying to force alignment on a
-    // vector with offset64 after serializing a 32-bit offset.
-    FLATBUFFERS_ASSERT(GetSize() == length_of_64_bit_region_);
-
-    // Call through.
-    ForceVectorAlignment(len, elemsize, alignment);
-
-    // Update the 64 bit region.
-    length_of_64_bit_region_ = GetSize();
-  }
-
-  // Similar to ForceVectorAlignment but for String fields.
-  void ForceStringAlignment(size_t len, size_t alignment) {
-    if (len == 0) return;
-    FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
-    PreAlign((len + 1) * sizeof(char), alignment);
-  }
-
-  /// @endcond
-
-  /// @brief Serialize an array into a FlatBuffer `vector`.
-  /// @tparam T The data type of the array elements.
-  /// @tparam OffsetT the type of offset to return
-  /// @tparam VectorT the type of vector to cast to.
-  /// @param[in] v A pointer to the array of type `T` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @return Returns a typed `TOffset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, template <typename...> class OffsetT = Offset,
-            template <typename...> class VectorT = Vector>
-  OffsetT<VectorT<T>> CreateVector(const T* v, size_t len) {
-    // The type of the length field in the vector.
-    typedef typename VectorT<T>::size_type LenT;
-    typedef typename OffsetT<VectorT<T>>::offset_type offset_type;
-    // If this assert hits, you're specifying a template argument that is
-    // causing the wrong overload to be selected, remove it.
-    AssertScalarT<T>();
-    StartVector<T, OffsetT, LenT>(len);
-    if (len > 0) {
-      // clang-format off
-      #if FLATBUFFERS_LITTLEENDIAN
-        PushBytes(reinterpret_cast<const uint8_t *>(v), len * sizeof(T));
-      #else
-        if (sizeof(T) == 1) {
-          PushBytes(reinterpret_cast<const uint8_t *>(v), len);
-        } else {
-          for (auto i = len; i > 0; ) {
-            PushElement(v[--i]);
-          }
-        }
-      #endif
-      // clang-format on
-    }
-    return OffsetT<VectorT<T>>(EndVector<LenT, offset_type>(len));
-  }
-
-  /// @brief Serialize an array like object into a FlatBuffer `vector`.
-  /// @tparam T The data type of the array elements.
-  /// @tparam C The type of the array.
-  /// @param[in] array A reference to an array like object of type `T` to
-  /// serialize into the buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, class C>
-  Offset<Vector<T>> CreateVector(const C& array) {
-    return CreateVector(array.data(), array.size());
-  }
-
-  /// @brief Serialize an initializer list into a FlatBuffer `vector`.
-  /// @tparam T The data type of the initializer list elements.
-  /// @param[in] v The value of the initializer list.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T>
-  Offset<Vector<T>> CreateVector(std::initializer_list<T> v) {
-    return CreateVector(v.begin(), v.size());
-  }
-
-  template <typename T>
-  Offset<Vector<Offset<T>>> CreateVector(const Offset<T>* v, size_t len) {
-    StartVector<Offset<T>>(len);
-    for (auto i = len; i > 0;) {
-      PushElement(v[--i]);
-    }
-    return Offset<Vector<Offset<T>>>(EndVector(len));
-  }
-
-  /// @brief Serialize a `std::vector` into a FlatBuffer `vector`.
-  /// @tparam T The data type of the `std::vector` elements.
-  /// @param v A const reference to the `std::vector` to serialize into the
-  /// buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, typename Alloc = std::allocator<T>>
-  Offset<Vector<T>> CreateVector(const std::vector<T, Alloc>& v) {
-    return CreateVector(data(v), v.size());
-  }
-
-  template <template <typename...> class VectorT = Vector64,
-            int&... ExplicitArgumentBarrier, typename T>
-  Offset64<VectorT<T>> CreateVector64(const std::vector<T>& v) {
-    return CreateVector<T, Offset64, VectorT>(data(v), v.size());
-  }
-
-  // vector<bool> may be implemented using a bit-set, so we can't access it as
-  // an array. Instead, read elements manually.
-  // Background: https://isocpp.org/blog/2012/11/on-vectorbool
-  Offset<Vector<uint8_t>> CreateVector(const std::vector<bool>& v) {
-    StartVector<uint8_t>(v.size());
-    for (auto i = v.size(); i > 0;) {
-      PushElement(static_cast<uint8_t>(v[--i]));
-    }
-    return Offset<Vector<uint8_t>>(EndVector(v.size()));
-  }
-
-  Offset64<Vector64<uint8_t>> CreateVector64(const std::vector<bool>& v) {
-    StartVector<uint8_t, Offset64, Vector64<uint8_t>::size_type>(v.size());
-    for (auto i = v.size(); i > 0;) {
-      PushElement(static_cast<uint8_t>(v[--i]));
-    }
-    return Offset64<Vector64<uint8_t>>(
-        EndVector<Vector64<uint8_t>::size_type,
-                  Offset64<Vector64<uint8_t>>::offset_type>(v.size()));
-  }
-
-  /// @brief Serialize values returned by a function into a FlatBuffer `vector`.
-  /// This is a convenience function that takes care of iteration for you.
-  /// @tparam T The data type of the `std::vector` elements.
-  /// @param f A function that takes the current iteration 0..vector_size-1 and
-  /// returns any type that you can construct a FlatBuffers vector out of.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T>
-  Offset<Vector<T>> CreateVector(size_t vector_size,
-                                 const std::function<T(size_t i)>& f) {
-    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
-    std::vector<T> elems(vector_size);
-    for (size_t i = 0; i < vector_size; i++) elems[i] = f(i);
-    return CreateVector(elems);
-  }
-
-  /// @brief Serialize values returned by a function into a FlatBuffer `vector`.
-  /// This is a convenience function that takes care of iteration for you. This
-  /// uses a vector stored on the heap to store the intermediate results of the
-  /// iteration.
-  /// @tparam T The data type of the `std::vector` elements.
-  /// @param f A function that takes the current iteration 0..vector_size-1,
-  /// and the state parameter returning any type that you can construct a
-  /// FlatBuffers vector out of.
-  /// @param state State passed to f.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, typename F, typename S>
-  Offset<Vector<T>> CreateVector(size_t vector_size, F f, S* state) {
-    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
-    std::vector<T> elems(vector_size);
-    for (size_t i = 0; i < vector_size; i++) elems[i] = f(i, state);
-    return CreateVector(elems);
-  }
-
-  /// @brief Serialize a `std::vector<StringType>` into a FlatBuffer `vector`.
-  /// whereas StringType is any type that is accepted by the CreateString()
-  /// overloads.
-  /// This is a convenience function for a common case.
-  /// @param v A const reference to the `std::vector` to serialize into the
-  /// buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename StringType = std::string,
-            typename Alloc = std::allocator<StringType>>
-  Offset<Vector<Offset<String>>> CreateVectorOfStrings(
-      const std::vector<StringType, Alloc>& v) {
-    return CreateVectorOfStrings(v.cbegin(), v.cend());
-  }
-
-  /// @brief Serialize a collection of Strings into a FlatBuffer `vector`.
-  /// This is a convenience function for a common case.
-  /// @param begin The beginning iterator of the collection
-  /// @param end The ending iterator of the collection
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <class It>
-  Offset<Vector<Offset<String>>> CreateVectorOfStrings(It begin, It end) {
-    auto distance = std::distance(begin, end);
-    FLATBUFFERS_ASSERT(distance >= 0);
-    auto size = static_cast<size_t>(distance);
-    auto scratch_buffer_usage = size * sizeof(Offset<String>);
-    // If there is not enough space to store the offsets, there definitely won't
-    // be enough space to store all the strings. So ensuring space for the
-    // scratch region is OK, for if it fails, it would have failed later.
-    buf_.ensure_space(scratch_buffer_usage);
-    for (auto it = begin; it != end; ++it) {
-      buf_.scratch_push_small(CreateString(*it));
-    }
-    StartVector<Offset<String>>(size);
-    for (size_t i = 1; i <= size; i++) {
-      // Note we re-evaluate the buf location each iteration to account for any
-      // underlying buffer resizing that may occur.
-      PushElement(*reinterpret_cast<Offset<String>*>(
-          buf_.scratch_end() - i * sizeof(Offset<String>)));
-    }
-    buf_.scratch_pop(scratch_buffer_usage);
-    return Offset<Vector<Offset<String>>>(EndVector(size));
-  }
-
-  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the struct array elements.
-  /// @param[in] v A pointer to the array of type `T` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, template <typename...> class OffsetT = Offset,
-            template <typename...> class VectorT = Vector>
-  OffsetT<VectorT<const T*>> CreateVectorOfStructs(const T* v, size_t len) {
-    // The type of the length field in the vector.
-    typedef typename VectorT<T>::size_type LenT;
-    typedef typename OffsetT<VectorT<const T*>>::offset_type offset_type;
-
-    StartVector<OffsetT, LenT>(len, sizeof(T), AlignOf<T>());
-    if (len > 0) {
-      PushBytes(reinterpret_cast<const uint8_t*>(v), sizeof(T) * len);
-    }
-    return OffsetT<VectorT<const T*>>(EndVector<LenT, offset_type>(len));
-  }
-
-  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the struct array elements.
-  /// @param[in] filler A function that takes the current iteration
-  /// 0..vector_size-1 and a pointer to the struct that must be filled.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  /// This is mostly useful when flatbuffers are generated with mutation
-  /// accessors.
-  template <typename T>
-  Offset<Vector<const T*>> CreateVectorOfStructs(
-      size_t vector_size, const std::function<void(size_t i, T*)>& filler) {
-    T* structs = StartVectorOfStructs<T>(vector_size);
-    for (size_t i = 0; i < vector_size; i++) {
-      filler(i, structs);
-      structs++;
-    }
-    return EndVectorOfStructs<T>(vector_size);
-  }
-
-  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the struct array elements.
-  /// @param[in] f A function that takes the current iteration 0..vector_size-1,
-  /// a pointer to the struct that must be filled and the state argument.
-  /// @param[in] state Arbitrary state to pass to f.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  /// This is mostly useful when flatbuffers are generated with mutation
-  /// accessors.
-  template <typename T, typename F, typename S>
-  Offset<Vector<const T*>> CreateVectorOfStructs(size_t vector_size, F f,
-                                                 S* state) {
-    T* structs = StartVectorOfStructs<T>(vector_size);
-    for (size_t i = 0; i < vector_size; i++) {
-      f(i, structs, state);
-      structs++;
-    }
-    return EndVectorOfStructs<T>(vector_size);
-  }
-
-  /// @brief Serialize a `std::vector` of structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the `std::vector` struct elements.
-  /// @param[in] v A const reference to the `std::vector` of structs to
-  /// serialize into the buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, template <typename...> class OffsetT = Offset,
-            template <typename...> class VectorT = Vector,
-            typename Alloc = std::allocator<T>>
-  OffsetT<VectorT<const T*>> CreateVectorOfStructs(
-      const std::vector<T, Alloc>& v) {
-    return CreateVectorOfStructs<T, OffsetT, VectorT>(data(v), v.size());
-  }
-
-  template <template <typename...> class VectorT = Vector64, int&...,
-            typename T>
-  Offset64<VectorT<const T*>> CreateVectorOfStructs64(const std::vector<T>& v) {
-    return CreateVectorOfStructs<T, Offset64, VectorT>(data(v), v.size());
-  }
-
-  /// @brief Serialize an array of native structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the struct array elements.
-  /// @tparam S The data type of the native struct array elements.
-  /// @param[in] v A pointer to the array of type `S` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @param[in] pack_func Pointer to a function to convert the native struct
-  /// to the FlatBuffer struct.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, typename S>
-  Offset<Vector<const T*>> CreateVectorOfNativeStructs(
-      const S* v, size_t len, T (*const pack_func)(const S&)) {
-    FLATBUFFERS_ASSERT(pack_func);
-    auto structs = StartVectorOfStructs<T>(len);
-    for (size_t i = 0; i < len; i++) {
-      structs[i] = pack_func(v[i]);
-    }
-    return EndVectorOfStructs<T>(len);
-  }
-
-  /// @brief Serialize an array of native structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the struct array elements.
-  /// @tparam S The data type of the native struct array elements.
-  /// @param[in] v A pointer to the array of type `S` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, typename S>
-  Offset<Vector<const T*>> CreateVectorOfNativeStructs(const S* v, size_t len) {
-    extern T Pack(const S&);
-    return CreateVectorOfNativeStructs(v, len, Pack);
-  }
-
-  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
-  /// `vector`.
-  /// @tparam T The data type of the `std::vector` struct elements.
-  /// @tparam S The data type of the `std::vector` native struct elements.
-  /// @param[in] v A const reference to the `std::vector` of structs to
-  /// serialize into the buffer as a `vector`.
-  /// @param[in] pack_func Pointer to a function to convert the native struct
-  /// to the FlatBuffer struct.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, typename S, typename Alloc = std::allocator<T>>
-  Offset<Vector<const T*>> CreateVectorOfNativeStructs(
-      const std::vector<S, Alloc>& v, T (*const pack_func)(const S&)) {
-    return CreateVectorOfNativeStructs<T, S>(data(v), v.size(), pack_func);
-  }
-
-  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
-  /// `vector`.
-  /// @tparam T The data type of the `std::vector` struct elements.
-  /// @tparam S The data type of the `std::vector` native struct elements.
-  /// @param[in] v A const reference to the `std::vector` of structs to
-  /// serialize into the buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, typename S, typename Alloc = std::allocator<S>>
-  Offset<Vector<const T*>> CreateVectorOfNativeStructs(
-      const std::vector<S, Alloc>& v) {
-    return CreateVectorOfNativeStructs<T, S>(data(v), v.size());
-  }
-
-  /// @cond FLATBUFFERS_INTERNAL
-  template <typename T>
-  struct StructKeyComparator {
-    bool operator()(const T& a, const T& b) const {
-      return a.KeyCompareLessThan(&b);
-    }
-  };
-  /// @endcond
-
-  /// @brief Serialize a `std::vector` of structs into a FlatBuffer `vector`
-  /// in sorted order.
-  /// @tparam T The data type of the `std::vector` struct elements.
-  /// @param[in] v A const reference to the `std::vector` of structs to
-  /// serialize into the buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, typename Alloc = std::allocator<T>>
-  Offset<Vector<const T*>> CreateVectorOfSortedStructs(
-      std::vector<T, Alloc>* v) {
-    return CreateVectorOfSortedStructs(data(*v), v->size());
-  }
-
-  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
-  /// `vector` in sorted order.
-  /// @tparam T The data type of the `std::vector` struct elements.
-  /// @tparam S The data type of the `std::vector` native struct elements.
-  /// @param[in] v A const reference to the `std::vector` of structs to
-  /// serialize into the buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, typename S, typename Alloc = std::allocator<T>>
-  Offset<Vector<const T*>> CreateVectorOfSortedNativeStructs(
-      std::vector<S, Alloc>* v) {
-    return CreateVectorOfSortedNativeStructs<T, S>(data(*v), v->size());
-  }
-
-  /// @brief Serialize an array of structs into a FlatBuffer `vector` in sorted
-  /// order.
-  /// @tparam T The data type of the struct array elements.
-  /// @param[in] v A pointer to the array of type `T` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T>
-  Offset<Vector<const T*>> CreateVectorOfSortedStructs(T* v, size_t len) {
-    std::stable_sort(v, v + len, StructKeyComparator<T>());
-    return CreateVectorOfStructs(v, len);
-  }
-
-  /// @brief Serialize an array of native structs into a FlatBuffer `vector` in
-  /// sorted order.
-  /// @tparam T The data type of the struct array elements.
-  /// @tparam S The data type of the native struct array elements.
-  /// @param[in] v A pointer to the array of type `S` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, typename S>
-  Offset<Vector<const T*>> CreateVectorOfSortedNativeStructs(S* v, size_t len) {
-    extern T Pack(const S&);
-    auto structs = StartVectorOfStructs<T>(len);
-    for (size_t i = 0; i < len; i++) {
-      structs[i] = Pack(v[i]);
-    }
-    std::stable_sort(structs, structs + len, StructKeyComparator<T>());
-    return EndVectorOfStructs<T>(len);
-  }
-
-  /// @cond FLATBUFFERS_INTERNAL
-  template <typename T>
-  struct TableKeyComparator {
-    explicit TableKeyComparator(vector_downward<SizeT>& buf) : buf_(buf) {}
-    TableKeyComparator(const TableKeyComparator& other) : buf_(other.buf_) {}
-    bool operator()(const Offset<T>& a, const Offset<T>& b) const {
-      auto table_a = reinterpret_cast<T*>(buf_.data_at(a.o));
-      auto table_b = reinterpret_cast<T*>(buf_.data_at(b.o));
-      return table_a->KeyCompareLessThan(table_b);
-    }
-    vector_downward<SizeT>& buf_;
-
-   private:
-    FLATBUFFERS_DELETE_FUNC(
-        TableKeyComparator& operator=(const TableKeyComparator& other));
-  };
-  /// @endcond
-
-  /// @brief Serialize an array of `table` offsets as a `vector` in the buffer
-  /// in sorted order.
-  /// @tparam T The data type that the offset refers to.
-  /// @param[in] v An array of type `Offset<T>` that contains the `table`
-  /// offsets to store in the buffer in sorted order.
-  /// @param[in] len The number of elements to store in the `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T>
-  Offset<Vector<Offset<T>>> CreateVectorOfSortedTables(Offset<T>* v,
-                                                       size_t len) {
-    std::stable_sort(v, v + len, TableKeyComparator<T>(buf_));
-    return CreateVector(v, len);
-  }
-
-  /// @brief Serialize an array of `table` offsets as a `vector` in the buffer
-  /// in sorted order.
-  /// @tparam T The data type that the offset refers to.
-  /// @param[in] v An array of type `Offset<T>` that contains the `table`
-  /// offsets to store in the buffer in sorted order.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template <typename T, typename Alloc = std::allocator<T>>
-  Offset<Vector<Offset<T>>> CreateVectorOfSortedTables(
-      std::vector<Offset<T>, Alloc>* v) {
-    return CreateVectorOfSortedTables(data(*v), v->size());
-  }
-
-  /// @brief Specialized version of `CreateVector` for non-copying use cases.
-  /// Write the data any time later to the returned buffer pointer `buf`.
-  /// @param[in] len The number of elements to store in the `vector`.
-  /// @param[in] elemsize The size of each element in the `vector`.
-  /// @param[out] buf A pointer to a `uint8_t` pointer that can be
-  /// written to at a later time to serialize the data into a `vector`
-  /// in the buffer.
-  uoffset_t CreateUninitializedVector(size_t len, size_t elemsize,
-                                      size_t alignment, uint8_t** buf) {
-    NotNested();
-    StartVector(len, elemsize, alignment);
-    buf_.make_space(len * elemsize);
-    const uoffset_t vec_start = GetSizeRelative32BitRegion();
-    auto vec_end = EndVector(len);
-    *buf = buf_.data_at(vec_start);
-    return vec_end;
-  }
-
-  FLATBUFFERS_ATTRIBUTE([[deprecated("call the version above instead")]])
-  uoffset_t CreateUninitializedVector(size_t len, size_t elemsize,
-                                      uint8_t** buf) {
-    return CreateUninitializedVector(len, elemsize, elemsize, buf);
-  }
-
-  /// @brief Specialized version of `CreateVector` for non-copying use cases.
-  /// Write the data any time later to the returned buffer pointer `buf`.
-  /// @tparam T The data type of the data that will be stored in the buffer
-  /// as a `vector`.
-  /// @param[in] len The number of elements to store in the `vector`.
-  /// @param[out] buf A pointer to a pointer of type `T` that can be
-  /// written to at a later time to serialize the data into a `vector`
-  /// in the buffer.
-  template <typename T>
-  Offset<Vector<T>> CreateUninitializedVector(size_t len, T** buf) {
-    AssertScalarT<T>();
-    return CreateUninitializedVector(len, sizeof(T), AlignOf<T>(),
-                                     reinterpret_cast<uint8_t**>(buf));
-  }
-
-  template <typename T>
-  Offset<Vector<const T*>> CreateUninitializedVectorOfStructs(size_t len,
-                                                              T** buf) {
-    return CreateUninitializedVector(len, sizeof(T), AlignOf<T>(),
-                                     reinterpret_cast<uint8_t**>(buf));
-  }
-
-  // @brief Create a vector of scalar type T given as input a vector of scalar
-  // type U, useful with e.g. pre "enum class" enums, or any existing scalar
-  // data of the wrong type.
-  template <typename T, typename U>
-  Offset<Vector<T>> CreateVectorScalarCast(const U* v, size_t len) {
-    AssertScalarT<T>();
-    AssertScalarT<U>();
-    StartVector<T>(len);
-    for (auto i = len; i > 0;) {
-      PushElement(static_cast<T>(v[--i]));
-    }
-    return Offset<Vector<T>>(EndVector(len));
-  }
-
-  /// @brief Write a struct by itself, typically to be part of a union.
-  template <typename T>
-  Offset<const T*> CreateStruct(const T& structobj) {
-    NotNested();
-    Align(AlignOf<T>());
-    buf_.push_small(structobj);
-    return Offset<const T*>(
-        CalculateOffset<typename Offset<const T*>::offset_type>());
-  }
-
-  /// @brief Finish serializing a buffer by writing the root offset.
-  /// @param[in] file_identifier If a `file_identifier` is given, the buffer
-  /// will be prefixed with a standard FlatBuffers file header.
-  template <typename T>
-  void Finish(Offset<T> root, const char* file_identifier = nullptr) {
-    Finish(root.o, file_identifier, false);
-  }
-
-  /// @brief Finish a buffer with a 32 bit size field pre-fixed (size of the
-  /// buffer following the size field). These buffers are NOT compatible
-  /// with standard buffers created by Finish, i.e. you can't call GetRoot
-  /// on them, you have to use GetSizePrefixedRoot instead.
-  /// All >32 bit quantities in this buffer will be aligned when the whole
-  /// size pre-fixed buffer is aligned.
-  /// These kinds of buffers are useful for creating a stream of FlatBuffers.
-  template <typename T>
-  void FinishSizePrefixed(Offset<T> root,
-                          const char* file_identifier = nullptr) {
-    Finish(root.o, file_identifier, true);
-  }
-
-  void SwapBufAllocator(FlatBufferBuilderImpl& other) {
-    buf_.swap_allocator(other.buf_);
-  }
-
-  /// @brief The length of a FlatBuffer file header.
-  static const size_t kFileIdentifierLength =
-      ::flatbuffers::kFileIdentifierLength;
-
- protected:
-  // You shouldn't really be copying instances of this class.
-  FlatBufferBuilderImpl(const FlatBufferBuilderImpl&);
-  FlatBufferBuilderImpl& operator=(const FlatBufferBuilderImpl&);
-
-  void Finish(uoffset_t root, const char* file_identifier, bool size_prefix) {
-    // A buffer can only be finished once. To reuse a builder use `clear()`.
-    FLATBUFFERS_ASSERT(!finished);
-
-    NotNested();
-    buf_.clear_scratch();
-
-    const size_t prefix_size = size_prefix ? sizeof(SizeT) : 0;
-    // Make sure we track the alignment of the size prefix.
-    TrackMinAlign(prefix_size);
-
-    const size_t root_offset_size = sizeof(uoffset_t);
-    const size_t file_id_size = file_identifier ? kFileIdentifierLength : 0;
-
-    // This will cause the whole buffer to be aligned.
-    PreAlign(prefix_size + root_offset_size + file_id_size, minalign_);
-
-    if (file_identifier) {
-      FLATBUFFERS_ASSERT(strlen(file_identifier) == kFileIdentifierLength);
-      PushBytes(reinterpret_cast<const uint8_t*>(file_identifier),
-                kFileIdentifierLength);
-    }
-    PushElement(ReferTo(root));  // Location of root.
-    if (size_prefix) {
-      PushElement(GetSize());
-    }
-    finished = true;
-  }
-
-  struct FieldLoc {
-    uoffset_t off;
-    voffset_t id;
-  };
-
-  vector_downward<SizeT> buf_;
-
-  // Accumulating offsets of table members while it is being built.
-  // We store these in the scratch pad of buf_, after the vtable offsets.
-  uoffset_t num_field_loc;
-  // Track how much of the vtable is in use, so we can output the most compact
-  // possible vtable.
-  voffset_t max_voffset_;
-
-  // This is the length of the 64-bit region of the buffer. The buffer supports
-  // 64-bit offsets by forcing serialization of those elements in the "tail"
-  // region of the buffer (i.e. "64-bit region"). To properly keep track of
-  // offsets that are referenced from the tail of the buffer to not overflow
-  // their size (e.g. Offset is a uint32_t type), the boundary of the 32-/64-bit
-  // regions must be tracked.
-  //
-  // [    Complete FlatBuffer     ]
-  // [32-bit region][64-bit region]
-  //               ^              ^
-  //               |              Tail of the buffer.
-  //               |
-  //               Tail of the 32-bit region of the buffer.
-  //
-  // This keeps track of the size of the 64-bit region so that the tail of the
-  // 32-bit region can be calculated as `GetSize() - length_of_64_bit_region_`.
-  //
-  // This will remain 0 if no 64-bit offset types are added to the buffer.
-  size_t length_of_64_bit_region_;
-
-  // Ensure objects are not nested.
-  bool nested;
-
-  // Ensure the buffer is finished before it is being accessed.
-  bool finished;
-
-  size_t minalign_;
-
-  bool force_defaults_;  // Serialize values equal to their defaults anyway.
-
-  bool dedup_vtables_;
-
-  struct StringOffsetCompare {
-    explicit StringOffsetCompare(const vector_downward<SizeT>& buf)
-        : buf_(&buf) {}
-    bool operator()(const Offset<String>& a, const Offset<String>& b) const {
-      auto stra = reinterpret_cast<const String*>(buf_->data_at(a.o));
-      auto strb = reinterpret_cast<const String*>(buf_->data_at(b.o));
-      return StringLessThan(stra->data(), stra->size(), strb->data(),
-                            strb->size());
-    }
-    const vector_downward<SizeT>* buf_;
-  };
-
-  // For use with CreateSharedString. Instantiated on first use only.
-  typedef std::set<Offset<String>, StringOffsetCompare> StringOffsetMap;
-  StringOffsetMap* string_pool;
-
- private:
-  void CanAddOffset64() {
-    // If you hit this assertion, you are attempting to add a 64-bit offset to
-    // a 32-bit only builder. This is because the builder has overloads that
-    // differ only on the offset size returned: e.g.:
-    //
-    //   FlatBufferBuilder builder;
-    //   Offset64<String> string_offset = builder.CreateString<Offset64>();
-    //
-    // Either use a 64-bit aware builder, or don't try to create an Offset64
-    // return type.
-    //
-    // TODO(derekbailey): we can probably do more enable_if to avoid this
-    // looking like its possible to the user.
-    static_assert(Is64Aware, "cannot add 64-bit offset to a 32-bit builder");
-
-    // If you hit this assertion, you are attempting to add an 64-bit offset
-    // item after already serializing a 32-bit item. All 64-bit offsets have to
-    // added to the tail of the buffer before any 32-bit items can be added.
-    // Otherwise some items might not be addressable due to the maximum range of
-    // the 32-bit offset.
-    FLATBUFFERS_ASSERT(GetSize() == length_of_64_bit_region_);
-  }
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const char pointer to the data to be stored as a string.
-  /// @param[in] len The number of bytes that should be stored from `str`.
-  /// @return Returns the offset in the buffer where the string starts.
-  void CreateStringImpl(const char* str, size_t len) {
-    NotNested();
-    PreAlign<uoffset_t>(len + 1);  // Always 0-terminated.
-    buf_.fill(1);
-    PushBytes(reinterpret_cast<const uint8_t*>(str), len);
-    PushElement(static_cast<uoffset_t>(len));
-  }
-
-  // Allocates space for a vector of structures.
-  // Must be completed with EndVectorOfStructs().
-  template <typename T, template <typename> class OffsetT = Offset>
-  T* StartVectorOfStructs(size_t vector_size) {
-    StartVector<OffsetT>(vector_size, sizeof(T), AlignOf<T>());
-    return reinterpret_cast<T*>(buf_.make_space(vector_size * sizeof(T)));
-  }
-
-  // End the vector of structures in the flatbuffers.
-  // Vector should have previously be started with StartVectorOfStructs().
-  template <typename T, template <typename> class OffsetT = Offset>
-  OffsetT<Vector<const T*>> EndVectorOfStructs(size_t vector_size) {
-    return OffsetT<Vector<const T*>>(
-        EndVector<typename Vector<const T*>::size_type,
-                  typename OffsetT<Vector<const T*>>::offset_type>(
-            vector_size));
-  }
-
-  template <typename T>
-  typename std::enable_if<std::is_same<T, uoffset_t>::value, T>::type
-  CalculateOffset() {
-    // Default to the end of the 32-bit region. This may or may not be the end
-    // of the buffer, depending on if any 64-bit offsets have been added.
-    return GetSizeRelative32BitRegion();
-  }
-
-  // Specializations to handle the 64-bit CalculateOffset, which is relative to
-  // end of the buffer.
-  template <typename T>
-  typename std::enable_if<std::is_same<T, uoffset64_t>::value, T>::type
-  CalculateOffset() {
-    // This should never be compiled in when not using a 64-bit builder.
-    static_assert(Is64Aware, "invalid 64-bit offset in 32-bit builder");
-
-    // Store how big the 64-bit region of the buffer is, so we can determine
-    // where the 32/64 bit boundary is.
-    length_of_64_bit_region_ = GetSize();
-
-    return length_of_64_bit_region_;
-  }
-};
-/// @}
-
-// Hack to `FlatBufferBuilder` mean `FlatBufferBuilder<false>` or
-// `FlatBufferBuilder<>`, where the template < > syntax is required.
-using FlatBufferBuilder = FlatBufferBuilderImpl<false>;
-using FlatBufferBuilder64 = FlatBufferBuilderImpl<true>;
-
-// These are external due to GCC not allowing them in the class.
-// See: https://stackoverflow.com/q/8061456/868247
-template <>
-template <>
-inline Offset64<String> FlatBufferBuilder64::CreateString(const char* str,
-                                                          size_t len) {
-  CanAddOffset64();
-  CreateStringImpl(str, len);
-  return Offset64<String>(
-      CalculateOffset<typename Offset64<String>::offset_type>());
-}
-
-// Used to distinguish from real Offsets.
-template <typename T = void>
-struct EmptyOffset {};
-
-// TODO(derekbailey): it would be nice to combine these two methods.
-template <>
-template <>
-inline void FlatBufferBuilder64::StartVector<Offset64, uint32_t>(
-    size_t len, size_t elemsize, size_t alignment) {
-  CanAddOffset64();
-  StartVector<EmptyOffset, uint32_t>(len, elemsize, alignment);
-}
-
-template <>
-template <>
-inline void FlatBufferBuilder64::StartVector<Offset64, uint64_t>(
-    size_t len, size_t elemsize, size_t alignment) {
-  CanAddOffset64();
-  StartVector<EmptyOffset, uint64_t>(len, elemsize, alignment);
-}
-
-/// Helpers to get a typed pointer to objects that are currently being built.
-/// @warning Creating new objects will lead to reallocations and invalidates
-/// the pointer!
-template <typename T>
-T* GetMutableTemporaryPointer(FlatBufferBuilder& fbb, Offset<T> offset) {
-  return reinterpret_cast<T*>(fbb.GetCurrentBufferPointer() + fbb.GetSize() -
-                              offset.o);
-}
-
-template <typename T>
-const T* GetTemporaryPointer(const FlatBufferBuilder& fbb, Offset<T> offset) {
-  return reinterpret_cast<const T*>(fbb.GetCurrentBufferPointer() +
-                                    fbb.GetSize() - offset.o);
-}
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_FLATBUFFER_BUILDER_H_
diff --git a/external/flatbuffers/include/flatbuffers/flatbuffers.h b/external/flatbuffers/include/flatbuffers/flatbuffers.h
deleted file mode 100644
index 0d9b5cce..00000000
--- a/external/flatbuffers/include/flatbuffers/flatbuffers.h
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
- * Copyright 2014 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_H_
-#define FLATBUFFERS_H_
-
-#include <algorithm>
-
-// TODO: These includes are for mitigating the pains of users editing their
-// source because they relied on flatbuffers.h to include everything for them.
-#include "flatbuffers/array.h"
-#include "flatbuffers/base.h"
-#include "flatbuffers/buffer.h"
-#include "flatbuffers/buffer_ref.h"
-#include "flatbuffers/detached_buffer.h"
-#include "flatbuffers/flatbuffer_builder.h"
-#include "flatbuffers/stl_emulation.h"
-#include "flatbuffers/string.h"
-#include "flatbuffers/struct.h"
-#include "flatbuffers/table.h"
-#include "flatbuffers/vector.h"
-#include "flatbuffers/vector_downward.h"
-#include "flatbuffers/verifier.h"
-
-namespace flatbuffers {
-
-/// @brief This can compute the start of a FlatBuffer from a root pointer, i.e.
-/// it is the opposite transformation of GetRoot().
-/// This may be useful if you want to pass on a root and have the recipient
-/// delete the buffer afterwards.
-inline const uint8_t* GetBufferStartFromRootPointer(const void* root) {
-  auto table = reinterpret_cast<const Table*>(root);
-  auto vtable = table->GetVTable();
-  // Either the vtable is before the root or after the root.
-  auto start = (std::min)(vtable, reinterpret_cast<const uint8_t*>(root));
-  // Align to at least sizeof(uoffset_t).
-  start = reinterpret_cast<const uint8_t*>(reinterpret_cast<uintptr_t>(start) &
-                                           ~(sizeof(uoffset_t) - 1));
-  // Additionally, there may be a file_identifier in the buffer, and the root
-  // offset. The buffer may have been aligned to any size between
-  // sizeof(uoffset_t) and FLATBUFFERS_MAX_ALIGNMENT (see "force_align").
-  // Sadly, the exact alignment is only known when constructing the buffer,
-  // since it depends on the presence of values with said alignment properties.
-  // So instead, we simply look at the next uoffset_t values (root,
-  // file_identifier, and alignment padding) to see which points to the root.
-  // None of the other values can "impersonate" the root since they will either
-  // be 0 or four ASCII characters.
-  static_assert(flatbuffers::kFileIdentifierLength == sizeof(uoffset_t),
-                "file_identifier is assumed to be the same size as uoffset_t");
-  for (auto possible_roots = FLATBUFFERS_MAX_ALIGNMENT / sizeof(uoffset_t) + 1;
-       possible_roots; possible_roots--) {
-    start -= sizeof(uoffset_t);
-    if (ReadScalar<uoffset_t>(start) + start ==
-        reinterpret_cast<const uint8_t*>(root))
-      return start;
-  }
-  // We didn't find the root, either the "root" passed isn't really a root,
-  // or the buffer is corrupt.
-  // Assert, because calling this function with bad data may cause reads
-  // outside of buffer boundaries.
-  FLATBUFFERS_ASSERT(false);
-  return nullptr;
-}
-
-/// @brief This return the prefixed size of a FlatBuffer.
-template <typename SizeT = uoffset_t>
-inline SizeT GetPrefixedSize(const uint8_t* buf) {
-  return ReadScalar<SizeT>(buf);
-}
-
-// Gets the total length of the buffer given a sized prefixed FlatBuffer.
-//
-// This includes the size of the prefix as well as the buffer:
-//
-//  [size prefix][flatbuffer]
-//  |---------length--------|
-template <typename SizeT = uoffset_t>
-inline SizeT GetSizePrefixedBufferLength(const uint8_t* const buf) {
-  return ReadScalar<SizeT>(buf) + sizeof(SizeT);
-}
-
-// Base class for native objects (FlatBuffer data de-serialized into native
-// C++ data structures).
-// Contains no functionality, purely documentative.
-struct NativeTable {};
-
-/// @brief Function types to be used with resolving hashes into objects and
-/// back again. The resolver gets a pointer to a field inside an object API
-/// object that is of the type specified in the schema using the attribute
-/// `cpp_type` (it is thus important whatever you write to this address
-/// matches that type). The value of this field is initially null, so you
-/// may choose to implement a delayed binding lookup using this function
-/// if you wish. The resolver does the opposite lookup, for when the object
-/// is being serialized again.
-typedef uint64_t hash_value_t;
-typedef std::function<void(void** pointer_adr, hash_value_t hash)>
-    resolver_function_t;
-typedef std::function<hash_value_t(void* pointer)> rehasher_function_t;
-
-// Helper function to test if a field is present, using any of the field
-// enums in the generated code.
-// `table` must be a generated table type. Since this is a template parameter,
-// this is not typechecked to be a subclass of Table, so beware!
-// Note: this function will return false for fields equal to the default
-// value, since they're not stored in the buffer (unless force_defaults was
-// used).
-template <typename T>
-bool IsFieldPresent(const T* table, typename T::FlatBuffersVTableOffset field) {
-  // Cast, since Table is a private baseclass of any table types.
-  return reinterpret_cast<const Table*>(table)->CheckField(
-      static_cast<voffset_t>(field));
-}
-
-// Utility function for reverse lookups on the EnumNames*() functions
-// (in the generated C++ code)
-// names must be NULL terminated.
-inline int LookupEnum(const char** names, const char* name) {
-  for (const char** p = names; *p; p++)
-    if (!strcmp(*p, name)) return static_cast<int>(p - names);
-  return -1;
-}
-
-// These macros allow us to layout a struct with a guarantee that they'll end
-// up looking the same on different compilers and platforms.
-// It does this by disallowing the compiler to do any padding, and then
-// does padding itself by inserting extra padding fields that make every
-// element aligned to its own size.
-// Additionally, it manually sets the alignment of the struct as a whole,
-// which is typically its largest element, or a custom size set in the schema
-// by the force_align attribute.
-// These are used in the generated code only.
-
-// clang-format off
-#if defined(_MSC_VER)
-  #define FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(alignment) \
-    __pragma(pack(1)) \
-    struct __declspec(align(alignment))
-  #define FLATBUFFERS_STRUCT_END(name, size) \
-    __pragma(pack()) \
-    static_assert(sizeof(name) == size, "compiler breaks packing rules")
-#elif defined(__GNUC__) || defined(__clang__) || defined(__ICCARM__)
-  #define FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(alignment) \
-    _Pragma("pack(1)") \
-    struct __attribute__((aligned(alignment)))
-  #define FLATBUFFERS_STRUCT_END(name, size) \
-    _Pragma("pack()") \
-    static_assert(sizeof(name) == size, "compiler breaks packing rules")
-#else
-  #error Unknown compiler, please define structure alignment macros
-#endif
-// clang-format on
-
-// Minimal reflection via code generation.
-// Besides full-fat reflection (see reflection.h) and parsing/printing by
-// loading schemas (see idl.h), we can also have code generation for minimal
-// reflection data which allows pretty-printing and other uses without needing
-// a schema or a parser.
-// Generate code with --reflect-types (types only) or --reflect-names (names
-// also) to enable.
-// See minireflect.h for utilities using this functionality.
-
-// These types are organized slightly differently as the ones in idl.h.
-enum SequenceType { ST_TABLE, ST_STRUCT, ST_UNION, ST_ENUM };
-
-// Scalars have the same order as in idl.h
-// clang-format off
-#define FLATBUFFERS_GEN_ELEMENTARY_TYPES(ET) \
-  ET(ET_UTYPE) \
-  ET(ET_BOOL) \
-  ET(ET_CHAR) \
-  ET(ET_UCHAR) \
-  ET(ET_SHORT) \
-  ET(ET_USHORT) \
-  ET(ET_INT) \
-  ET(ET_UINT) \
-  ET(ET_LONG) \
-  ET(ET_ULONG) \
-  ET(ET_FLOAT) \
-  ET(ET_DOUBLE) \
-  ET(ET_STRING) \
-  ET(ET_SEQUENCE)  // See SequenceType.
-
-enum ElementaryType {
-  #define FLATBUFFERS_ET(E) E,
-    FLATBUFFERS_GEN_ELEMENTARY_TYPES(FLATBUFFERS_ET)
-  #undef FLATBUFFERS_ET
-};
-
-inline const char * const *ElementaryTypeNames() {
-  static const char * const names[] = {
-    #define FLATBUFFERS_ET(E) #E,
-      FLATBUFFERS_GEN_ELEMENTARY_TYPES(FLATBUFFERS_ET)
-    #undef FLATBUFFERS_ET
-  };
-  return names;
-}
-// clang-format on
-
-// Basic type info cost just 16bits per field!
-// We're explicitly defining the signedness since the signedness of integer
-// bitfields is otherwise implementation-defined and causes warnings on older
-// GCC compilers.
-struct TypeCode {
-  // ElementaryType
-  unsigned short base_type : 4;
-  // Either vector (in table) or array (in struct)
-  unsigned short is_repeating : 1;
-  // Index into type_refs below, or -1 for none.
-  signed short sequence_ref : 11;
-};
-
-static_assert(sizeof(TypeCode) == 2, "TypeCode");
-
-struct TypeTable;
-
-// Signature of the static method present in each type.
-typedef const TypeTable* (*TypeFunction)();
-
-struct TypeTable {
-  SequenceType st;
-  size_t num_elems;  // of type_codes, values, names (but not type_refs).
-  const TypeCode* type_codes;     // num_elems count
-  const TypeFunction* type_refs;  // less than num_elems entries (see TypeCode).
-  const int16_t* array_sizes;     // less than num_elems entries (see TypeCode).
-  const int64_t* values;  // Only set for non-consecutive enum/union or structs.
-  const char* const* names;  // Only set if compiled with --reflect-names.
-};
-
-// String which identifies the current version of FlatBuffers.
-inline const char* flatbuffers_version_string() {
-  return "FlatBuffers " FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MAJOR) "."
-      FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MINOR) "."
-      FLATBUFFERS_STRING(FLATBUFFERS_VERSION_REVISION);
-}
-
-// clang-format off
-#define FLATBUFFERS_DEFINE_BITMASK_OPERATORS(E, T)\
-    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator | (E lhs, E rhs){\
-        return E(T(lhs) | T(rhs));\
-    }\
-    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator & (E lhs, E rhs){\
-        return E(T(lhs) & T(rhs));\
-    }\
-    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator ^ (E lhs, E rhs){\
-        return E(T(lhs) ^ T(rhs));\
-    }\
-    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator ~ (E lhs){\
-        return E(~T(lhs));\
-    }\
-    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator |= (E &lhs, E rhs){\
-        lhs = lhs | rhs;\
-        return lhs;\
-    }\
-    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator &= (E &lhs, E rhs){\
-        lhs = lhs & rhs;\
-        return lhs;\
-    }\
-    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator ^= (E &lhs, E rhs){\
-        lhs = lhs ^ rhs;\
-        return lhs;\
-    }\
-    inline FLATBUFFERS_CONSTEXPR_CPP11 bool operator !(E rhs) \
-    {\
-        return !bool(T(rhs)); \
-    }
-/// @endcond
-}  // namespace flatbuffers
-
-// clang-format on
-
-#endif  // FLATBUFFERS_H_
diff --git a/external/flatbuffers/include/flatbuffers/flatc.h b/external/flatbuffers/include/flatbuffers/flatc.h
deleted file mode 100644
index da24762c..00000000
--- a/external/flatbuffers/include/flatbuffers/flatc.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright 2017 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_FLATC_H_
-#define FLATBUFFERS_FLATC_H_
-
-#include <functional>
-#include <limits>
-#include <list>
-#include <memory>
-#include <string>
-
-#include "flatbuffers/code_generator.h"
-#include "flatbuffers/flatbuffers.h"
-#include "flatbuffers/idl.h"
-#include "flatbuffers/util.h"
-
-namespace flatbuffers {
-
-extern void LogCompilerWarn(const std::string& warn);
-extern void LogCompilerError(const std::string& err);
-
-struct FlatCOptions {
-  IDLOptions opts;
-
-  std::string program_name;
-
-  std::string output_path;
-
-  std::vector<std::string> filenames;
-
-  std::list<std::string> include_directories_storage;
-  std::vector<const char*> include_directories;
-  std::vector<const char*> conform_include_directories;
-  std::vector<bool> generator_enabled;
-  size_t binary_files_from = std::numeric_limits<size_t>::max();
-  std::string conform_to_schema;
-  std::string annotate_schema;
-  bool annotate_include_vector_contents = true;
-  bool any_generator = false;
-  bool print_make_rules = false;
-  bool raw_binary = false;
-  bool schema_binary = false;
-  bool grpc_enabled = false;
-  bool requires_bfbs = false;
-  bool file_names_only = false;
-
-  std::vector<std::shared_ptr<CodeGenerator>> generators;
-};
-
-struct FlatCOption {
-  std::string short_opt;
-  std::string long_opt;
-  std::string parameter;
-  std::string description;
-};
-
-class FlatCompiler {
- public:
-  typedef void (*WarnFn)(const FlatCompiler* flatc, const std::string& warn,
-                         bool show_exe_name);
-
-  typedef void (*ErrorFn)(const FlatCompiler* flatc, const std::string& err,
-                          bool usage, bool show_exe_name);
-
-  // Parameters required to initialize the FlatCompiler.
-  struct InitParams {
-    InitParams() : warn_fn(nullptr), error_fn(nullptr) {}
-
-    WarnFn warn_fn;
-    ErrorFn error_fn;
-  };
-
-  explicit FlatCompiler(const InitParams& params) : params_(params) {}
-
-  bool RegisterCodeGenerator(const FlatCOption& option,
-                             std::shared_ptr<CodeGenerator> code_generator);
-
-  int Compile(const FlatCOptions& options);
-
-  std::string GetShortUsageString(const std::string& program_name) const;
-  std::string GetUsageString(const std::string& program_name) const;
-
-  // Parse the FlatC options from command line arguments.
-  FlatCOptions ParseFromCommandLineArguments(int argc, const char** argv);
-
- private:
-  void ParseFile(flatbuffers::Parser& parser, const std::string& filename,
-                 const std::string& contents,
-                 const std::vector<const char*>& include_directories) const;
-
-  void LoadBinarySchema(Parser& parser, const std::string& filename,
-                        const std::string& contents);
-
-  void Warn(const std::string& warn, bool show_exe_name = true) const;
-
-  void Error(const std::string& err, bool usage = true,
-             bool show_exe_name = true) const;
-
-  void AnnotateBinaries(const uint8_t* binary_schema,
-                        uint64_t binary_schema_size,
-                        const FlatCOptions& options);
-
-  void ValidateOptions(const FlatCOptions& options);
-
-  Parser GetConformParser(const FlatCOptions& options);
-
-  std::unique_ptr<Parser> GenerateCode(const FlatCOptions& options,
-                                       Parser& conform_parser);
-
-  std::map<std::string, std::shared_ptr<CodeGenerator>> code_generators_;
-
-  InitParams params_;
-};
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_FLATC_H_
diff --git a/external/flatbuffers/include/flatbuffers/flex_flat_util.h b/external/flatbuffers/include/flatbuffers/flex_flat_util.h
deleted file mode 100644
index 70c0a458..00000000
--- a/external/flatbuffers/include/flatbuffers/flex_flat_util.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright 2022 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_FLEX_FLAT_UTIL_H_
-#define FLATBUFFERS_FLEX_FLAT_UTIL_H_
-
-#include "flatbuffers/flatbuffers.h"
-#include "flatbuffers/flexbuffers.h"
-
-namespace flexbuffers {
-
-// Verifies the `nested` flexbuffer within a flatbuffer vector is valid.
-template <bool B>
-inline bool VerifyNestedFlexBuffer(
-    const flatbuffers::Vector<uint8_t>* const nested,
-    flatbuffers::VerifierTemplate<B>& verifier) {
-  if (!nested) return true;
-  return verifier.Check(flexbuffers::VerifyBuffer(
-      nested->data(), nested->size(), verifier.GetFlexReuseTracker()));
-}
-
-}  // namespace flexbuffers
-
-#endif  // FLATBUFFERS_FLEX_FLAT_UTIL_H_
diff --git a/external/flatbuffers/include/flatbuffers/flexbuffers.h b/external/flatbuffers/include/flatbuffers/flexbuffers.h
deleted file mode 100644
index 5c42a7ed..00000000
--- a/external/flatbuffers/include/flatbuffers/flexbuffers.h
+++ /dev/null
@@ -1,2086 +0,0 @@
-/*
- * Copyright 2017 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_FLEXBUFFERS_H_
-#define FLATBUFFERS_FLEXBUFFERS_H_
-
-#include <algorithm>
-#include <map>
-// Used to select STL variant.
-#include "flatbuffers/base.h"
-// We use the basic binary writing functions from the regular FlatBuffers.
-#include "flatbuffers/util.h"
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4127)  // C4127: conditional expression is constant
-#endif
-
-namespace flexbuffers {
-
-class Reference;
-class Map;
-
-// These are used in the lower 2 bits of a type field to determine the size of
-// the elements (and or size field) of the item pointed to (e.g. vector).
-enum BitWidth {
-  BIT_WIDTH_8 = 0,
-  BIT_WIDTH_16 = 1,
-  BIT_WIDTH_32 = 2,
-  BIT_WIDTH_64 = 3,
-};
-
-// These are used as the upper 6 bits of a type field to indicate the actual
-// type.
-enum Type {
-  FBT_NULL = 0,
-  FBT_INT = 1,
-  FBT_UINT = 2,
-  FBT_FLOAT = 3,
-  // Types above stored inline, types below (except FBT_BOOL) store an offset.
-  FBT_KEY = 4,
-  FBT_STRING = 5,
-  FBT_INDIRECT_INT = 6,
-  FBT_INDIRECT_UINT = 7,
-  FBT_INDIRECT_FLOAT = 8,
-  FBT_MAP = 9,
-  FBT_VECTOR = 10,      // Untyped.
-  FBT_VECTOR_INT = 11,  // Typed any size (stores no type table).
-  FBT_VECTOR_UINT = 12,
-  FBT_VECTOR_FLOAT = 13,
-  FBT_VECTOR_KEY = 14,
-  // DEPRECATED, use FBT_VECTOR or FBT_VECTOR_KEY instead.
-  // Read test.cpp/FlexBuffersDeprecatedTest() for details on why.
-  FBT_VECTOR_STRING_DEPRECATED = 15,
-  FBT_VECTOR_INT2 = 16,  // Typed tuple (no type table, no size field).
-  FBT_VECTOR_UINT2 = 17,
-  FBT_VECTOR_FLOAT2 = 18,
-  FBT_VECTOR_INT3 = 19,  // Typed triple (no type table, no size field).
-  FBT_VECTOR_UINT3 = 20,
-  FBT_VECTOR_FLOAT3 = 21,
-  FBT_VECTOR_INT4 = 22,  // Typed quad (no type table, no size field).
-  FBT_VECTOR_UINT4 = 23,
-  FBT_VECTOR_FLOAT4 = 24,
-  FBT_BLOB = 25,
-  FBT_BOOL = 26,
-  FBT_VECTOR_BOOL =
-      36,  // To Allow the same type of conversion of type to vector type
-
-  FBT_MAX_TYPE = 37
-};
-
-inline bool IsInline(Type t) { return t <= FBT_FLOAT || t == FBT_BOOL; }
-
-inline bool IsTypedVectorElementType(Type t) {
-  return (t >= FBT_INT && t <= FBT_STRING) || t == FBT_BOOL;
-}
-
-inline bool IsTypedVector(Type t) {
-  return (t >= FBT_VECTOR_INT && t <= FBT_VECTOR_STRING_DEPRECATED) ||
-         t == FBT_VECTOR_BOOL;
-}
-
-inline bool IsFixedTypedVector(Type t) {
-  return t >= FBT_VECTOR_INT2 && t <= FBT_VECTOR_FLOAT4;
-}
-
-inline Type ToTypedVector(Type t, size_t fixed_len = 0) {
-  FLATBUFFERS_ASSERT(IsTypedVectorElementType(t));
-  switch (fixed_len) {
-    case 0:
-      return static_cast<Type>(t - FBT_INT + FBT_VECTOR_INT);
-    case 2:
-      return static_cast<Type>(t - FBT_INT + FBT_VECTOR_INT2);
-    case 3:
-      return static_cast<Type>(t - FBT_INT + FBT_VECTOR_INT3);
-    case 4:
-      return static_cast<Type>(t - FBT_INT + FBT_VECTOR_INT4);
-    default:
-      FLATBUFFERS_ASSERT(0);
-      return FBT_NULL;
-  }
-}
-
-inline Type ToTypedVectorElementType(Type t) {
-  FLATBUFFERS_ASSERT(IsTypedVector(t));
-  return static_cast<Type>(t - FBT_VECTOR_INT + FBT_INT);
-}
-
-inline Type ToFixedTypedVectorElementType(Type t, uint8_t* len) {
-  FLATBUFFERS_ASSERT(IsFixedTypedVector(t));
-  auto fixed_type = t - FBT_VECTOR_INT2;
-  *len = static_cast<uint8_t>(fixed_type / 3 +
-                              2);  // 3 types each, starting from length 2.
-  return static_cast<Type>(fixed_type % 3 + FBT_INT);
-}
-
-// TODO: implement proper support for 8/16bit floats, or decide not to
-// support them.
-typedef int16_t half;
-typedef int8_t quarter;
-
-// TODO: can we do this without conditionals using intrinsics or inline asm
-// on some platforms? Given branch prediction the method below should be
-// decently quick, but it is the most frequently executed function.
-// We could do an (unaligned) 64-bit read if we ifdef out the platforms for
-// which that doesn't work (or where we'd read into un-owned memory).
-template <typename R, typename T1, typename T2, typename T4, typename T8>
-R ReadSizedScalar(const uint8_t* data, uint8_t byte_width) {
-  return byte_width < 4
-             ? (byte_width < 2
-                    ? static_cast<R>(flatbuffers::ReadScalar<T1>(data))
-                    : static_cast<R>(flatbuffers::ReadScalar<T2>(data)))
-             : (byte_width < 8
-                    ? static_cast<R>(flatbuffers::ReadScalar<T4>(data))
-                    : static_cast<R>(flatbuffers::ReadScalar<T8>(data)));
-}
-
-inline int64_t ReadInt64(const uint8_t* data, uint8_t byte_width) {
-  return ReadSizedScalar<int64_t, int8_t, int16_t, int32_t, int64_t>(
-      data, byte_width);
-}
-
-inline uint64_t ReadUInt64(const uint8_t* data, uint8_t byte_width) {
-  // This is the "hottest" function (all offset lookups use this), so worth
-  // optimizing if possible.
-  // TODO: GCC apparently replaces memcpy by a rep movsb, but only if count is a
-  // constant, which here it isn't. Test if memcpy is still faster than
-  // the conditionals in ReadSizedScalar. Can also use inline asm.
-
-  // clang-format off
-  #if defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
-  // This is 64-bit Windows only, __movsb does not work on 32-bit Windows.
-    uint64_t u = 0;
-    __movsb(reinterpret_cast<uint8_t *>(&u),
-            reinterpret_cast<const uint8_t *>(data), byte_width);
-    return flatbuffers::EndianScalar(u);
-  #else
-    return ReadSizedScalar<uint64_t, uint8_t, uint16_t, uint32_t, uint64_t>(
-             data, byte_width);
-  #endif
-  // clang-format on
-}
-
-inline double ReadDouble(const uint8_t* data, uint8_t byte_width) {
-  return ReadSizedScalar<double, quarter, half, float, double>(data,
-                                                               byte_width);
-}
-
-inline const uint8_t* Indirect(const uint8_t* offset, uint8_t byte_width) {
-  return offset - ReadUInt64(offset, byte_width);
-}
-
-template <typename T>
-const uint8_t* Indirect(const uint8_t* offset) {
-  return offset - flatbuffers::ReadScalar<T>(offset);
-}
-
-inline BitWidth WidthU(uint64_t u) {
-#define FLATBUFFERS_GET_FIELD_BIT_WIDTH(value, width)                   \
-  {                                                                     \
-    if (!((u) & ~((1ULL << (width)) - 1ULL))) return BIT_WIDTH_##width; \
-  }
-  FLATBUFFERS_GET_FIELD_BIT_WIDTH(u, 8);
-  FLATBUFFERS_GET_FIELD_BIT_WIDTH(u, 16);
-  FLATBUFFERS_GET_FIELD_BIT_WIDTH(u, 32);
-#undef FLATBUFFERS_GET_FIELD_BIT_WIDTH
-  return BIT_WIDTH_64;
-}
-
-inline BitWidth WidthI(int64_t i) {
-  auto u = static_cast<uint64_t>(i) << 1;
-  return WidthU(i >= 0 ? u : ~u);
-}
-
-inline BitWidth WidthF(double f) {
-  return static_cast<double>(static_cast<float>(f)) == f ? BIT_WIDTH_32
-                                                         : BIT_WIDTH_64;
-}
-
-// Base class of all types below.
-// Points into the data buffer and allows access to one type.
-class Object {
- public:
-  Object(const uint8_t* data, uint8_t byte_width)
-      : data_(data), byte_width_(byte_width) {}
-
- protected:
-  const uint8_t* data_;
-  uint8_t byte_width_;
-};
-
-// Object that has a size, obtained either from size prefix, or elsewhere.
-class Sized : public Object {
- public:
-  // Size prefix.
-  Sized(const uint8_t* data, uint8_t byte_width)
-      : Object(data, byte_width), size_(read_size()) {}
-  // Manual size.
-  Sized(const uint8_t* data, uint8_t byte_width, size_t sz)
-      : Object(data, byte_width), size_(sz) {}
-  size_t size() const { return size_; }
-  // Access size stored in `byte_width_` bytes before data_ pointer.
-  size_t read_size() const {
-    return static_cast<size_t>(ReadUInt64(data_ - byte_width_, byte_width_));
-  }
-
- protected:
-  size_t size_;
-};
-
-class String : public Sized {
- public:
-  // Size prefix.
-  String(const uint8_t* data, uint8_t byte_width) : Sized(data, byte_width) {}
-  // Manual size.
-  String(const uint8_t* data, uint8_t byte_width, size_t sz)
-      : Sized(data, byte_width, sz) {}
-
-  size_t length() const { return size(); }
-  const char* c_str() const { return reinterpret_cast<const char*>(data_); }
-  std::string str() const { return std::string(c_str(), size()); }
-
-  static String EmptyString() {
-    static const char* empty_string = "";
-    return String(reinterpret_cast<const uint8_t*>(empty_string), 1, 0);
-  }
-  bool IsTheEmptyString() const { return data_ == EmptyString().data_; }
-};
-
-class Blob : public Sized {
- public:
-  Blob(const uint8_t* data_buf, uint8_t byte_width)
-      : Sized(data_buf, byte_width) {}
-
-  static Blob EmptyBlob() {
-    static const uint8_t empty_blob[] = {0 /*len*/};
-    return Blob(empty_blob + 1, 1);
-  }
-  bool IsTheEmptyBlob() const { return data_ == EmptyBlob().data_; }
-  const uint8_t* data() const { return data_; }
-};
-
-class Vector : public Sized {
- public:
-  Vector(const uint8_t* data, uint8_t byte_width) : Sized(data, byte_width) {}
-
-  Reference operator[](size_t i) const;
-
-  static Vector EmptyVector() {
-    static const uint8_t empty_vector[] = {0 /*len*/};
-    return Vector(empty_vector + 1, 1);
-  }
-  bool IsTheEmptyVector() const { return data_ == EmptyVector().data_; }
-};
-
-class TypedVector : public Sized {
- public:
-  TypedVector(const uint8_t* data, uint8_t byte_width, Type element_type)
-      : Sized(data, byte_width), type_(element_type) {}
-
-  Reference operator[](size_t i) const;
-
-  static TypedVector EmptyTypedVector() {
-    static const uint8_t empty_typed_vector[] = {0 /*len*/};
-    return TypedVector(empty_typed_vector + 1, 1, FBT_INT);
-  }
-  bool IsTheEmptyVector() const {
-    return data_ == TypedVector::EmptyTypedVector().data_;
-  }
-
-  Type ElementType() { return type_; }
-
-  friend Reference;
-
- private:
-  Type type_;
-
-  friend Map;
-};
-
-class FixedTypedVector : public Object {
- public:
-  FixedTypedVector(const uint8_t* data, uint8_t byte_width, Type element_type,
-                   uint8_t len)
-      : Object(data, byte_width), type_(element_type), len_(len) {}
-
-  Reference operator[](size_t i) const;
-
-  static FixedTypedVector EmptyFixedTypedVector() {
-    static const uint8_t fixed_empty_vector[] = {0 /* unused */};
-    return FixedTypedVector(fixed_empty_vector, 1, FBT_INT, 0);
-  }
-  bool IsTheEmptyFixedTypedVector() const {
-    return data_ == FixedTypedVector::EmptyFixedTypedVector().data_;
-  }
-
-  Type ElementType() const { return type_; }
-  uint8_t size() const { return len_; }
-
- private:
-  Type type_;
-  uint8_t len_;
-};
-
-class Map : public Vector {
- public:
-  Map(const uint8_t* data, uint8_t byte_width) : Vector(data, byte_width) {}
-
-  Reference operator[](const char* key) const;
-  Reference operator[](const std::string& key) const;
-
-  Vector Values() const { return Vector(data_, byte_width_); }
-
-  TypedVector Keys() const {
-    const size_t num_prefixed_fields = 3;
-    auto keys_offset = data_ - byte_width_ * num_prefixed_fields;
-    return TypedVector(Indirect(keys_offset, byte_width_),
-                       static_cast<uint8_t>(
-                           ReadUInt64(keys_offset + byte_width_, byte_width_)),
-                       FBT_KEY);
-  }
-
-  static Map EmptyMap() {
-    static const uint8_t empty_map[] = {
-        0 /*keys_len*/, 0 /*keys_offset*/, 1 /*keys_width*/, 0 /*len*/
-    };
-    return Map(empty_map + 4, 1);
-  }
-
-  bool IsTheEmptyMap() const { return data_ == EmptyMap().data_; }
-};
-
-inline void IndentString(std::string& s, int indent,
-                         const char* indent_string) {
-  for (int i = 0; i < indent; i++) s += indent_string;
-}
-
-template <typename T>
-void AppendToString(std::string& s, T&& v, bool keys_quoted, bool indented,
-                    int cur_indent, const char* indent_string,
-                    bool natural_utf8) {
-  s += "[";
-  s += indented ? "\n" : " ";
-  for (size_t i = 0; i < v.size(); i++) {
-    if (i) {
-      s += ",";
-      s += indented ? "\n" : " ";
-    }
-    if (indented) IndentString(s, cur_indent, indent_string);
-    v[i].ToString(true, keys_quoted, s, indented, cur_indent, indent_string,
-                  natural_utf8);
-  }
-  if (indented) {
-    s += "\n";
-    IndentString(s, cur_indent - 1, indent_string);
-  } else {
-    s += " ";
-  }
-  s += "]";
-}
-
-template <typename T>
-void AppendToString(std::string& s, T&& v, bool keys_quoted) {
-  AppendToString(s, v, keys_quoted);
-}
-
-class Reference {
- public:
-  Reference()
-      : data_(nullptr), parent_width_(0), byte_width_(0), type_(FBT_NULL) {}
-
-  Reference(const uint8_t* data, uint8_t parent_width, uint8_t byte_width,
-            Type type)
-      : data_(data),
-        parent_width_(parent_width),
-        byte_width_(byte_width),
-        type_(type) {}
-
-  Reference(const uint8_t* data, uint8_t parent_width, uint8_t packed_type)
-      : data_(data),
-        parent_width_(parent_width),
-        byte_width_(static_cast<uint8_t>(1 << (packed_type & 3))),
-        type_(static_cast<Type>(packed_type >> 2)) {}
-
-  Type GetType() const { return type_; }
-
-  bool IsNull() const { return type_ == FBT_NULL; }
-  bool IsBool() const { return type_ == FBT_BOOL; }
-  bool IsInt() const { return type_ == FBT_INT || type_ == FBT_INDIRECT_INT; }
-  bool IsUInt() const {
-    return type_ == FBT_UINT || type_ == FBT_INDIRECT_UINT;
-  }
-  bool IsIntOrUint() const { return IsInt() || IsUInt(); }
-  bool IsFloat() const {
-    return type_ == FBT_FLOAT || type_ == FBT_INDIRECT_FLOAT;
-  }
-  bool IsNumeric() const { return IsIntOrUint() || IsFloat(); }
-  bool IsString() const { return type_ == FBT_STRING; }
-  bool IsKey() const { return type_ == FBT_KEY; }
-  bool IsVector() const { return type_ == FBT_VECTOR || type_ == FBT_MAP; }
-  bool IsUntypedVector() const { return type_ == FBT_VECTOR; }
-  bool IsTypedVector() const { return flexbuffers::IsTypedVector(type_); }
-  bool IsFixedTypedVector() const {
-    return flexbuffers::IsFixedTypedVector(type_);
-  }
-  bool IsAnyVector() const {
-    return (IsTypedVector() || IsFixedTypedVector() || IsVector());
-  }
-  bool IsMap() const { return type_ == FBT_MAP; }
-  bool IsBlob() const { return type_ == FBT_BLOB; }
-  bool AsBool() const {
-    return (type_ == FBT_BOOL ? ReadUInt64(data_, parent_width_)
-                              : AsUInt64()) != 0;
-  }
-
-  // Reads any type as a int64_t. Never fails, does most sensible conversion.
-  // Truncates floats, strings are attempted to be parsed for a number,
-  // vectors/maps return their size. Returns 0 if all else fails.
-  int64_t AsInt64() const {
-    if (type_ == FBT_INT) {
-      // A fast path for the common case.
-      return ReadInt64(data_, parent_width_);
-    } else
-      switch (type_) {
-        case FBT_INDIRECT_INT:
-          return ReadInt64(Indirect(), byte_width_);
-        case FBT_UINT:
-          return ReadUInt64(data_, parent_width_);
-        case FBT_INDIRECT_UINT:
-          return ReadUInt64(Indirect(), byte_width_);
-        case FBT_FLOAT:
-          return static_cast<int64_t>(ReadDouble(data_, parent_width_));
-        case FBT_INDIRECT_FLOAT:
-          return static_cast<int64_t>(ReadDouble(Indirect(), byte_width_));
-        case FBT_NULL:
-          return 0;
-        case FBT_STRING:
-          return flatbuffers::StringToInt(AsString().c_str());
-        case FBT_VECTOR:
-          return static_cast<int64_t>(AsVector().size());
-        case FBT_BOOL:
-          return ReadInt64(data_, parent_width_);
-        default:
-          // Convert other things to int.
-          return 0;
-      }
-  }
-
-  // TODO: could specialize these to not use AsInt64() if that saves
-  // extension ops in generated code, and use a faster op than ReadInt64.
-  int32_t AsInt32() const { return static_cast<int32_t>(AsInt64()); }
-  int16_t AsInt16() const { return static_cast<int16_t>(AsInt64()); }
-  int8_t AsInt8() const { return static_cast<int8_t>(AsInt64()); }
-
-  uint64_t AsUInt64() const {
-    if (type_ == FBT_UINT) {
-      // A fast path for the common case.
-      return ReadUInt64(data_, parent_width_);
-    } else
-      switch (type_) {
-        case FBT_INDIRECT_UINT:
-          return ReadUInt64(Indirect(), byte_width_);
-        case FBT_INT:
-          return ReadInt64(data_, parent_width_);
-        case FBT_INDIRECT_INT:
-          return ReadInt64(Indirect(), byte_width_);
-        case FBT_FLOAT:
-          return static_cast<uint64_t>(ReadDouble(data_, parent_width_));
-        case FBT_INDIRECT_FLOAT:
-          return static_cast<uint64_t>(ReadDouble(Indirect(), byte_width_));
-        case FBT_NULL:
-          return 0;
-        case FBT_STRING:
-          return flatbuffers::StringToUInt(AsString().c_str());
-        case FBT_VECTOR:
-          return static_cast<uint64_t>(AsVector().size());
-        case FBT_BOOL:
-          return ReadUInt64(data_, parent_width_);
-        default:
-          // Convert other things to uint.
-          return 0;
-      }
-  }
-
-  uint32_t AsUInt32() const { return static_cast<uint32_t>(AsUInt64()); }
-  uint16_t AsUInt16() const { return static_cast<uint16_t>(AsUInt64()); }
-  uint8_t AsUInt8() const { return static_cast<uint8_t>(AsUInt64()); }
-
-  double AsDouble() const {
-    if (type_ == FBT_FLOAT) {
-      // A fast path for the common case.
-      return ReadDouble(data_, parent_width_);
-    } else
-      switch (type_) {
-        case FBT_INDIRECT_FLOAT:
-          return ReadDouble(Indirect(), byte_width_);
-        case FBT_INT:
-          return static_cast<double>(ReadInt64(data_, parent_width_));
-        case FBT_UINT:
-          return static_cast<double>(ReadUInt64(data_, parent_width_));
-        case FBT_INDIRECT_INT:
-          return static_cast<double>(ReadInt64(Indirect(), byte_width_));
-        case FBT_INDIRECT_UINT:
-          return static_cast<double>(ReadUInt64(Indirect(), byte_width_));
-        case FBT_NULL:
-          return 0.0;
-        case FBT_STRING: {
-          double d;
-          flatbuffers::StringToNumber(AsString().c_str(), &d);
-          return d;
-        }
-        case FBT_VECTOR:
-          return static_cast<double>(AsVector().size());
-        case FBT_BOOL:
-          return static_cast<double>(ReadUInt64(data_, parent_width_));
-        default:
-          // Convert strings and other things to float.
-          return 0;
-      }
-  }
-
-  float AsFloat() const { return static_cast<float>(AsDouble()); }
-
-  const char* AsKey() const {
-    if (type_ == FBT_KEY || type_ == FBT_STRING) {
-      return reinterpret_cast<const char*>(Indirect());
-    } else {
-      return "";
-    }
-  }
-
-  // This function returns the empty string if you try to read something that
-  // is not a string or key.
-  String AsString() const {
-    if (type_ == FBT_STRING) {
-      return String(Indirect(), byte_width_);
-    } else if (type_ == FBT_KEY) {
-      auto key = Indirect();
-      return String(key, byte_width_,
-                    strlen(reinterpret_cast<const char*>(key)));
-    } else {
-      return String::EmptyString();
-    }
-  }
-
-  // Unlike AsString(), this will convert any type to a std::string.
-  std::string ToString() const {
-    std::string s;
-    ToString(false, false, s);
-    return s;
-  }
-
-  // Convert any type to a JSON-like string. strings_quoted determines if
-  // string values at the top level receive "" quotes (inside other values
-  // they always do). keys_quoted determines if keys are quoted, at any level.
-  void ToString(bool strings_quoted, bool keys_quoted, std::string& s) const {
-    ToString(strings_quoted, keys_quoted, s, false, 0, "", false);
-  }
-
-  // This version additionally allow you to specify if you want indentation.
-  void ToString(bool strings_quoted, bool keys_quoted, std::string& s,
-                bool indented, int cur_indent, const char* indent_string,
-                bool natural_utf8 = false) const {
-    if (type_ == FBT_STRING) {
-      String str(Indirect(), byte_width_);
-      if (strings_quoted) {
-        flatbuffers::EscapeString(str.c_str(), str.length(), &s, true,
-                                  natural_utf8);
-      } else {
-        s.append(str.c_str(), str.length());
-      }
-    } else if (IsKey()) {
-      auto str = AsKey();
-      if (keys_quoted) {
-        flatbuffers::EscapeString(str, strlen(str), &s, true, natural_utf8);
-      } else {
-        s += str;
-      }
-    } else if (IsInt()) {
-      s += flatbuffers::NumToString(AsInt64());
-    } else if (IsUInt()) {
-      s += flatbuffers::NumToString(AsUInt64());
-    } else if (IsFloat()) {
-      s += flatbuffers::NumToString(AsDouble());
-    } else if (IsNull()) {
-      s += "null";
-    } else if (IsBool()) {
-      s += AsBool() ? "true" : "false";
-    } else if (IsMap()) {
-      s += "{";
-      s += indented ? "\n" : " ";
-      auto m = AsMap();
-      auto keys = m.Keys();
-      auto vals = m.Values();
-      for (size_t i = 0; i < keys.size(); i++) {
-        bool kq = keys_quoted;
-        if (!kq) {
-          // FlexBuffers keys may contain arbitrary characters, only allow
-          // unquoted if it looks like an "identifier":
-          const char* p = keys[i].AsKey();
-          if (!flatbuffers::is_alpha(*p) && *p != '_') {
-            kq = true;
-          } else {
-            while (*++p) {
-              if (!flatbuffers::is_alnum(*p) && *p != '_') {
-                kq = true;
-                break;
-              }
-            }
-          }
-        }
-        if (indented) IndentString(s, cur_indent + 1, indent_string);
-        keys[i].ToString(true, kq, s);
-        s += ": ";
-        vals[i].ToString(true, keys_quoted, s, indented, cur_indent + 1,
-                         indent_string, natural_utf8);
-        if (i < keys.size() - 1) {
-          s += ",";
-          if (!indented) s += " ";
-        }
-        if (indented) s += "\n";
-      }
-      if (!indented) s += " ";
-      if (indented) IndentString(s, cur_indent, indent_string);
-      s += "}";
-    } else if (IsVector()) {
-      AppendToString<Vector>(s, AsVector(), keys_quoted, indented,
-                             cur_indent + 1, indent_string, natural_utf8);
-    } else if (IsTypedVector()) {
-      AppendToString<TypedVector>(s, AsTypedVector(), keys_quoted, indented,
-                                  cur_indent + 1, indent_string, natural_utf8);
-    } else if (IsFixedTypedVector()) {
-      AppendToString<FixedTypedVector>(s, AsFixedTypedVector(), keys_quoted,
-                                       indented, cur_indent + 1, indent_string,
-                                       natural_utf8);
-    } else if (IsBlob()) {
-      auto blob = AsBlob();
-      flatbuffers::EscapeString(reinterpret_cast<const char*>(blob.data()),
-                                blob.size(), &s, true, false);
-    } else {
-      s += "(?)";
-    }
-  }
-
-  // This function returns the empty blob if you try to read a not-blob.
-  // Strings can be viewed as blobs too.
-  Blob AsBlob() const {
-    if (type_ == FBT_BLOB || type_ == FBT_STRING) {
-      return Blob(Indirect(), byte_width_);
-    } else {
-      return Blob::EmptyBlob();
-    }
-  }
-
-  // This function returns the empty vector if you try to read a not-vector.
-  // Maps can be viewed as vectors too.
-  Vector AsVector() const {
-    if (type_ == FBT_VECTOR || type_ == FBT_MAP) {
-      return Vector(Indirect(), byte_width_);
-    } else {
-      return Vector::EmptyVector();
-    }
-  }
-
-  TypedVector AsTypedVector() const {
-    if (IsTypedVector()) {
-      auto tv =
-          TypedVector(Indirect(), byte_width_, ToTypedVectorElementType(type_));
-      if (tv.type_ == FBT_STRING) {
-        // These can't be accessed as strings, since we don't know the bit-width
-        // of the size field, see the declaration of
-        // FBT_VECTOR_STRING_DEPRECATED above for details.
-        // We change the type here to be keys, which are a subtype of strings,
-        // and will ignore the size field. This will truncate strings with
-        // embedded nulls.
-        tv.type_ = FBT_KEY;
-      }
-      return tv;
-    } else {
-      return TypedVector::EmptyTypedVector();
-    }
-  }
-
-  FixedTypedVector AsFixedTypedVector() const {
-    if (IsFixedTypedVector()) {
-      uint8_t len = 0;
-      auto vtype = ToFixedTypedVectorElementType(type_, &len);
-      return FixedTypedVector(Indirect(), byte_width_, vtype, len);
-    } else {
-      return FixedTypedVector::EmptyFixedTypedVector();
-    }
-  }
-
-  Map AsMap() const {
-    if (type_ == FBT_MAP) {
-      return Map(Indirect(), byte_width_);
-    } else {
-      return Map::EmptyMap();
-    }
-  }
-
-  template <typename T>
-  T As() const;
-
-  // Experimental: Mutation functions.
-  // These allow scalars in an already created buffer to be updated in-place.
-  // Since by default scalars are stored in the smallest possible space,
-  // the new value may not fit, in which case these functions return false.
-  // To avoid this, you can construct the values you intend to mutate using
-  // Builder::ForceMinimumBitWidth.
-  bool MutateInt(int64_t i) {
-    if (type_ == FBT_INT) {
-      return Mutate(data_, i, parent_width_, WidthI(i));
-    } else if (type_ == FBT_INDIRECT_INT) {
-      return Mutate(Indirect(), i, byte_width_, WidthI(i));
-    } else if (type_ == FBT_UINT) {
-      auto u = static_cast<uint64_t>(i);
-      return Mutate(data_, u, parent_width_, WidthU(u));
-    } else if (type_ == FBT_INDIRECT_UINT) {
-      auto u = static_cast<uint64_t>(i);
-      return Mutate(Indirect(), u, byte_width_, WidthU(u));
-    } else {
-      return false;
-    }
-  }
-
-  bool MutateBool(bool b) {
-    return type_ == FBT_BOOL && Mutate(data_, b, parent_width_, BIT_WIDTH_8);
-  }
-
-  bool MutateUInt(uint64_t u) {
-    if (type_ == FBT_UINT) {
-      return Mutate(data_, u, parent_width_, WidthU(u));
-    } else if (type_ == FBT_INDIRECT_UINT) {
-      return Mutate(Indirect(), u, byte_width_, WidthU(u));
-    } else if (type_ == FBT_INT) {
-      auto i = static_cast<int64_t>(u);
-      return Mutate(data_, i, parent_width_, WidthI(i));
-    } else if (type_ == FBT_INDIRECT_INT) {
-      auto i = static_cast<int64_t>(u);
-      return Mutate(Indirect(), i, byte_width_, WidthI(i));
-    } else {
-      return false;
-    }
-  }
-
-  bool MutateFloat(float f) {
-    if (type_ == FBT_FLOAT) {
-      return MutateF(data_, f, parent_width_, BIT_WIDTH_32);
-    } else if (type_ == FBT_INDIRECT_FLOAT) {
-      return MutateF(Indirect(), f, byte_width_, BIT_WIDTH_32);
-    } else {
-      return false;
-    }
-  }
-
-  bool MutateFloat(double d) {
-    if (type_ == FBT_FLOAT) {
-      return MutateF(data_, d, parent_width_, WidthF(d));
-    } else if (type_ == FBT_INDIRECT_FLOAT) {
-      return MutateF(Indirect(), d, byte_width_, WidthF(d));
-    } else {
-      return false;
-    }
-  }
-
-  bool MutateString(const char* str, size_t len) {
-    auto s = AsString();
-    if (s.IsTheEmptyString()) return false;
-    // This is very strict, could allow shorter strings, but that creates
-    // garbage.
-    if (s.length() != len) return false;
-    memcpy(const_cast<char*>(s.c_str()), str, len);
-    return true;
-  }
-  bool MutateString(const char* str) { return MutateString(str, strlen(str)); }
-  bool MutateString(const std::string& str) {
-    return MutateString(str.data(), str.length());
-  }
-
- private:
-  const uint8_t* Indirect() const {
-    return flexbuffers::Indirect(data_, parent_width_);
-  }
-
-  template <typename T>
-  bool Mutate(const uint8_t* dest, T t, size_t byte_width,
-              BitWidth value_width) {
-    auto fits = static_cast<size_t>(static_cast<size_t>(1U) << value_width) <=
-                byte_width;
-    if (fits) {
-      t = flatbuffers::EndianScalar(t);
-      memcpy(const_cast<uint8_t*>(dest), &t, byte_width);
-    }
-    return fits;
-  }
-
-  template <typename T>
-  bool MutateF(const uint8_t* dest, T t, size_t byte_width,
-               BitWidth value_width) {
-    if (byte_width == sizeof(double))
-      return Mutate(dest, static_cast<double>(t), byte_width, value_width);
-    if (byte_width == sizeof(float))
-      return Mutate(dest, static_cast<float>(t), byte_width, value_width);
-    FLATBUFFERS_ASSERT(false);
-    return false;
-  }
-
-  friend class Verifier;
-
-  const uint8_t* data_;
-  uint8_t parent_width_;
-  uint8_t byte_width_;
-  Type type_;
-};
-
-// Template specialization for As().
-template <>
-inline bool Reference::As<bool>() const {
-  return AsBool();
-}
-
-template <>
-inline int8_t Reference::As<int8_t>() const {
-  return AsInt8();
-}
-template <>
-inline int16_t Reference::As<int16_t>() const {
-  return AsInt16();
-}
-template <>
-inline int32_t Reference::As<int32_t>() const {
-  return AsInt32();
-}
-template <>
-inline int64_t Reference::As<int64_t>() const {
-  return AsInt64();
-}
-
-template <>
-inline uint8_t Reference::As<uint8_t>() const {
-  return AsUInt8();
-}
-template <>
-inline uint16_t Reference::As<uint16_t>() const {
-  return AsUInt16();
-}
-template <>
-inline uint32_t Reference::As<uint32_t>() const {
-  return AsUInt32();
-}
-template <>
-inline uint64_t Reference::As<uint64_t>() const {
-  return AsUInt64();
-}
-
-template <>
-inline double Reference::As<double>() const {
-  return AsDouble();
-}
-template <>
-inline float Reference::As<float>() const {
-  return AsFloat();
-}
-
-template <>
-inline String Reference::As<String>() const {
-  return AsString();
-}
-template <>
-inline std::string Reference::As<std::string>() const {
-  return AsString().str();
-}
-
-template <>
-inline Blob Reference::As<Blob>() const {
-  return AsBlob();
-}
-template <>
-inline Vector Reference::As<Vector>() const {
-  return AsVector();
-}
-template <>
-inline TypedVector Reference::As<TypedVector>() const {
-  return AsTypedVector();
-}
-template <>
-inline FixedTypedVector Reference::As<FixedTypedVector>() const {
-  return AsFixedTypedVector();
-}
-template <>
-inline Map Reference::As<Map>() const {
-  return AsMap();
-}
-
-inline uint8_t PackedType(BitWidth bit_width, Type type) {
-  return static_cast<uint8_t>(bit_width | (type << 2));
-}
-
-inline uint8_t NullPackedType() { return PackedType(BIT_WIDTH_8, FBT_NULL); }
-
-// Vector accessors.
-// Note: if you try to access outside of bounds, you get a Null value back
-// instead. Normally this would be an assert, but since this is "dynamically
-// typed" data, you may not want that (someone sends you a 2d vector and you
-// wanted 3d).
-// The Null converts seamlessly into a default value for any other type.
-// TODO(wvo): Could introduce an #ifdef that makes this into an assert?
-inline Reference Vector::operator[](size_t i) const {
-  auto len = size();
-  if (i >= len) return Reference(nullptr, 1, NullPackedType());
-  auto packed_type = (data_ + len * byte_width_)[i];
-  auto elem = data_ + i * byte_width_;
-  return Reference(elem, byte_width_, packed_type);
-}
-
-inline Reference TypedVector::operator[](size_t i) const {
-  auto len = size();
-  if (i >= len) return Reference(nullptr, 1, NullPackedType());
-  auto elem = data_ + i * byte_width_;
-  return Reference(elem, byte_width_, 1, type_);
-}
-
-inline Reference FixedTypedVector::operator[](size_t i) const {
-  if (i >= len_) return Reference(nullptr, 1, NullPackedType());
-  auto elem = data_ + i * byte_width_;
-  return Reference(elem, byte_width_, 1, type_);
-}
-
-template <typename T>
-int KeyCompare(const void* key, const void* elem) {
-  auto str_elem = reinterpret_cast<const char*>(
-      Indirect<T>(reinterpret_cast<const uint8_t*>(elem)));
-  auto skey = reinterpret_cast<const char*>(key);
-  return strcmp(skey, str_elem);
-}
-
-inline Reference Map::operator[](const char* key) const {
-  auto keys = Keys();
-  // We can't pass keys.byte_width_ to the comparison function, so we have
-  // to pick the right one ahead of time.
-  int (*comp)(const void*, const void*) = nullptr;
-  switch (keys.byte_width_) {
-    case 1:
-      comp = KeyCompare<uint8_t>;
-      break;
-    case 2:
-      comp = KeyCompare<uint16_t>;
-      break;
-    case 4:
-      comp = KeyCompare<uint32_t>;
-      break;
-    case 8:
-      comp = KeyCompare<uint64_t>;
-      break;
-    default:
-      FLATBUFFERS_ASSERT(false);
-      return Reference();
-  }
-  auto res = std::bsearch(key, keys.data_, keys.size(), keys.byte_width_, comp);
-  if (!res) return Reference(nullptr, 1, NullPackedType());
-  auto i = (reinterpret_cast<uint8_t*>(res) - keys.data_) / keys.byte_width_;
-  return (*static_cast<const Vector*>(this))[i];
-}
-
-inline Reference Map::operator[](const std::string& key) const {
-  return (*this)[key.c_str()];
-}
-
-inline Reference GetRoot(const uint8_t* buffer, size_t size) {
-  // See Finish() below for the serialization counterpart of this.
-  // The root starts at the end of the buffer, so we parse backwards from there.
-  auto end = buffer + size;
-  auto byte_width = *--end;
-  auto packed_type = *--end;
-  end -= byte_width;  // The root data item.
-  return Reference(end, byte_width, packed_type);
-}
-
-inline Reference GetRoot(const std::vector<uint8_t>& buffer) {
-  return GetRoot(buffer.data(), buffer.size());
-}
-
-// Flags that configure how the Builder behaves.
-// The "Share" flags determine if the Builder automatically tries to pool
-// this type. Pooling can reduce the size of serialized data if there are
-// multiple maps of the same kind, at the expense of slightly slower
-// serialization (the cost of lookups) and more memory use (std::set).
-// By default this is on for keys, but off for strings.
-// Turn keys off if you have e.g. only one map.
-// Turn strings on if you expect many non-unique string values.
-// Additionally, sharing key vectors can save space if you have maps with
-// identical field populations.
-enum BuilderFlag {
-  BUILDER_FLAG_NONE = 0,
-  BUILDER_FLAG_SHARE_KEYS = 1,
-  BUILDER_FLAG_SHARE_STRINGS = 2,
-  BUILDER_FLAG_SHARE_KEYS_AND_STRINGS = 3,
-  BUILDER_FLAG_SHARE_KEY_VECTORS = 4,
-  BUILDER_FLAG_SHARE_ALL = 7,
-};
-
-class Builder FLATBUFFERS_FINAL_CLASS {
- public:
-  Builder(size_t initial_size = 256,
-          BuilderFlag flags = BUILDER_FLAG_SHARE_KEYS)
-      : buf_(initial_size),
-        finished_(false),
-        has_duplicate_keys_(false),
-        flags_(flags),
-        force_min_bit_width_(BIT_WIDTH_8),
-        key_pool(KeyOffsetCompare(buf_)),
-        string_pool(StringOffsetCompare(buf_)) {
-    buf_.clear();
-  }
-
-#ifdef FLATBUFFERS_DEFAULT_DECLARATION
-  Builder(Builder&&) = default;
-  Builder& operator=(Builder&&) = default;
-#endif
-
-  /// @brief Get the serialized buffer (after you call `Finish()`).
-  /// @return Returns a vector owned by this class.
-  const std::vector<uint8_t>& GetBuffer() const {
-    Finished();
-    return buf_;
-  }
-
-  // Size of the buffer. Does not include unfinished values.
-  size_t GetSize() const { return buf_.size(); }
-
-  // Reset all state so we can re-use the buffer.
-  void Clear() {
-    buf_.clear();
-    stack_.clear();
-    finished_ = false;
-    // flags_ remains as-is;
-    force_min_bit_width_ = BIT_WIDTH_8;
-    key_pool.clear();
-    string_pool.clear();
-  }
-
-  // All value constructing functions below have two versions: one that
-  // takes a key (for placement inside a map) and one that doesn't (for inside
-  // vectors and elsewhere).
-
-  void Null() { stack_.push_back(Value()); }
-  void Null(const char* key) {
-    Key(key);
-    Null();
-  }
-
-  void Int(int64_t i) { stack_.push_back(Value(i, FBT_INT, WidthI(i))); }
-  void Int(const char* key, int64_t i) {
-    Key(key);
-    Int(i);
-  }
-
-  void UInt(uint64_t u) { stack_.push_back(Value(u, FBT_UINT, WidthU(u))); }
-  void UInt(const char* key, uint64_t u) {
-    Key(key);
-    UInt(u);
-  }
-
-  void Float(float f) { stack_.push_back(Value(f)); }
-  void Float(const char* key, float f) {
-    Key(key);
-    Float(f);
-  }
-
-  void Double(double f) { stack_.push_back(Value(f)); }
-  void Double(const char* key, double d) {
-    Key(key);
-    Double(d);
-  }
-
-  void Bool(bool b) { stack_.push_back(Value(b)); }
-  void Bool(const char* key, bool b) {
-    Key(key);
-    Bool(b);
-  }
-
-  void IndirectInt(int64_t i) { PushIndirect(i, FBT_INDIRECT_INT, WidthI(i)); }
-  void IndirectInt(const char* key, int64_t i) {
-    Key(key);
-    IndirectInt(i);
-  }
-
-  void IndirectUInt(uint64_t u) {
-    PushIndirect(u, FBT_INDIRECT_UINT, WidthU(u));
-  }
-  void IndirectUInt(const char* key, uint64_t u) {
-    Key(key);
-    IndirectUInt(u);
-  }
-
-  void IndirectFloat(float f) {
-    PushIndirect(f, FBT_INDIRECT_FLOAT, BIT_WIDTH_32);
-  }
-  void IndirectFloat(const char* key, float f) {
-    Key(key);
-    IndirectFloat(f);
-  }
-
-  void IndirectDouble(double f) {
-    PushIndirect(f, FBT_INDIRECT_FLOAT, WidthF(f));
-  }
-  void IndirectDouble(const char* key, double d) {
-    Key(key);
-    IndirectDouble(d);
-  }
-
-  size_t Key(const char* str, size_t len) {
-    auto sloc = buf_.size();
-    WriteBytes(str, len + 1);
-    if (flags_ & BUILDER_FLAG_SHARE_KEYS) {
-      auto it = key_pool.find(sloc);
-      if (it != key_pool.end()) {
-        // Already in the buffer. Remove key we just serialized, and use
-        // existing offset instead.
-        buf_.resize(sloc);
-        sloc = *it;
-      } else {
-        key_pool.insert(sloc);
-      }
-    }
-    stack_.push_back(Value(static_cast<uint64_t>(sloc), FBT_KEY, BIT_WIDTH_8));
-    return sloc;
-  }
-
-  size_t Key(const char* str) { return Key(str, strlen(str)); }
-  size_t Key(const std::string& str) { return Key(str.c_str(), str.size()); }
-
-  size_t String(const char* str, size_t len) {
-    auto reset_to = buf_.size();
-    auto sloc = CreateBlob(str, len, 1, FBT_STRING);
-    if (flags_ & BUILDER_FLAG_SHARE_STRINGS) {
-      StringOffset so(sloc, len);
-      auto it = string_pool.find(so);
-      if (it != string_pool.end()) {
-        // Already in the buffer. Remove string we just serialized, and use
-        // existing offset instead.
-        buf_.resize(reset_to);
-        sloc = it->first;
-        stack_.back().u_ = sloc;
-      } else {
-        string_pool.insert(so);
-      }
-    }
-    return sloc;
-  }
-  size_t String(const char* str) { return String(str, strlen(str)); }
-  size_t String(const std::string& str) {
-    return String(str.c_str(), str.size());
-  }
-  void String(const flexbuffers::String& str) {
-    String(str.c_str(), str.length());
-  }
-
-  void String(const char* key, const char* str) {
-    Key(key);
-    String(str);
-  }
-  void String(const char* key, const std::string& str) {
-    Key(key);
-    String(str);
-  }
-  void String(const char* key, const flexbuffers::String& str) {
-    Key(key);
-    String(str);
-  }
-
-  size_t AlignedBlob(const void* data, size_t len, BitWidth alignment) {
-    // The requested alignment must not be smaller than the one required to
-    // store the length.
-    return CreateAlignedBlob(data, len, 0, FBT_BLOB,
-                             std::max(alignment, WidthU(len)));
-  }
-  size_t AlignedBlob(const std::vector<uint8_t>& v, BitWidth alignment) {
-    return AlignedBlob(v.data(), v.size(), alignment);
-  }
-  size_t Blob(const void* data, size_t len) {
-    return CreateBlob(data, len, 0, FBT_BLOB);
-  }
-  size_t Blob(const std::vector<uint8_t>& v) {
-    return Blob(v.data(), v.size());
-  }
-
-  void Blob(const char* key, const void* data, size_t len) {
-    Key(key);
-    Blob(data, len);
-  }
-  void Blob(const char* key, const std::vector<uint8_t>& v) {
-    Key(key);
-    Blob(v);
-  }
-
-  // TODO(wvo): support all the FlexBuffer types (like flexbuffers::String),
-  // e.g. Vector etc. Also in overloaded versions.
-  // Also some FlatBuffers types?
-
-  size_t StartVector() { return stack_.size(); }
-  size_t StartVector(const char* key) {
-    Key(key);
-    return stack_.size();
-  }
-  size_t StartMap() { return stack_.size(); }
-  size_t StartMap(const char* key) {
-    Key(key);
-    return stack_.size();
-  }
-
-  // TODO(wvo): allow this to specify an alignment greater than the natural
-  // alignment.
-  size_t EndVector(size_t start, bool typed, bool fixed) {
-    auto vec = CreateVector(start, stack_.size() - start, 1, typed, fixed);
-    // Remove temp elements and return vector.
-    stack_.resize(start);
-    stack_.push_back(vec);
-    return static_cast<size_t>(vec.u_);
-  }
-
-  size_t EndMap(size_t start) {
-    // We should have interleaved keys and values on the stack.
-    auto len = MapElementCount(start);
-    // Make sure keys are all strings:
-    for (auto key = start; key < stack_.size(); key += 2) {
-      FLATBUFFERS_ASSERT(stack_[key].type_ == FBT_KEY);
-    }
-    // Now sort values, so later we can do a binary search lookup.
-    // We want to sort 2 array elements at a time.
-    struct TwoValue {
-      Value key;
-      Value val;
-    };
-    // TODO(wvo): strict aliasing?
-    // TODO(wvo): allow the caller to indicate the data is already sorted
-    // for maximum efficiency? With an assert to check sortedness to make sure
-    // we're not breaking binary search.
-    // Or, we can track if the map is sorted as keys are added which would be
-    // be quite cheap (cheaper than checking it here), so we can skip this
-    // step automatically when appliccable, and encourage people to write in
-    // sorted fashion.
-    // std::sort is typically already a lot faster on sorted data though.
-    auto dict = reinterpret_cast<TwoValue*>(stack_.data() + start);
-    std::sort(dict, dict + len,
-              [&](const TwoValue& a, const TwoValue& b) -> bool {
-                auto as = reinterpret_cast<const char*>(buf_.data() + a.key.u_);
-                auto bs = reinterpret_cast<const char*>(buf_.data() + b.key.u_);
-                auto comp = strcmp(as, bs);
-                // We want to disallow duplicate keys, since this results in a
-                // map where values cannot be found.
-                // But we can't assert here (since we don't want to fail on
-                // random JSON input) or have an error mechanism.
-                // Instead, we set has_duplicate_keys_ in the builder to
-                // signal this.
-                // TODO: Have to check for pointer equality, as some sort
-                // implementation apparently call this function with the same
-                // element?? Why?
-                if (!comp && &a != &b) has_duplicate_keys_ = true;
-                return comp < 0;
-              });
-    // First create a vector out of all keys.
-    // TODO(wvo): if kBuilderFlagShareKeyVectors is true, see if we can share
-    // the first vector.
-    auto keys = CreateVector(start, len, 2, true, false);
-    auto vec = CreateVector(start + 1, len, 2, false, false, &keys);
-    // Remove temp elements and return map.
-    stack_.resize(start);
-    stack_.push_back(vec);
-    return static_cast<size_t>(vec.u_);
-  }
-
-  // Call this after EndMap to see if the map had any duplicate keys.
-  // Any map with such keys won't be able to retrieve all values.
-  bool HasDuplicateKeys() const { return has_duplicate_keys_; }
-
-  template <typename F>
-  size_t Vector(F f) {
-    auto start = StartVector();
-    f();
-    return EndVector(start, false, false);
-  }
-  template <typename F, typename T>
-  size_t Vector(F f, T& state) {
-    auto start = StartVector();
-    f(state);
-    return EndVector(start, false, false);
-  }
-  template <typename F>
-  size_t Vector(const char* key, F f) {
-    auto start = StartVector(key);
-    f();
-    return EndVector(start, false, false);
-  }
-  template <typename F, typename T>
-  size_t Vector(const char* key, F f, T& state) {
-    auto start = StartVector(key);
-    f(state);
-    return EndVector(start, false, false);
-  }
-
-  template <typename T>
-  void Vector(const T* elems, size_t len) {
-    if (flatbuffers::is_scalar<T>::value) {
-      // This path should be a lot quicker and use less space.
-      ScalarVector(elems, len, false);
-    } else {
-      auto start = StartVector();
-      for (size_t i = 0; i < len; i++) Add(elems[i]);
-      EndVector(start, false, false);
-    }
-  }
-  template <typename T>
-  void Vector(const char* key, const T* elems, size_t len) {
-    Key(key);
-    Vector(elems, len);
-  }
-  template <typename T>
-  void Vector(const std::vector<T>& vec) {
-    Vector(vec.data(), vec.size());
-  }
-
-  template <typename F>
-  size_t TypedVector(F f) {
-    auto start = StartVector();
-    f();
-    return EndVector(start, true, false);
-  }
-  template <typename F, typename T>
-  size_t TypedVector(F f, T& state) {
-    auto start = StartVector();
-    f(state);
-    return EndVector(start, true, false);
-  }
-  template <typename F>
-  size_t TypedVector(const char* key, F f) {
-    auto start = StartVector(key);
-    f();
-    return EndVector(start, true, false);
-  }
-  template <typename F, typename T>
-  size_t TypedVector(const char* key, F f, T& state) {
-    auto start = StartVector(key);
-    f(state);
-    return EndVector(start, true, false);
-  }
-
-  template <typename T>
-  size_t FixedTypedVector(const T* elems, size_t len) {
-    // We only support a few fixed vector lengths. Anything bigger use a
-    // regular typed vector.
-    FLATBUFFERS_ASSERT(len >= 2 && len <= 4);
-    // And only scalar values.
-    static_assert(flatbuffers::is_scalar<T>::value, "Unrelated types");
-    return ScalarVector(elems, len, true);
-  }
-
-  template <typename T>
-  size_t FixedTypedVector(const char* key, const T* elems, size_t len) {
-    Key(key);
-    return FixedTypedVector(elems, len);
-  }
-
-  template <typename F>
-  size_t Map(F f) {
-    auto start = StartMap();
-    f();
-    return EndMap(start);
-  }
-  template <typename F, typename T>
-  size_t Map(F f, T& state) {
-    auto start = StartMap();
-    f(state);
-    return EndMap(start);
-  }
-  template <typename F>
-  size_t Map(const char* key, F f) {
-    auto start = StartMap(key);
-    f();
-    return EndMap(start);
-  }
-  template <typename F, typename T>
-  size_t Map(const char* key, F f, T& state) {
-    auto start = StartMap(key);
-    f(state);
-    return EndMap(start);
-  }
-  template <typename T>
-  void Map(const std::map<std::string, T>& map) {
-    auto start = StartMap();
-    for (auto it = map.begin(); it != map.end(); ++it)
-      Add(it->first.c_str(), it->second);
-    EndMap(start);
-  }
-
-  size_t MapElementCount(size_t start) {
-    // Make sure it is an even number:
-    auto len = stack_.size() - start;
-    FLATBUFFERS_ASSERT(!(len & 1));
-    len /= 2;
-    return len;
-  }
-
-  // If you wish to share a value explicitly (a value not shared automatically
-  // through one of the BUILDER_FLAG_SHARE_* flags) you can do so with these
-  // functions. Or if you wish to turn those flags off for performance reasons
-  // and still do some explicit sharing. For example:
-  // builder.IndirectDouble(M_PI);
-  // auto id = builder.LastValue();  // Remember where we stored it.
-  // .. more code goes here ..
-  // builder.ReuseValue(id);  // Refers to same double by offset.
-  // LastValue works regardless of whether the value has a key or not.
-  // Works on any data type.
-  struct Value;
-  Value LastValue() { return stack_.back(); }
-  void ReuseValue(Value v) { stack_.push_back(v); }
-  void ReuseValue(const char* key, Value v) {
-    Key(key);
-    ReuseValue(v);
-  }
-
-  // Undo the last element serialized. Call once for a value and once for a
-  // key.
-  void Undo() { stack_.pop_back(); }
-
-  // Overloaded Add that tries to call the correct function above.
-  void Add(int8_t i) { Int(i); }
-  void Add(int16_t i) { Int(i); }
-  void Add(int32_t i) { Int(i); }
-  void Add(int64_t i) { Int(i); }
-  void Add(uint8_t u) { UInt(u); }
-  void Add(uint16_t u) { UInt(u); }
-  void Add(uint32_t u) { UInt(u); }
-  void Add(uint64_t u) { UInt(u); }
-  void Add(float f) { Float(f); }
-  void Add(double d) { Double(d); }
-  void Add(bool b) { Bool(b); }
-  void Add(const char* str) { String(str); }
-  void Add(const std::string& str) { String(str); }
-  void Add(const flexbuffers::String& str) { String(str); }
-
-  template <typename T>
-  void Add(const std::vector<T>& vec) {
-    Vector(vec);
-  }
-
-  template <typename T>
-  void Add(const char* key, const T& t) {
-    Key(key);
-    Add(t);
-  }
-
-  template <typename T>
-  void Add(const std::map<std::string, T>& map) {
-    Map(map);
-  }
-
-  template <typename T>
-  void operator+=(const T& t) {
-    Add(t);
-  }
-
-  // This function is useful in combination with the Mutate* functions above.
-  // It forces elements of vectors and maps to have a minimum size, such that
-  // they can later be updated without failing.
-  // Call with no arguments to reset.
-  void ForceMinimumBitWidth(BitWidth bw = BIT_WIDTH_8) {
-    force_min_bit_width_ = bw;
-  }
-
-  void Finish() {
-    // If you hit this assert, you likely have objects that were never included
-    // in a parent. You need to have exactly one root to finish a buffer.
-    // Check your Start/End calls are matched, and all objects are inside
-    // some other object.
-    FLATBUFFERS_ASSERT(stack_.size() == 1);
-
-    // Write root value.
-    auto byte_width = Align(stack_[0].ElemWidth(buf_.size(), 0));
-    WriteAny(stack_[0], byte_width);
-    // Write root type.
-    Write(stack_[0].StoredPackedType(), 1);
-    // Write root size. Normally determined by parent, but root has no parent :)
-    Write(byte_width, 1);
-
-    finished_ = true;
-  }
-
- private:
-  void Finished() const {
-    // If you get this assert, you're attempting to get access a buffer
-    // which hasn't been finished yet. Be sure to call
-    // Builder::Finish with your root object.
-    FLATBUFFERS_ASSERT(finished_);
-  }
-
-  // Align to prepare for writing a scalar with a certain size.
-  uint8_t Align(BitWidth alignment) {
-    auto byte_width = 1U << alignment;
-    buf_.insert(buf_.end(), flatbuffers::PaddingBytes(buf_.size(), byte_width),
-                0);
-    return static_cast<uint8_t>(byte_width);
-  }
-
-  void WriteBytes(const void* val, size_t size) {
-    buf_.insert(buf_.end(), reinterpret_cast<const uint8_t*>(val),
-                reinterpret_cast<const uint8_t*>(val) + size);
-  }
-
-  template <typename T>
-  void Write(T val, size_t byte_width) {
-    FLATBUFFERS_ASSERT(sizeof(T) >= byte_width);
-    val = flatbuffers::EndianScalar(val);
-    WriteBytes(&val, byte_width);
-  }
-
-  void WriteDouble(double f, uint8_t byte_width) {
-    switch (byte_width) {
-      case 8:
-        Write(f, byte_width);
-        break;
-      case 4:
-        Write(static_cast<float>(f), byte_width);
-        break;
-      // case 2: Write(static_cast<half>(f), byte_width); break;
-      // case 1: Write(static_cast<quarter>(f), byte_width); break;
-      default:
-        FLATBUFFERS_ASSERT(0);
-    }
-  }
-
-  void WriteOffset(uint64_t o, uint8_t byte_width) {
-    auto reloff = buf_.size() - o;
-    FLATBUFFERS_ASSERT(byte_width == 8 || reloff < 1ULL << (byte_width * 8));
-    Write(reloff, byte_width);
-  }
-
-  template <typename T>
-  void PushIndirect(T val, Type type, BitWidth bit_width) {
-    auto byte_width = Align(bit_width);
-    auto iloc = buf_.size();
-    Write(val, byte_width);
-    stack_.push_back(Value(static_cast<uint64_t>(iloc), type, bit_width));
-  }
-
-  static BitWidth WidthB(size_t byte_width) {
-    switch (byte_width) {
-      case 1:
-        return BIT_WIDTH_8;
-      case 2:
-        return BIT_WIDTH_16;
-      case 4:
-        return BIT_WIDTH_32;
-      case 8:
-        return BIT_WIDTH_64;
-      default:
-        FLATBUFFERS_ASSERT(false);
-        return BIT_WIDTH_64;
-    }
-  }
-
-  template <typename T>
-  static Type GetScalarType() {
-    static_assert(flatbuffers::is_scalar<T>::value, "Unrelated types");
-    return flatbuffers::is_floating_point<T>::value ? FBT_FLOAT
-           : flatbuffers::is_same<T, bool>::value
-               ? FBT_BOOL
-               : (flatbuffers::is_unsigned<T>::value ? FBT_UINT : FBT_INT);
-  }
-
- public:
-  // This was really intended to be private, except for LastValue/ReuseValue.
-  struct Value {
-    union {
-      int64_t i_;
-      uint64_t u_;
-      double f_;
-    };
-
-    Type type_;
-
-    // For scalars: of itself, for vector: of its elements, for string: length.
-    BitWidth min_bit_width_;
-
-    Value() : i_(0), type_(FBT_NULL), min_bit_width_(BIT_WIDTH_8) {}
-
-    Value(bool b)
-        : u_(static_cast<uint64_t>(b)),
-          type_(FBT_BOOL),
-          min_bit_width_(BIT_WIDTH_8) {}
-
-    Value(int64_t i, Type t, BitWidth bw)
-        : i_(i), type_(t), min_bit_width_(bw) {}
-    Value(uint64_t u, Type t, BitWidth bw)
-        : u_(u), type_(t), min_bit_width_(bw) {}
-
-    Value(float f)
-        : f_(static_cast<double>(f)),
-          type_(FBT_FLOAT),
-          min_bit_width_(BIT_WIDTH_32) {}
-    Value(double f) : f_(f), type_(FBT_FLOAT), min_bit_width_(WidthF(f)) {}
-
-    uint8_t StoredPackedType(BitWidth parent_bit_width_ = BIT_WIDTH_8) const {
-      return PackedType(StoredWidth(parent_bit_width_), type_);
-    }
-
-    BitWidth ElemWidth(size_t buf_size, size_t elem_index) const {
-      if (IsInline(type_)) {
-        return min_bit_width_;
-      } else {
-        // We have an absolute offset, but want to store a relative offset
-        // elem_index elements beyond the current buffer end. Since whether
-        // the relative offset fits in a certain byte_width depends on
-        // the size of the elements before it (and their alignment), we have
-        // to test for each size in turn.
-        for (size_t byte_width = 1;
-             byte_width <= sizeof(flatbuffers::largest_scalar_t);
-             byte_width *= 2) {
-          // Where are we going to write this offset?
-          auto offset_loc = buf_size +
-                            flatbuffers::PaddingBytes(buf_size, byte_width) +
-                            elem_index * byte_width;
-          // Compute relative offset.
-          auto offset = offset_loc - u_;
-          // Does it fit?
-          auto bit_width = WidthU(offset);
-          if (static_cast<size_t>(static_cast<size_t>(1U) << bit_width) ==
-              byte_width)
-            return bit_width;
-        }
-        FLATBUFFERS_ASSERT(false);  // Must match one of the sizes above.
-        return BIT_WIDTH_64;
-      }
-    }
-
-    BitWidth StoredWidth(BitWidth parent_bit_width_ = BIT_WIDTH_8) const {
-      if (IsInline(type_)) {
-        return (std::max)(min_bit_width_, parent_bit_width_);
-      } else {
-        return min_bit_width_;
-      }
-    }
-  };
-
- private:
-  void WriteAny(const Value& val, uint8_t byte_width) {
-    switch (val.type_) {
-      case FBT_NULL:
-      case FBT_INT:
-        Write(val.i_, byte_width);
-        break;
-      case FBT_BOOL:
-      case FBT_UINT:
-        Write(val.u_, byte_width);
-        break;
-      case FBT_FLOAT:
-        WriteDouble(val.f_, byte_width);
-        break;
-      default:
-        WriteOffset(val.u_, byte_width);
-        break;
-    }
-  }
-
-  size_t CreateBlob(const void* data, size_t len, size_t trailing, Type type) {
-    auto bit_width = WidthU(len);
-    return CreateAlignedBlob(data, len, trailing, type, bit_width);
-  }
-
-  size_t CreateAlignedBlob(const void* data, size_t len, size_t trailing,
-                           Type type, BitWidth alignment) {
-    auto byte_width = Align(alignment);
-    Write<uint64_t>(len, byte_width);
-    auto sloc = buf_.size();
-    WriteBytes(data, len + trailing);
-    stack_.push_back(Value(static_cast<uint64_t>(sloc), type, alignment));
-    return sloc;
-  }
-
-  template <typename T>
-  size_t ScalarVector(const T* elems, size_t len, bool fixed) {
-    auto vector_type = GetScalarType<T>();
-    auto byte_width = sizeof(T);
-    auto bit_width = WidthB(byte_width);
-    // If you get this assert, you're trying to write a vector with a size
-    // field that is bigger than the scalars you're trying to write (e.g. a
-    // byte vector > 255 elements). For such types, write a "blob" instead.
-    // TODO: instead of asserting, could write vector with larger elements
-    // instead, though that would be wasteful.
-    FLATBUFFERS_ASSERT(WidthU(len) <= bit_width);
-    Align(bit_width);
-    if (!fixed) Write<uint64_t>(len, byte_width);
-    auto vloc = buf_.size();
-    for (size_t i = 0; i < len; i++) Write(elems[i], byte_width);
-    stack_.push_back(Value(static_cast<uint64_t>(vloc),
-                           ToTypedVector(vector_type, fixed ? len : 0),
-                           bit_width));
-    return vloc;
-  }
-
-  Value CreateVector(size_t start, size_t vec_len, size_t step, bool typed,
-                     bool fixed, const Value* keys = nullptr) {
-    FLATBUFFERS_ASSERT(
-        !fixed ||
-        typed);  // typed=false, fixed=true combination is not supported.
-    // Figure out smallest bit width we can store this vector with.
-    auto bit_width = (std::max)(force_min_bit_width_, WidthU(vec_len));
-    auto prefix_elems = 1;
-    if (keys) {
-      // If this vector is part of a map, we will pre-fix an offset to the keys
-      // to this vector.
-      bit_width = (std::max)(bit_width, keys->ElemWidth(buf_.size(), 0));
-      prefix_elems += 2;
-    }
-    Type vector_type = FBT_KEY;
-    // Check bit widths and types for all elements.
-    for (size_t i = start; i < stack_.size(); i += step) {
-      auto elem_width =
-          stack_[i].ElemWidth(buf_.size(), i - start + prefix_elems);
-      bit_width = (std::max)(bit_width, elem_width);
-      if (typed) {
-        if (i == start) {
-          vector_type = stack_[i].type_;
-        } else {
-          // If you get this assert, you are writing a typed vector with
-          // elements that are not all the same type.
-          FLATBUFFERS_ASSERT(vector_type == stack_[i].type_);
-        }
-      }
-    }
-    // If you get this assert, your typed types are not one of:
-    // Int / UInt / Float / Key.
-    FLATBUFFERS_ASSERT(!typed || IsTypedVectorElementType(vector_type));
-    auto byte_width = Align(bit_width);
-    // Write vector. First the keys width/offset if available, and size.
-    if (keys) {
-      WriteOffset(keys->u_, byte_width);
-      Write<uint64_t>(1ULL << keys->min_bit_width_, byte_width);
-    }
-    if (!fixed) Write<uint64_t>(vec_len, byte_width);
-    // Then the actual data.
-    auto vloc = buf_.size();
-    for (size_t i = start; i < stack_.size(); i += step) {
-      WriteAny(stack_[i], byte_width);
-    }
-    // Then the types.
-    if (!typed) {
-      for (size_t i = start; i < stack_.size(); i += step) {
-        buf_.push_back(stack_[i].StoredPackedType(bit_width));
-      }
-    }
-    return Value(static_cast<uint64_t>(vloc),
-                 keys ? FBT_MAP
-                      : (typed ? ToTypedVector(vector_type, fixed ? vec_len : 0)
-                               : FBT_VECTOR),
-                 bit_width);
-  }
-
-  // You shouldn't really be copying instances of this class.
-  Builder(const Builder&);
-  Builder& operator=(const Builder&);
-
-  std::vector<uint8_t> buf_;
-  std::vector<Value> stack_;
-
-  bool finished_;
-  bool has_duplicate_keys_;
-
-  BuilderFlag flags_;
-
-  BitWidth force_min_bit_width_;
-
-  struct KeyOffsetCompare {
-    explicit KeyOffsetCompare(const std::vector<uint8_t>& buf) : buf_(&buf) {}
-    bool operator()(size_t a, size_t b) const {
-      auto stra = reinterpret_cast<const char*>(buf_->data() + a);
-      auto strb = reinterpret_cast<const char*>(buf_->data() + b);
-      return strcmp(stra, strb) < 0;
-    }
-    const std::vector<uint8_t>* buf_;
-  };
-
-  typedef std::pair<size_t, size_t> StringOffset;
-  struct StringOffsetCompare {
-    explicit StringOffsetCompare(const std::vector<uint8_t>& buf)
-        : buf_(&buf) {}
-    bool operator()(const StringOffset& a, const StringOffset& b) const {
-      auto stra = buf_->data() + a.first;
-      auto strb = buf_->data() + b.first;
-      auto cr = memcmp(stra, strb, (std::min)(a.second, b.second) + 1);
-      return cr < 0 || (cr == 0 && a.second < b.second);
-    }
-    const std::vector<uint8_t>* buf_;
-  };
-
-  typedef std::set<size_t, KeyOffsetCompare> KeyOffsetMap;
-  typedef std::set<StringOffset, StringOffsetCompare> StringOffsetMap;
-
-  KeyOffsetMap key_pool;
-  StringOffsetMap string_pool;
-
-  friend class Verifier;
-};
-
-// Helper class to verify the integrity of a FlexBuffer
-class Verifier FLATBUFFERS_FINAL_CLASS {
- public:
-  Verifier(const uint8_t* buf, size_t buf_len,
-           // Supplying this vector likely results in faster verification
-           // of larger buffers with many shared keys/strings, but
-           // comes at the cost of using additional memory the same size of
-           // the buffer being verified, so it is by default off.
-           std::vector<uint8_t>* reuse_tracker = nullptr,
-           bool _check_alignment = true, size_t max_depth = 64)
-      : buf_(buf),
-        size_(buf_len),
-        depth_(0),
-        max_depth_(max_depth),
-        num_vectors_(0),
-        max_vectors_(buf_len),
-        check_alignment_(_check_alignment),
-        reuse_tracker_(reuse_tracker) {
-    FLATBUFFERS_ASSERT(static_cast<int32_t>(size_) <
-                       FLATBUFFERS_MAX_BUFFER_SIZE);
-    if (reuse_tracker_) {
-      reuse_tracker_->clear();
-      reuse_tracker_->resize(size_, PackedType(BIT_WIDTH_8, FBT_NULL));
-    }
-  }
-
- private:
-  // Central location where any verification failures register.
-  bool Check(bool ok) const {
-    // clang-format off
-    #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
-      FLATBUFFERS_ASSERT(ok);
-    #endif
-    // clang-format on
-    return ok;
-  }
-
-  // Verify any range within the buffer.
-  bool VerifyFrom(size_t elem, size_t elem_len) const {
-    return Check(elem_len < size_ && elem <= size_ - elem_len);
-  }
-  bool VerifyBefore(size_t elem, size_t elem_len) const {
-    return Check(elem_len <= elem);
-  }
-
-  bool VerifyFromPointer(const uint8_t* p, size_t len) {
-    auto o = static_cast<size_t>(p - buf_);
-    return VerifyFrom(o, len);
-  }
-  bool VerifyBeforePointer(const uint8_t* p, size_t len) {
-    auto o = static_cast<size_t>(p - buf_);
-    return VerifyBefore(o, len);
-  }
-
-  bool VerifyByteWidth(size_t width) {
-    return Check(width == 1 || width == 2 || width == 4 || width == 8);
-  }
-
-  bool VerifyType(int type) { return Check(type >= 0 && type < FBT_MAX_TYPE); }
-
-  bool VerifyOffset(uint64_t off, const uint8_t* p) {
-    return Check(off <= static_cast<uint64_t>(size_)) &&
-           off <= static_cast<uint64_t>(p - buf_);
-  }
-
-  bool VerifyAlignment(const uint8_t* p, size_t size) const {
-    auto o = static_cast<size_t>(p - buf_);
-    return Check((o & (size - 1)) == 0 || !check_alignment_);
-  }
-
-// Macro, since we want to escape from parent function & use lazy args.
-#define FLEX_CHECK_VERIFIED(P, PACKED_TYPE)                     \
-  if (reuse_tracker_) {                                         \
-    auto packed_type = PACKED_TYPE;                             \
-    auto existing = (*reuse_tracker_)[P - buf_];                \
-    if (existing == packed_type) return true;                   \
-    /* Fail verification if already set with different type! */ \
-    if (!Check(existing == 0)) return false;                    \
-    (*reuse_tracker_)[P - buf_] = packed_type;                  \
-  }
-
-  bool VerifyVector(Reference r, const uint8_t* p, Type elem_type) {
-    // Any kind of nesting goes thru this function, so guard against that
-    // here, both with simple nesting checks, and the reuse tracker if on.
-    depth_++;
-    num_vectors_++;
-    if (!Check(depth_ <= max_depth_ && num_vectors_ <= max_vectors_))
-      return false;
-    auto size_byte_width = r.byte_width_;
-    if (!VerifyBeforePointer(p, size_byte_width)) return false;
-    FLEX_CHECK_VERIFIED(p - size_byte_width,
-                        PackedType(Builder::WidthB(size_byte_width), r.type_));
-    auto sized = Sized(p, size_byte_width);
-    auto num_elems = sized.size();
-    auto elem_byte_width = r.type_ == FBT_STRING || r.type_ == FBT_BLOB
-                               ? uint8_t(1)
-                               : r.byte_width_;
-    auto max_elems = SIZE_MAX / elem_byte_width;
-    if (!Check(num_elems < max_elems))
-      return false;  // Protect against byte_size overflowing.
-    auto byte_size = num_elems * elem_byte_width;
-    if (!VerifyFromPointer(p, byte_size)) return false;
-    if (elem_type == FBT_NULL) {
-      // Verify type bytes after the vector.
-      if (!VerifyFromPointer(p + byte_size, num_elems)) return false;
-      auto v = Vector(p, size_byte_width);
-      for (size_t i = 0; i < num_elems; i++)
-        if (!VerifyRef(v[i])) return false;
-    } else if (elem_type == FBT_KEY) {
-      auto v = TypedVector(p, elem_byte_width, FBT_KEY);
-      for (size_t i = 0; i < num_elems; i++)
-        if (!VerifyRef(v[i])) return false;
-    } else {
-      FLATBUFFERS_ASSERT(IsInline(elem_type));
-    }
-    depth_--;
-    return true;
-  }
-
-  bool VerifyKeys(const uint8_t* p, uint8_t byte_width) {
-    // The vector part of the map has already been verified.
-    const size_t num_prefixed_fields = 3;
-    if (!VerifyBeforePointer(p, byte_width * num_prefixed_fields)) return false;
-    p -= byte_width * num_prefixed_fields;
-    auto off = ReadUInt64(p, byte_width);
-    if (!VerifyOffset(off, p)) return false;
-    auto key_byte_with =
-        static_cast<uint8_t>(ReadUInt64(p + byte_width, byte_width));
-    if (!VerifyByteWidth(key_byte_with)) return false;
-    return VerifyVector(Reference(p, byte_width, key_byte_with, FBT_VECTOR_KEY),
-                        p - off, FBT_KEY);
-  }
-
-  bool VerifyKey(const uint8_t* p) {
-    FLEX_CHECK_VERIFIED(p, PackedType(BIT_WIDTH_8, FBT_KEY));
-    while (p < buf_ + size_)
-      if (!*p++) return true;
-    return false;
-  }
-
-#undef FLEX_CHECK_VERIFIED
-
-  bool VerifyTerminator(const String& s) {
-    return VerifyFromPointer(reinterpret_cast<const uint8_t*>(s.c_str()),
-                             s.size() + 1);
-  }
-
-  bool VerifyRef(Reference r) {
-    // r.parent_width_ and r.data_ already verified.
-    if (!VerifyByteWidth(r.byte_width_) || !VerifyType(r.type_)) {
-      return false;
-    }
-    if (IsInline(r.type_)) {
-      // Inline scalars, don't require further verification.
-      return true;
-    }
-    // All remaining types are an offset.
-    auto off = ReadUInt64(r.data_, r.parent_width_);
-    if (!VerifyOffset(off, r.data_)) return false;
-    auto p = r.Indirect();
-    if (!VerifyAlignment(p, r.byte_width_)) return false;
-    switch (r.type_) {
-      case FBT_INDIRECT_INT:
-      case FBT_INDIRECT_UINT:
-      case FBT_INDIRECT_FLOAT:
-        return VerifyFromPointer(p, r.byte_width_);
-      case FBT_KEY:
-        return VerifyKey(p);
-      case FBT_MAP:
-        return VerifyVector(r, p, FBT_NULL) && VerifyKeys(p, r.byte_width_);
-      case FBT_VECTOR:
-        return VerifyVector(r, p, FBT_NULL);
-      case FBT_VECTOR_INT:
-        return VerifyVector(r, p, FBT_INT);
-      case FBT_VECTOR_BOOL:
-      case FBT_VECTOR_UINT:
-        return VerifyVector(r, p, FBT_UINT);
-      case FBT_VECTOR_FLOAT:
-        return VerifyVector(r, p, FBT_FLOAT);
-      case FBT_VECTOR_KEY:
-        return VerifyVector(r, p, FBT_KEY);
-      case FBT_VECTOR_STRING_DEPRECATED:
-        // Use of FBT_KEY here intentional, see elsewhere.
-        return VerifyVector(r, p, FBT_KEY);
-      case FBT_BLOB:
-        return VerifyVector(r, p, FBT_UINT);
-      case FBT_STRING:
-        return VerifyVector(r, p, FBT_UINT) &&
-               VerifyTerminator(String(p, r.byte_width_));
-      case FBT_VECTOR_INT2:
-      case FBT_VECTOR_UINT2:
-      case FBT_VECTOR_FLOAT2:
-      case FBT_VECTOR_INT3:
-      case FBT_VECTOR_UINT3:
-      case FBT_VECTOR_FLOAT3:
-      case FBT_VECTOR_INT4:
-      case FBT_VECTOR_UINT4:
-      case FBT_VECTOR_FLOAT4: {
-        uint8_t len = 0;
-        auto vtype = ToFixedTypedVectorElementType(r.type_, &len);
-        if (!VerifyType(vtype)) return false;
-        return VerifyFromPointer(p, static_cast<size_t>(r.byte_width_) * len);
-      }
-      default:
-        return false;
-    }
-  }
-
- public:
-  bool VerifyBuffer() {
-    if (!Check(size_ >= 3)) return false;
-    auto end = buf_ + size_;
-    auto byte_width = *--end;
-    auto packed_type = *--end;
-    return VerifyByteWidth(byte_width) && Check(end - buf_ >= byte_width) &&
-           VerifyRef(Reference(end - byte_width, byte_width, packed_type));
-  }
-
- private:
-  const uint8_t* buf_;
-  size_t size_;
-  size_t depth_;
-  const size_t max_depth_;
-  size_t num_vectors_;
-  const size_t max_vectors_;
-  bool check_alignment_;
-  std::vector<uint8_t>* reuse_tracker_;
-};
-
-// Utility function that constructs the Verifier for you, see above for
-// parameters.
-inline bool VerifyBuffer(const uint8_t* buf, size_t buf_len,
-                         std::vector<uint8_t>* reuse_tracker = nullptr) {
-  Verifier verifier(buf, buf_len, reuse_tracker);
-  return verifier.VerifyBuffer();
-}
-
-}  // namespace flexbuffers
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#endif  // FLATBUFFERS_FLEXBUFFERS_H_
diff --git a/external/flatbuffers/include/flatbuffers/grpc.h b/external/flatbuffers/include/flatbuffers/grpc.h
deleted file mode 100644
index 74633fd6..00000000
--- a/external/flatbuffers/include/flatbuffers/grpc.h
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * Copyright 2014 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_GRPC_H_
-#define FLATBUFFERS_GRPC_H_
-
-// Helper functionality to glue FlatBuffers and GRPC.
-
-#include "flatbuffers/flatbuffers.h"
-#include "grpcpp/support/byte_buffer.h"
-#include "grpcpp/support/slice.h"
-
-namespace flatbuffers {
-namespace grpc {
-
-// Message is a typed wrapper around a buffer that manages the underlying
-// `grpc_slice` and also provides flatbuffers-specific helpers such as `Verify`
-// and `GetRoot`. Since it is backed by a `grpc_slice`, the underlying buffer
-// is refcounted and ownership is be managed automatically.
-template <class T>
-class Message {
- public:
-  Message() {}
-
-  Message(::grpc::Slice slice) : slice_(slice) {}
-
-  Message& operator=(const Message& other) = delete;
-
-  Message(Message&& other) = default;
-
-  Message(const Message& other) = delete;
-
-  Message& operator=(Message&& other) = default;
-
-  const uint8_t* mutable_data() const { return slice_.begin(); }
-
-  const uint8_t* data() const { return slice_.begin(); }
-
-  size_t size() const { return slice_.size(); }
-
-  bool Verify() const {
-    Verifier verifier(data(), size());
-    return verifier.VerifyBuffer<T>(nullptr);
-  }
-
-  T* GetMutableRoot() { return flatbuffers::GetMutableRoot<T>(mutable_data()); }
-
-  const T* GetRoot() const { return flatbuffers::GetRoot<T>(data()); }
-
-  // This is only intended for serializer use, or if you know what you're doing
-  const ::grpc::Slice& BorrowSlice() const { return slice_; }
-
- private:
-  ::grpc::Slice slice_;
-};
-
-class MessageBuilder;
-
-// SliceAllocator is a gRPC-specific allocator that uses the `grpc_slice`
-// refcounted slices to manage memory ownership. This makes it easy and
-// efficient to transfer buffers to gRPC.
-class SliceAllocator : public Allocator {
- public:
-  SliceAllocator() {}
-
-  SliceAllocator(const SliceAllocator& other) = delete;
-  SliceAllocator& operator=(const SliceAllocator& other) = delete;
-
-  SliceAllocator(SliceAllocator&& other) {
-    // default-construct and swap idiom
-    swap(other);
-  }
-
-  SliceAllocator& operator=(SliceAllocator&& other) {
-    // move-construct and swap idiom
-    SliceAllocator temp(std::move(other));
-    swap(temp);
-    return *this;
-  }
-
-  void swap(SliceAllocator& other) {
-    using std::swap;
-    swap(slice_, other.slice_);
-  }
-
-  virtual ~SliceAllocator() {}
-
-  virtual uint8_t* allocate(size_t size) override {
-    FLATBUFFERS_ASSERT(slice_.size() == 0);
-    slice_ = ::grpc::Slice(size);
-    return const_cast<uint8_t*>(slice_.begin());
-  }
-
-  virtual void deallocate(uint8_t* p, size_t size) override {
-    FLATBUFFERS_ASSERT(p == slice_.begin());
-    FLATBUFFERS_ASSERT(size == slice_.size());
-    slice_ = ::grpc::Slice();
-  }
-
-  virtual uint8_t* reallocate_downward(uint8_t* old_p, size_t old_size,
-                                       size_t new_size, size_t in_use_back,
-                                       size_t in_use_front) override {
-    FLATBUFFERS_ASSERT(old_p == slice_.begin());
-    FLATBUFFERS_ASSERT(old_size == slice_.size());
-    FLATBUFFERS_ASSERT(new_size > old_size);
-    ::grpc::Slice old_slice = slice_;
-    ::grpc::Slice new_slice = ::grpc::Slice(new_size);
-    uint8_t* new_p = const_cast<uint8_t*>(new_slice.begin());
-    memcpy_downward(old_p, old_size, new_p, new_size, in_use_back,
-                    in_use_front);
-    slice_ = new_slice;
-    return const_cast<uint8_t*>(slice_.begin());
-  }
-
- private:
-  ::grpc::Slice& get_slice(uint8_t* p, size_t size) {
-    FLATBUFFERS_ASSERT(p == slice_.begin());
-    FLATBUFFERS_ASSERT(size == slice_.size());
-    return slice_;
-  }
-
-  ::grpc::Slice slice_;
-
-  friend class MessageBuilder;
-};
-
-// SliceAllocatorMember is a hack to ensure that the MessageBuilder's
-// slice_allocator_ member is constructed before the FlatBufferBuilder, since
-// the allocator is used in the FlatBufferBuilder ctor.
-namespace detail {
-struct SliceAllocatorMember {
-  SliceAllocator slice_allocator_;
-};
-}  // namespace detail
-
-// MessageBuilder is a gRPC-specific FlatBufferBuilder that uses SliceAllocator
-// to allocate gRPC buffers.
-class MessageBuilder : private detail::SliceAllocatorMember,
-                       public FlatBufferBuilder {
- public:
-  explicit MessageBuilder(uoffset_t initial_size = 1024)
-      : FlatBufferBuilder(initial_size, &slice_allocator_, false) {}
-
-  MessageBuilder(const MessageBuilder& other) = delete;
-  MessageBuilder& operator=(const MessageBuilder& other) = delete;
-
-  MessageBuilder(MessageBuilder&& other)
-      : FlatBufferBuilder(1024, &slice_allocator_, false) {
-    // Default construct and swap idiom.
-    Swap(other);
-  }
-
-  /// Create a MessageBuilder from a FlatBufferBuilder.
-  explicit MessageBuilder(FlatBufferBuilder&& src,
-                          void (*dealloc)(void*,
-                                          size_t) = &DefaultAllocator::dealloc)
-      : FlatBufferBuilder(1024, &slice_allocator_, false) {
-    src.Swap(*this);
-    src.SwapBufAllocator(*this);
-    if (buf_.capacity()) {
-      uint8_t* buf = buf_.scratch_data();  // pointer to memory
-      size_t capacity = buf_.capacity();   // size of memory
-      slice_allocator_.slice_ = ::grpc::Slice(buf, capacity, dealloc);
-    } else {
-      slice_allocator_.slice_ = ::grpc::Slice();
-    }
-  }
-
-  /// Move-assign a FlatBufferBuilder to a MessageBuilder.
-  /// Only FlatBufferBuilder with default allocator (basically, nullptr) is
-  /// supported.
-  MessageBuilder& operator=(FlatBufferBuilder&& src) {
-    // Move construct a temporary and swap
-    MessageBuilder temp(std::move(src));
-    Swap(temp);
-    return *this;
-  }
-
-  MessageBuilder& operator=(MessageBuilder&& other) {
-    // Move construct a temporary and swap
-    MessageBuilder temp(std::move(other));
-    Swap(temp);
-    return *this;
-  }
-
-  void Swap(MessageBuilder& other) {
-    slice_allocator_.swap(other.slice_allocator_);
-    FlatBufferBuilder::Swap(other);
-    // After swapping the FlatBufferBuilder, we swap back the allocator, which
-    // restores the original allocator back in place. This is necessary because
-    // MessageBuilder's allocator is its own member (SliceAllocatorMember). The
-    // allocator passed to FlatBufferBuilder::vector_downward must point to this
-    // member.
-    buf_.swap_allocator(other.buf_);
-  }
-
-  // Releases the ownership of the buffer pointer.
-  // Returns the size, offset, and the original grpc_slice that
-  // allocated the buffer. Also see grpc_slice_unref().
-  uint8_t* ReleaseRaw(size_t& size, size_t& offset, ::grpc::Slice& slice) {
-    uint8_t* buf = FlatBufferBuilder::ReleaseRaw(size, offset);
-    slice = slice_allocator_.slice_;
-    slice_allocator_.slice_ = ::grpc::Slice();
-    return buf;
-  }
-
-  ~MessageBuilder() {}
-
-  // GetMessage extracts the subslice of the buffer corresponding to the
-  // flatbuffers-encoded region and wraps it in a `Message<T>` to handle buffer
-  // ownership.
-  template <class T>
-  Message<T> GetMessage() {
-    auto buf_data = buf_.scratch_data();  // pointer to memory
-    auto buf_size = buf_.capacity();      // size of memory
-    auto msg_data = buf_.data();          // pointer to msg
-    auto msg_size = buf_.size();          // size of msg
-    // Do some sanity checks on data/size
-    FLATBUFFERS_ASSERT(msg_data);
-    FLATBUFFERS_ASSERT(msg_size);
-    FLATBUFFERS_ASSERT(msg_data >= buf_data);
-    FLATBUFFERS_ASSERT(msg_data + msg_size <= buf_data + buf_size);
-    // Calculate offsets from the buffer start
-    auto begin = msg_data - buf_data;
-    auto end = begin + msg_size;
-    // Get the slice we are working with (no refcount change)
-    ::grpc::Slice slice = slice_allocator_.get_slice(buf_data, buf_size);
-    // Extract a subslice of the existing slice (increment refcount)
-    ::grpc::Slice subslice = slice.sub(begin, end);
-    // Wrap the subslice in a `Message<T>`, but don't increment refcount
-    Message<T> msg(subslice);
-    return msg;
-  }
-
-  template <class T>
-  Message<T> ReleaseMessage() {
-    Message<T> msg = GetMessage<T>();
-    Reset();
-    return msg;
-  }
-
- private:
-  // SliceAllocator slice_allocator_;  // part of SliceAllocatorMember
-};
-
-}  // namespace grpc
-}  // namespace flatbuffers
-
-namespace grpc {
-
-template <class T>
-class SerializationTraits<flatbuffers::grpc::Message<T>> {
- public:
-  static grpc::Status Serialize(const flatbuffers::grpc::Message<T>& msg,
-                                ByteBuffer* buffer, bool* own_buffer) {
-    // Package the single slice into a `ByteBuffer`,
-    // incrementing the refcount in the process.
-    *buffer = ByteBuffer(&msg.BorrowSlice(), 1);
-    *own_buffer = true;
-    return grpc::Status::OK;
-  }
-
-  // Deserialize by pulling the
-  static grpc::Status Deserialize(ByteBuffer* buf,
-                                  flatbuffers::grpc::Message<T>* msg) {
-    Slice slice;
-    if (!buf->TrySingleSlice(&slice).ok()) {
-      if (!buf->DumpToSingleSlice(&slice).ok()) {
-        buf->Clear();
-        return ::grpc::Status(::grpc::StatusCode::INTERNAL, "No payload");
-      }
-    }
-    *msg = flatbuffers::grpc::Message<T>(slice);
-    buf->Clear();
-#if FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION
-    return ::grpc::Status::OK;
-#else
-    if (msg->Verify()) {
-      return ::grpc::Status::OK;
-    } else {
-      return ::grpc::Status(::grpc::StatusCode::INTERNAL,
-                            "Message verification failed");
-    }
-#endif
-  }
-};
-
-}  // namespace grpc
-
-#endif  // FLATBUFFERS_GRPC_H_
diff --git a/external/flatbuffers/include/flatbuffers/hash.h b/external/flatbuffers/include/flatbuffers/hash.h
deleted file mode 100644
index 2e92c09a..00000000
--- a/external/flatbuffers/include/flatbuffers/hash.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright 2015 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_HASH_H_
-#define FLATBUFFERS_HASH_H_
-
-#include <cstdint>
-#include <cstring>
-
-#include "flatbuffers/flatbuffers.h"
-
-namespace flatbuffers {
-
-template <typename T>
-struct FnvTraits {
-  static const T kFnvPrime;
-  static const T kOffsetBasis;
-};
-
-template <>
-struct FnvTraits<uint32_t> {
-  static const uint32_t kFnvPrime = 0x01000193;
-  static const uint32_t kOffsetBasis = 0x811C9DC5;
-};
-
-template <>
-struct FnvTraits<uint64_t> {
-  static const uint64_t kFnvPrime = 0x00000100000001b3ULL;
-  static const uint64_t kOffsetBasis = 0xcbf29ce484222645ULL;
-};
-
-template <typename T>
-T HashFnv1(const char* input) {
-  T hash = FnvTraits<T>::kOffsetBasis;
-  for (const char* c = input; *c; ++c) {
-    hash *= FnvTraits<T>::kFnvPrime;
-    hash ^= static_cast<unsigned char>(*c);
-  }
-  return hash;
-}
-
-template <typename T>
-T HashFnv1a(const char* input) {
-  T hash = FnvTraits<T>::kOffsetBasis;
-  for (const char* c = input; *c; ++c) {
-    hash ^= static_cast<unsigned char>(*c);
-    hash *= FnvTraits<T>::kFnvPrime;
-  }
-  return hash;
-}
-
-template <>
-inline uint16_t HashFnv1<uint16_t>(const char* input) {
-  uint32_t hash = HashFnv1<uint32_t>(input);
-  return (hash >> 16) ^ (hash & 0xffff);
-}
-
-template <>
-inline uint16_t HashFnv1a<uint16_t>(const char* input) {
-  uint32_t hash = HashFnv1a<uint32_t>(input);
-  return (hash >> 16) ^ (hash & 0xffff);
-}
-
-template <typename T>
-struct NamedHashFunction {
-  const char* name;
-
-  typedef T (*HashFunction)(const char*);
-  HashFunction function;
-};
-
-const NamedHashFunction<uint16_t> kHashFunctions16[] = {
-    {"fnv1_16", HashFnv1<uint16_t>},
-    {"fnv1a_16", HashFnv1a<uint16_t>},
-};
-
-const NamedHashFunction<uint32_t> kHashFunctions32[] = {
-    {"fnv1_32", HashFnv1<uint32_t>},
-    {"fnv1a_32", HashFnv1a<uint32_t>},
-};
-
-const NamedHashFunction<uint64_t> kHashFunctions64[] = {
-    {"fnv1_64", HashFnv1<uint64_t>},
-    {"fnv1a_64", HashFnv1a<uint64_t>},
-};
-
-inline NamedHashFunction<uint16_t>::HashFunction FindHashFunction16(
-    const char* name) {
-  std::size_t size = sizeof(kHashFunctions16) / sizeof(kHashFunctions16[0]);
-  for (std::size_t i = 0; i < size; ++i) {
-    if (std::strcmp(name, kHashFunctions16[i].name) == 0) {
-      return kHashFunctions16[i].function;
-    }
-  }
-  return nullptr;
-}
-
-inline NamedHashFunction<uint32_t>::HashFunction FindHashFunction32(
-    const char* name) {
-  std::size_t size = sizeof(kHashFunctions32) / sizeof(kHashFunctions32[0]);
-  for (std::size_t i = 0; i < size; ++i) {
-    if (std::strcmp(name, kHashFunctions32[i].name) == 0) {
-      return kHashFunctions32[i].function;
-    }
-  }
-  return nullptr;
-}
-
-inline NamedHashFunction<uint64_t>::HashFunction FindHashFunction64(
-    const char* name) {
-  std::size_t size = sizeof(kHashFunctions64) / sizeof(kHashFunctions64[0]);
-  for (std::size_t i = 0; i < size; ++i) {
-    if (std::strcmp(name, kHashFunctions64[i].name) == 0) {
-      return kHashFunctions64[i].function;
-    }
-  }
-  return nullptr;
-}
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_HASH_H_
diff --git a/external/flatbuffers/include/flatbuffers/idl.h b/external/flatbuffers/include/flatbuffers/idl.h
deleted file mode 100644
index 9e58d4be..00000000
--- a/external/flatbuffers/include/flatbuffers/idl.h
+++ /dev/null
@@ -1,1329 +0,0 @@
-/*
- * Copyright 2014 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_IDL_H_
-#define FLATBUFFERS_IDL_H_
-
-#include <algorithm>
-#include <functional>
-#include <map>
-#include <memory>
-#include <stack>
-#include <vector>
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/file_manager.h"
-#include "flatbuffers/flatbuffers.h"
-#include "flatbuffers/flexbuffers.h"
-#include "flatbuffers/hash.h"
-#include "flatbuffers/reflection.h"
-
-// This file defines the data types representing a parsed IDL (Interface
-// Definition Language) / schema file.
-
-// Limits maximum depth of nested objects.
-// Prevents stack overflow while parse scheme, or json, or flexbuffer.
-#if !defined(FLATBUFFERS_MAX_PARSING_DEPTH)
-#define FLATBUFFERS_MAX_PARSING_DEPTH 64
-#endif
-
-namespace flatbuffers {
-
-// The order of these matters for Is*() functions below.
-// Additionally, Parser::ParseType assumes bool..string is a contiguous range
-// of type tokens.
-// clang-format off
-#define FLATBUFFERS_GEN_TYPES_SCALAR(TD) \
-  TD(NONE,     "",       uint8_t,  byte,   byte,    byte,   uint8,   u8,   UByte, UInt8, 0) \
-  TD(UTYPE,    "",       uint8_t,  byte,   byte,    byte,   uint8,   u8,   UByte, UInt8, 1) /* begin scalar/int */ \
-  TD(BOOL,     "bool",   uint8_t,  boolean,bool,    bool,   bool,    bool, Boolean, Bool, 2) \
-  TD(CHAR,     "byte",   int8_t,   byte,   int8,    sbyte,  int8,    i8,   Byte, Int8, 3) \
-  TD(UCHAR,    "ubyte",  uint8_t,  byte,   byte,    byte,   uint8,   u8,   UByte, UInt8, 4) \
-  TD(SHORT,    "short",  int16_t,  short,  int16,   short,  int16,   i16,  Short, Int16, 5) \
-  TD(USHORT,   "ushort", uint16_t, short,  uint16,  ushort, uint16,  u16,  UShort, UInt16, 6) \
-  TD(INT,      "int",    int32_t,  int,    int32,   int,    int32,   i32,  Int, Int32, 7) \
-  TD(UINT,     "uint",   uint32_t, int,    uint32,  uint,   uint32,  u32,  UInt, UInt32, 8) \
-  TD(LONG,     "long",   int64_t,  long,   int64,   long,   int64,   i64,  Long, Int64, 9) \
-  TD(ULONG,    "ulong",  uint64_t, long,   uint64,  ulong,  uint64,  u64,  ULong, UInt64, 10) /* end int */ \
-  TD(FLOAT,    "float",  float,    float,  float32, float,  float32, f32,  Float, Float32, 11) /* begin float */ \
-  TD(DOUBLE,   "double", double,   double, float64, double, float64, f64,  Double, Double, 12) /* end float/scalar */
-#define FLATBUFFERS_GEN_TYPES_POINTER(TD) \
-  TD(STRING,   "string", Offset<void>,   int, int, StringOffset, int, unused, Int, Offset<String>, 13) \
-  TD(VECTOR,   "",       Offset<void>,   int, int, VectorOffset, int, unused, Int, Offset<UOffset>, 14) \
-  TD(VECTOR64, "",       Offset64<void>, int, int, VectorOffset, int, unused, Int, Offset<UOffset>, 18) \
-  TD(STRUCT,   "",       Offset<void>,   int, int, int,          int, unused, Int, Offset<UOffset>, 15) \
-  TD(UNION,    "",       Offset<void>,   int, int, int,          int, unused, Int, Offset<UOffset>, 16)
-#define FLATBUFFERS_GEN_TYPE_ARRAY(TD) \
-  TD(ARRAY,    "",       int,            int, int, int,          int, unused, Int, Offset<UOffset>, 17)
-// The fields are:
-// - enum
-// - FlatBuffers schema type.
-// - C++ type.
-// - Java type.
-// - Go type.
-// - C# / .Net type.
-// - Python type.
-// - Kotlin type.
-// - Rust type.
-// - Swift type.
-// - enum value (matches the reflected values)
-
-// using these macros, we can now write code dealing with types just once, e.g.
-
-/*
-switch (type) {
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, \
-                         RTYPE, KTYPE, STYPE, ...) \
-    case BASE_TYPE_ ## ENUM: \
-      // do something specific to CTYPE here
-    FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
-  #undef FLATBUFFERS_TD
-}
-*/
-
-// If not all FLATBUFFERS_GEN_() arguments are necessary for implementation
-// of FLATBUFFERS_TD, you can use a variadic macro (with __VA_ARGS__ if needed).
-// In the above example, only CTYPE is used to generate the code, it can be rewritten:
-
-/*
-switch (type) {
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
-    case BASE_TYPE_ ## ENUM: \
-      // do something specific to CTYPE here
-    FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
-  #undef FLATBUFFERS_TD
-}
-*/
-
-#define FLATBUFFERS_GEN_TYPES(TD) \
-        FLATBUFFERS_GEN_TYPES_SCALAR(TD) \
-        FLATBUFFERS_GEN_TYPES_POINTER(TD) \
-        FLATBUFFERS_GEN_TYPE_ARRAY(TD)
-
-// Create an enum for all the types above.
-#ifdef __GNUC__
-__extension__  // Stop GCC complaining about trailing comma with -Wpendantic.
-#endif
-enum BaseType {
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, \
-              CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE, STYPE, ENUM_VALUE) \
-    BASE_TYPE_ ## ENUM = ENUM_VALUE,
-    FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
-  #undef FLATBUFFERS_TD
-};
-
-#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
-  static_assert(sizeof(CTYPE) <= sizeof(largest_scalar_t), \
-                "define largest_scalar_t as " #CTYPE);
-  FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
-#undef FLATBUFFERS_TD
-
-inline bool IsScalar (BaseType t) { return t >= BASE_TYPE_UTYPE &&
-                                           t <= BASE_TYPE_DOUBLE; }
-inline bool IsInteger(BaseType t) { return t >= BASE_TYPE_UTYPE &&
-                                           t <= BASE_TYPE_ULONG; }
-inline bool IsFloat  (BaseType t) { return t == BASE_TYPE_FLOAT ||
-                                           t == BASE_TYPE_DOUBLE; }
-inline bool IsLong   (BaseType t) { return t == BASE_TYPE_LONG ||
-                                           t == BASE_TYPE_ULONG; }
-inline bool IsBool   (BaseType t) { return t == BASE_TYPE_BOOL; }
-inline bool IsOneByte(BaseType t) { return t >= BASE_TYPE_UTYPE &&
-                                           t <= BASE_TYPE_UCHAR; }
-inline bool IsVector (BaseType t) { return t == BASE_TYPE_VECTOR ||
-                                           t == BASE_TYPE_VECTOR64; }
-
-inline bool IsUnsigned(BaseType t) {
-  return (t == BASE_TYPE_UTYPE)  || (t == BASE_TYPE_UCHAR) ||
-         (t == BASE_TYPE_USHORT) || (t == BASE_TYPE_UINT)  ||
-         (t == BASE_TYPE_ULONG);
-}
-
-inline size_t SizeOf(const BaseType t) {
-  switch (t) {
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
-    case BASE_TYPE_##ENUM: return sizeof(CTYPE);
-      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
-  #undef FLATBUFFERS_TD
-    default: FLATBUFFERS_ASSERT(0);
-  }
-  return 0;
-}
-
-inline const char* TypeName(const BaseType t) {
-  switch (t) {
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, ...) \
-    case BASE_TYPE_##ENUM: return IDLTYPE;
-      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
-  #undef FLATBUFFERS_TD
-    default: FLATBUFFERS_ASSERT(0);
-  }
-  return nullptr;
-}
-
-inline const char* StringOf(const BaseType t) {
-  switch (t) {
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
-    case BASE_TYPE_##ENUM: return #CTYPE;
-      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
-  #undef FLATBUFFERS_TD
-    default: FLATBUFFERS_ASSERT(0);
-  }
-  return "";
-}
-
-// clang-format on
-
-struct StructDef;
-struct EnumDef;
-class Parser;
-
-// Represents any type in the IDL, which is a combination of the BaseType
-// and additional information for vectors/structs_.
-struct Type {
-  explicit Type(BaseType _base_type = BASE_TYPE_NONE, StructDef* _sd = nullptr,
-                EnumDef* _ed = nullptr, uint16_t _fixed_length = 0)
-      : base_type(_base_type),
-        element(BASE_TYPE_NONE),
-        struct_def(_sd),
-        enum_def(_ed),
-        fixed_length(_fixed_length) {}
-
-  bool operator==(const Type& o) const {
-    return base_type == o.base_type && element == o.element &&
-           struct_def == o.struct_def && enum_def == o.enum_def;
-  }
-
-  Type VectorType() const {
-    return Type(element, struct_def, enum_def, fixed_length);
-  }
-
-  Offset<reflection::Type> Serialize(FlatBufferBuilder* builder) const;
-
-  bool Deserialize(const Parser& parser, const reflection::Type* type);
-
-  BaseType base_type;
-  BaseType element;       // only set if t == BASE_TYPE_VECTOR or
-                          // BASE_TYPE_VECTOR64
-  StructDef* struct_def;  // only set if t or element == BASE_TYPE_STRUCT
-  EnumDef* enum_def;      // set if t == BASE_TYPE_UNION / BASE_TYPE_UTYPE,
-                          // or for an integral type derived from an enum.
-  uint16_t fixed_length;  // only set if t == BASE_TYPE_ARRAY
-};
-
-// Represents a parsed scalar value, its type, and field offset.
-struct Value {
-  Value()
-      : constant("0"),
-        offset(static_cast<voffset_t>(~(static_cast<voffset_t>(0U)))) {}
-  Type type;
-  std::string constant;
-  voffset_t offset;
-};
-
-// Helper class that retains the original order of a set of identifiers and
-// also provides quick lookup.
-template <typename T>
-class SymbolTable {
- public:
-  ~SymbolTable() {
-    for (auto it = vec.begin(); it != vec.end(); ++it) {
-      delete *it;
-    }
-  }
-
-  bool Add(const std::string& name, T* e) {
-    vec.emplace_back(e);
-    auto it = dict.find(name);
-    if (it != dict.end()) return true;
-    dict[name] = e;
-    return false;
-  }
-
-  void Move(const std::string& oldname, const std::string& newname) {
-    auto it = dict.find(oldname);
-    if (it != dict.end()) {
-      auto obj = it->second;
-      dict.erase(it);
-      dict[newname] = obj;
-    } else {
-      FLATBUFFERS_ASSERT(false);
-    }
-  }
-
-  T* Lookup(const std::string& name) const {
-    auto it = dict.find(name);
-    return it == dict.end() ? nullptr : it->second;
-  }
-
- public:
-  std::map<std::string, T*> dict;  // quick lookup
-  std::vector<T*> vec;             // Used to iterate in order of insertion
-};
-
-// A name space, as set in the schema.
-struct Namespace {
-  Namespace() : from_table(0) {}
-
-  // Given a (potentially unqualified) name, return the "fully qualified" name
-  // which has a full namespaced descriptor.
-  // With max_components you can request less than the number of components
-  // the current namespace has.
-  std::string GetFullyQualifiedName(const std::string& name,
-                                    size_t max_components = 1000) const;
-
-  std::vector<std::string> components;
-  size_t from_table;  // Part of the namespace corresponds to a message/table.
-};
-
-inline bool operator<(const Namespace& a, const Namespace& b) {
-  size_t min_size = std::min(a.components.size(), b.components.size());
-  for (size_t i = 0; i < min_size; ++i) {
-    if (a.components[i] != b.components[i])
-      return a.components[i] < b.components[i];
-  }
-  return a.components.size() < b.components.size();
-}
-
-// Base class for all definition types (fields, structs_, enums_).
-struct Definition {
-  Definition()
-      : generated(false),
-        defined_namespace(nullptr),
-        serialized_location(0),
-        index(-1),
-        refcount(1),
-        declaration_file(nullptr) {}
-
-  flatbuffers::Offset<
-      flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>>
-  SerializeAttributes(FlatBufferBuilder* builder, const Parser& parser) const;
-
-  bool DeserializeAttributes(Parser& parser,
-                             const Vector<Offset<reflection::KeyValue>>* attrs);
-
-  std::string name;
-  std::string file;
-  std::vector<std::string> doc_comment;
-  SymbolTable<Value> attributes;
-  bool generated;  // did we already output code for this definition?
-  Namespace* defined_namespace;  // Where it was defined.
-
-  // For use with Serialize()
-  uoffset_t serialized_location;
-  int index;  // Inside the vector it is stored.
-  int refcount;
-  const std::string* declaration_file;
-};
-
-struct FieldDef : public Definition {
-  FieldDef()
-      : deprecated(false),
-        key(false),
-        shared(false),
-        native_inline(false),
-        flexbuffer(false),
-        offset64(false),
-        presence(kDefault),
-        nested_flatbuffer(nullptr),
-        padding(0),
-        sibling_union_field(nullptr) {}
-
-  Offset<reflection::Field> Serialize(FlatBufferBuilder* builder, uint16_t id,
-                                      const Parser& parser) const;
-
-  bool Deserialize(Parser& parser, const reflection::Field* field);
-
-  bool IsScalarOptional() const { return IsScalar() && IsOptional(); }
-  bool IsScalar() const {
-    return ::flatbuffers::IsScalar(value.type.base_type);
-  }
-  bool IsOptional() const { return presence == kOptional; }
-  bool IsRequired() const { return presence == kRequired; }
-  bool IsDefault() const { return presence == kDefault; }
-
-  Value value;
-  bool deprecated;  // Field is allowed to be present in old data, but can't be.
-                    // written in new data nor accessed in new code.
-  bool key;         // Field functions as a key for creating sorted vectors.
-  bool shared;  // Field will be using string pooling (i.e. CreateSharedString)
-                // as default serialization behavior if field is a string.
-  bool native_inline;  // Field will be defined inline (instead of as a pointer)
-                       // for native tables if field is a struct.
-  bool flexbuffer;     // This field contains FlexBuffer data.
-  bool offset64;       // If the field uses 64-bit offsets.
-
-  enum Presence {
-    // Field must always be present.
-    kRequired,
-    // Non-presence should be signalled to and controlled by users.
-    kOptional,
-    // Non-presence is hidden from users.
-    // Implementations may omit writing default values.
-    kDefault,
-  };
-  Presence static MakeFieldPresence(bool optional, bool required) {
-    FLATBUFFERS_ASSERT(!(required && optional));
-    // clang-format off
-    return required ? FieldDef::kRequired
-         : optional ? FieldDef::kOptional
-                    : FieldDef::kDefault;
-    // clang-format on
-  }
-  Presence presence;
-
-  StructDef* nested_flatbuffer;  // This field contains nested FlatBuffer data.
-  size_t padding;                // Bytes to always pad after this field.
-
-  // sibling_union_field is always set to nullptr. The only exception is
-  // when FieldDef is a union field or an union type field. Therefore,
-  // sibling_union_field on a union field points to the union type field
-  // and vice-versa.
-  FieldDef* sibling_union_field;
-};
-
-struct StructDef : public Definition {
-  enum class CycleStatus {
-    NotChecked,
-    InProgress,
-    Checked,
-  };
-
-  StructDef()
-      : fixed(false),
-        predecl(true),
-        sortbysize(true),
-        has_key(false),
-        minalign(1),
-        bytesize(0),
-        cycle_status{CycleStatus::NotChecked} {}
-
-  void PadLastField(size_t min_align) {
-    auto padding = PaddingBytes(bytesize, min_align);
-    bytesize += padding;
-    if (fields.vec.size()) fields.vec.back()->padding = padding;
-  }
-
-  Offset<reflection::Object> Serialize(FlatBufferBuilder* builder,
-                                       const Parser& parser) const;
-
-  bool Deserialize(Parser& parser, const reflection::Object* object);
-
-  SymbolTable<FieldDef> fields;
-
-  bool fixed;       // If it's struct, not a table.
-  bool predecl;     // If it's used before it was defined.
-  bool sortbysize;  // Whether fields come in the declaration or size order.
-  bool has_key;     // It has a key field.
-  size_t minalign;  // What the whole object needs to be aligned to.
-  size_t bytesize;  // Size if fixed.
-
-  CycleStatus cycle_status;  // used for determining if we have circular references
-
-  flatbuffers::unique_ptr<std::string> original_location;
-  std::vector<voffset_t> reserved_ids;
-};
-
-struct EnumDef;
-struct EnumValBuilder;
-
-struct EnumVal {
-  Offset<reflection::EnumVal> Serialize(FlatBufferBuilder* builder,
-                                        const Parser& parser) const;
-
-  bool Deserialize(Parser& parser, const reflection::EnumVal* val);
-
-  flatbuffers::Offset<
-      flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>>
-  SerializeAttributes(FlatBufferBuilder* builder, const Parser& parser) const;
-
-  bool DeserializeAttributes(Parser& parser,
-                             const Vector<Offset<reflection::KeyValue>>* attrs);
-
-  uint64_t GetAsUInt64() const { return static_cast<uint64_t>(value); }
-  int64_t GetAsInt64() const { return value; }
-  bool IsZero() const { return 0 == value; }
-  bool IsNonZero() const { return !IsZero(); }
-
-  std::string name;
-  std::vector<std::string> doc_comment;
-  Type union_type;
-  SymbolTable<Value> attributes;
-
- private:
-  friend EnumDef;
-  friend EnumValBuilder;
-  friend bool operator==(const EnumVal& lhs, const EnumVal& rhs);
-
-  EnumVal(const std::string& _name, int64_t _val) : name(_name), value(_val) {}
-  EnumVal() : value(0) {}
-
-  int64_t value;
-};
-
-struct EnumDef : public Definition {
-  EnumDef() : is_union(false), uses_multiple_type_instances(false) {}
-
-  Offset<reflection::Enum> Serialize(FlatBufferBuilder* builder,
-                                     const Parser& parser) const;
-
-  bool Deserialize(Parser& parser, const reflection::Enum* values);
-
-  template <typename T>
-  void ChangeEnumValue(EnumVal* ev, T new_val);
-  void SortByValue();
-  void RemoveDuplicates();
-
-  std::string AllFlags() const;
-  const EnumVal* MinValue() const;
-  const EnumVal* MaxValue() const;
-  // Returns the number of integer steps from v1 to v2.
-  uint64_t Distance(const EnumVal* v1, const EnumVal* v2) const;
-  // Returns the number of integer steps from Min to Max.
-  uint64_t Distance() const { return Distance(MinValue(), MaxValue()); }
-
-  EnumVal* ReverseLookup(int64_t enum_idx,
-                         bool skip_union_default = false) const;
-  EnumVal* FindByValue(const std::string& constant) const;
-
-  std::string ToString(const EnumVal& ev) const {
-    return IsUInt64() ? NumToString(ev.GetAsUInt64())
-                      : NumToString(ev.GetAsInt64());
-  }
-
-  size_t size() const { return vals.vec.size(); }
-
-  const std::vector<EnumVal*>& Vals() const { return vals.vec; }
-
-  const EnumVal* Lookup(const std::string& enum_name) const {
-    return vals.Lookup(enum_name);
-  }
-
-  bool is_union;
-  // Type is a union which uses type aliases where at least one type is
-  // available under two different names.
-  bool uses_multiple_type_instances;
-  Type underlying_type;
-
- private:
-  bool IsUInt64() const {
-    return (BASE_TYPE_ULONG == underlying_type.base_type);
-  }
-
-  friend EnumValBuilder;
-  SymbolTable<EnumVal> vals;
-};
-
-inline bool IsString(const Type& type) {
-  return type.base_type == BASE_TYPE_STRING;
-}
-
-inline bool IsStruct(const Type& type) {
-  return type.base_type == BASE_TYPE_STRUCT && type.struct_def->fixed;
-}
-
-inline bool IsIncompleteStruct(const Type& type) {
-  return type.base_type == BASE_TYPE_STRUCT && type.struct_def->predecl;
-}
-
-inline bool IsTable(const Type& type) {
-  return type.base_type == BASE_TYPE_STRUCT && !type.struct_def->fixed;
-}
-
-inline bool IsUnion(const Type& type) {
-  return type.enum_def != nullptr && type.enum_def->is_union;
-}
-
-inline bool IsUnionType(const Type& type) {
-  return IsUnion(type) && IsInteger(type.base_type);
-}
-
-inline bool IsVector(const Type& type) { return IsVector(type.base_type); }
-
-inline bool IsVectorOfStruct(const Type& type) {
-  return IsVector(type) && IsStruct(type.VectorType());
-}
-
-inline bool IsVectorOfTable(const Type& type) {
-  return IsVector(type) && IsTable(type.VectorType());
-}
-
-inline bool IsArray(const Type& type) {
-  return type.base_type == BASE_TYPE_ARRAY;
-}
-
-inline bool IsSeries(const Type& type) {
-  return IsVector(type) || IsArray(type);
-}
-
-inline bool IsEnum(const Type& type) {
-  return type.enum_def != nullptr && IsInteger(type.base_type);
-}
-
-inline size_t InlineSize(const Type& type) {
-  return IsStruct(type)
-             ? type.struct_def->bytesize
-             : (IsArray(type)
-                    ? InlineSize(type.VectorType()) * type.fixed_length
-                    : SizeOf(type.base_type));
-}
-
-inline size_t InlineAlignment(const Type& type) {
-  if (IsStruct(type)) {
-    return type.struct_def->minalign;
-  } else if (IsArray(type)) {
-    return IsStruct(type.VectorType()) ? type.struct_def->minalign
-                                       : SizeOf(type.element);
-  } else {
-    return SizeOf(type.base_type);
-  }
-}
-inline bool operator==(const EnumVal& lhs, const EnumVal& rhs) {
-  return lhs.value == rhs.value;
-}
-inline bool operator!=(const EnumVal& lhs, const EnumVal& rhs) {
-  return !(lhs == rhs);
-}
-
-inline bool EqualByName(const Type& a, const Type& b) {
-  return a.base_type == b.base_type && a.element == b.element &&
-         (a.struct_def == b.struct_def ||
-          (a.struct_def != nullptr && b.struct_def != nullptr &&
-           a.struct_def->name == b.struct_def->name)) &&
-         (a.enum_def == b.enum_def ||
-          (a.enum_def != nullptr && b.enum_def != nullptr &&
-           a.enum_def->name == b.enum_def->name));
-}
-
-struct RPCCall : public Definition {
-  Offset<reflection::RPCCall> Serialize(FlatBufferBuilder* builder,
-                                        const Parser& parser) const;
-
-  bool Deserialize(Parser& parser, const reflection::RPCCall* call);
-
-  StructDef *request, *response;
-};
-
-struct ServiceDef : public Definition {
-  Offset<reflection::Service> Serialize(FlatBufferBuilder* builder,
-                                        const Parser& parser) const;
-  bool Deserialize(Parser& parser, const reflection::Service* service);
-
-  SymbolTable<RPCCall> calls;
-};
-
-struct IncludedFile {
-  // The name of the schema file being included, as defined in the .fbs file.
-  // This includes the prefix (e.g., include "foo/bar/baz.fbs" would mean this
-  // value is "foo/bar/baz.fbs").
-  std::string schema_name;
-
-  // The filename of where the included file was found, after searching the
-  // relative paths plus any other paths included with `flatc -I ...`. Note,
-  // while this is sometimes the same as schema_name, it is not always, since it
-  // can be defined relative to where flatc was invoked.
-  std::string filename;
-};
-
-// Since IncludedFile is contained within a std::set, need to provide ordering.
-inline bool operator<(const IncludedFile& a, const IncludedFile& b) {
-  return a.filename < b.filename;
-}
-
-// Container of options that may apply to any of the source/text generators.
-struct IDLOptions {
-  // file saver
-  // shared pointer since this object gets copied and modified.
-  FileSaver* file_saver = nullptr;
-
-  // field case style options for C++
-  enum CaseStyle { CaseStyle_Unchanged = 0, CaseStyle_Upper, CaseStyle_Lower };
-  enum class ProtoIdGapAction { NO_OP, WARNING, ERROR };
-  bool gen_jvmstatic;
-  // Use flexbuffers instead for binary and text generation
-  bool use_flexbuffers;
-  bool strict_json;
-  bool output_default_scalars_in_json;
-  int indent_step;
-  bool cpp_minify_enums;
-  bool output_enum_identifiers;
-  bool prefixed_enums;
-  bool scoped_enums;
-  bool emit_min_max_enum_values;
-  bool swift_implementation_only;
-  bool include_dependence_headers;
-  bool mutable_buffer;
-  bool one_file;
-  bool proto_mode;
-  bool proto_oneof_union;
-  bool generate_all;
-  bool skip_unexpected_fields_in_json;
-  bool generate_name_strings;
-  bool generate_object_based_api;
-  bool gen_compare;
-  bool gen_absl_hash;
-  std::string cpp_object_api_pointer_type;
-  std::string cpp_object_api_string_type;
-  bool cpp_object_api_string_flexible_constructor;
-  CaseStyle cpp_object_api_field_case_style;
-  bool cpp_direct_copy;
-  bool gen_nullable;
-  std::string java_package_prefix;
-  bool java_checkerframework;
-  bool gen_generated;
-  bool gen_json_coders;
-  std::string object_prefix;
-  std::string object_suffix;
-  bool union_value_namespacing;
-  bool allow_non_utf8;
-  bool natural_utf8;
-  std::string include_prefix;
-  bool keep_prefix;
-  bool binary_schema_comments;
-  bool binary_schema_builtins;
-  bool binary_schema_gen_embed;
-  bool binary_schema_absolute_paths;
-  std::string go_import;
-  std::string go_namespace;
-  std::string go_module_name;
-  bool protobuf_ascii_alike;
-  bool size_prefixed;
-  std::string root_type;
-  bool force_defaults;
-  bool java_primitive_has_method;
-  bool cs_gen_json_serializer;
-  std::vector<std::string> cpp_includes;
-  std::string cpp_std;
-  bool cpp_static_reflection;
-  std::string proto_namespace_suffix;
-  std::string filename_suffix;
-  std::string filename_extension;
-  bool no_warnings;
-  bool warnings_as_errors;
-  std::string project_root;
-  bool cs_global_alias;
-  bool json_nested_flatbuffers;
-  bool json_nested_flexbuffers;
-  bool json_nested_legacy_flatbuffers;
-  bool ts_no_import_ext;
-  bool no_leak_private_annotations;
-  bool require_json_eof;
-  bool keep_proto_id;
-
-  /********************************** Python **********************************/
-  bool python_no_type_prefix_suffix;
-  bool python_typing;
-  bool python_decode_obj_api_strings = false;
-
-  // The target Python version. Can be one of the following:
-  // -  "0"
-  // -  "2"
-  // -  "3"
-  // -  "2.<minor>"
-  // -  "3.<minor>"
-  // -  "2.<minor>.<micro>"
-  // -  "3.<minor>.<micro>"
-  //
-  // https://docs.python.org/3/faq/general.html#how-does-the-python-version-numbering-scheme-work
-  std::string python_version;
-
-  // Whether to generate numpy helpers.
-  bool python_gen_numpy;
-
-  bool ts_omit_entrypoint;
-  bool ts_undefined_for_optionals;
-  ProtoIdGapAction proto_id_gap_action;
-
-  // Possible options for the more general generator below.
-  enum Language {
-    kJava = 1 << 0,
-    kCSharp = 1 << 1,
-    kGo = 1 << 2,
-    kCpp = 1 << 3,
-    kPython = 1 << 5,
-    kPhp = 1 << 6,
-    kJson = 1 << 7,
-    kBinary = 1 << 8,
-    kTs = 1 << 9,
-    kJsonSchema = 1 << 10,
-    kDart = 1 << 11,
-    kLua = 1 << 12,
-    kLobster = 1 << 13,
-    kRust = 1 << 14,
-    kKotlin = 1 << 15,
-    kSwift = 1 << 16,
-    kNim = 1 << 17,
-    kProto = 1 << 18,
-    kKotlinKmp = 1 << 19,
-    kMAX
-  };
-
-  enum MiniReflect { kNone, kTypes, kTypesAndNames };
-
-  MiniReflect mini_reflect;
-
-  // If set, require all fields in a table to be explicitly numbered.
-  bool require_explicit_ids;
-
-  // If set, implement serde::Serialize for generated Rust types
-  bool rust_serialize;
-
-  // If set, generate rust types in individual files with a root module file.
-  bool rust_module_root_file;
-
-  // The corresponding language bit will be set if a language is included
-  // for code generation.
-  unsigned long lang_to_generate;
-
-  // If set (default behavior), empty string fields will be set to nullptr to
-  // make the flatbuffer more compact.
-  bool set_empty_strings_to_null;
-
-  // If set (default behavior), empty vector fields will be set to nullptr to
-  // make the flatbuffer more compact.
-  bool set_empty_vectors_to_null;
-
-  /*********************************** gRPC ***********************************/
-  std::string grpc_filename_suffix;
-  bool grpc_use_system_headers;
-  std::string grpc_search_path;
-  std::vector<std::string> grpc_additional_headers;
-  // Generate C++ gRPC Callback API (modern async API) service code when used
-  // together with --grpc. This is an additive, opt-in feature.
-  bool grpc_callback_api;
-
-  /******************************* Python gRPC ********************************/
-  bool grpc_python_typed_handlers;
-
-  IDLOptions()
-      : gen_jvmstatic(false),
-        use_flexbuffers(false),
-        strict_json(false),
-        output_default_scalars_in_json(false),
-        indent_step(2),
-        cpp_minify_enums(false),
-        output_enum_identifiers(true),
-        prefixed_enums(true),
-        scoped_enums(false),
-        emit_min_max_enum_values(true),
-        swift_implementation_only(false),
-        include_dependence_headers(true),
-        mutable_buffer(false),
-        one_file(false),
-        proto_mode(false),
-        proto_oneof_union(false),
-        generate_all(false),
-        skip_unexpected_fields_in_json(false),
-        generate_name_strings(false),
-        generate_object_based_api(false),
-        gen_compare(false),
-        gen_absl_hash(false),
-        cpp_object_api_pointer_type("std::unique_ptr"),
-        cpp_object_api_string_flexible_constructor(false),
-        cpp_object_api_field_case_style(CaseStyle_Unchanged),
-        cpp_direct_copy(true),
-        gen_nullable(false),
-        java_checkerframework(false),
-        gen_generated(false),
-        gen_json_coders(false),
-        object_suffix("T"),
-        union_value_namespacing(true),
-        allow_non_utf8(false),
-        natural_utf8(false),
-        keep_prefix(false),
-        binary_schema_comments(false),
-        binary_schema_builtins(false),
-        binary_schema_gen_embed(false),
-        binary_schema_absolute_paths(false),
-        protobuf_ascii_alike(false),
-        size_prefixed(false),
-        force_defaults(false),
-        java_primitive_has_method(false),
-        cs_gen_json_serializer(false),
-        cpp_static_reflection(false),
-        filename_suffix("_generated"),
-        filename_extension(),
-        no_warnings(false),
-        warnings_as_errors(false),
-        project_root(""),
-        cs_global_alias(false),
-        json_nested_flatbuffers(true),
-        json_nested_flexbuffers(true),
-        json_nested_legacy_flatbuffers(false),
-        ts_no_import_ext(false),
-        no_leak_private_annotations(false),
-        require_json_eof(true),
-        keep_proto_id(false),
-        python_no_type_prefix_suffix(false),
-        python_typing(false),
-        python_gen_numpy(true),
-        ts_omit_entrypoint(false),
-        ts_undefined_for_optionals(false),
-        proto_id_gap_action(ProtoIdGapAction::WARNING),
-        mini_reflect(IDLOptions::kNone),
-        require_explicit_ids(false),
-        rust_serialize(false),
-        rust_module_root_file(false),
-        lang_to_generate(0),
-        set_empty_strings_to_null(true),
-        set_empty_vectors_to_null(true),
-        grpc_filename_suffix(".fb"),
-        grpc_use_system_headers(true),
-        grpc_callback_api(false),
-        grpc_python_typed_handlers(false) {}
-};
-
-// This encapsulates where the parser is in the current source file.
-struct ParserState {
-  ParserState()
-      : prev_cursor_(nullptr),
-        cursor_(nullptr),
-        line_start_(nullptr),
-        line_(0),
-        token_(-1),
-        attr_is_trivial_ascii_string_(true) {}
-
- protected:
-  void ResetState(const char* source) {
-    prev_cursor_ = source;
-    cursor_ = source;
-    line_ = 0;
-    MarkNewLine();
-  }
-
-  void MarkNewLine() {
-    line_start_ = cursor_;
-    line_ += 1;
-  }
-
-  int64_t CursorPosition() const {
-    FLATBUFFERS_ASSERT(cursor_ && line_start_ && cursor_ >= line_start_);
-    return static_cast<int64_t>(cursor_ - line_start_);
-  }
-
-  const char* prev_cursor_;
-  const char* cursor_;
-  const char* line_start_;
-  int line_;  // the current line being parsed
-  int token_;
-
-  // Flag: text in attribute_ is true ASCII string without escape
-  // sequences. Only printable ASCII (without [\t\r\n]).
-  // Used for number-in-string (and base64 string in future).
-  bool attr_is_trivial_ascii_string_;
-  std::string attribute_;
-  std::vector<std::string> doc_comment_;
-};
-
-// A way to make error propagation less error prone by requiring values to be
-// checked.
-// Once you create a value of this type you must either:
-// - Call Check() on it.
-// - Copy or assign it to another value.
-// Failure to do so leads to an assert.
-// This guarantees that this as return value cannot be ignored.
-class CheckedError {
- public:
-  explicit CheckedError(bool error)
-      : is_error_(error), has_been_checked_(false) {}
-
-  CheckedError& operator=(const CheckedError& other) {
-    is_error_ = other.is_error_;
-    has_been_checked_ = false;
-    other.has_been_checked_ = true;
-    return *this;
-  }
-
-  CheckedError(const CheckedError& other) {
-    *this = other;  // Use assignment operator.
-  }
-
-  ~CheckedError() { FLATBUFFERS_ASSERT(has_been_checked_); }
-
-  bool Check() {
-    has_been_checked_ = true;
-    return is_error_;
-  }
-
- private:
-  bool is_error_;
-  mutable bool has_been_checked_;
-};
-
-// Additionally, in GCC we can get these errors statically, for additional
-// assurance:
-// clang-format off
-#ifdef __GNUC__
-#define FLATBUFFERS_CHECKED_ERROR CheckedError \
-          __attribute__((warn_unused_result))
-#else
-#define FLATBUFFERS_CHECKED_ERROR CheckedError
-#endif
-// clang-format on
-
-class Parser : public ParserState {
- public:
-  explicit Parser(const IDLOptions& options = IDLOptions())
-      : current_namespace_(nullptr),
-        empty_namespace_(nullptr),
-        flex_builder_(256, flexbuffers::BUILDER_FLAG_SHARE_ALL),
-        root_struct_def_(nullptr),
-        opts(options),
-        uses_flexbuffers_(false),
-        has_warning_(false),
-        advanced_features_(0),
-        source_(nullptr),
-        anonymous_counter_(0),
-        parse_depth_counter_(0) {
-    if (opts.force_defaults) {
-      builder_.ForceDefaults(true);
-    }
-    // Start out with the empty namespace being current.
-    empty_namespace_ = new Namespace();
-    namespaces_.push_back(empty_namespace_);
-    current_namespace_ = empty_namespace_;
-    known_attributes_["deprecated"] = true;
-    known_attributes_["required"] = true;
-    known_attributes_["key"] = true;
-    known_attributes_["shared"] = true;
-    known_attributes_["hash"] = true;
-    known_attributes_["id"] = true;
-    known_attributes_["force_align"] = true;
-    known_attributes_["bit_flags"] = true;
-    known_attributes_["original_order"] = true;
-    known_attributes_["nested_flatbuffer"] = true;
-    known_attributes_["csharp_partial"] = true;
-    known_attributes_["streaming"] = true;
-    known_attributes_["idempotent"] = true;
-    known_attributes_["cpp_type"] = true;
-    known_attributes_["cpp_ptr_type"] = true;
-    known_attributes_["cpp_ptr_type_get"] = true;
-    known_attributes_["cpp_str_type"] = true;
-    known_attributes_["cpp_str_flex_ctor"] = true;
-    known_attributes_["native_inline"] = true;
-    known_attributes_["native_custom_alloc"] = true;
-    known_attributes_["native_type"] = true;
-    known_attributes_["native_type_pack_name"] = true;
-    known_attributes_["native_default"] = true;
-    known_attributes_["flexbuffer"] = true;
-    known_attributes_["private"] = true;
-
-    // An attribute added to a field to indicate that is uses 64-bit addressing.
-    known_attributes_["offset64"] = true;
-
-    // An attribute added to a vector field to indicate that it uses 64-bit
-    // addressing and it has a 64-bit length.
-    known_attributes_["vector64"] = true;
-  }
-
-  // Copying is not allowed
-  Parser(const Parser&) = delete;
-  Parser& operator=(const Parser&) = delete;
-
-  Parser(Parser&&) = default;
-  Parser& operator=(Parser&&) = default;
-
-  ~Parser() {
-    for (auto it = namespaces_.begin(); it != namespaces_.end(); ++it) {
-      delete *it;
-    }
-  }
-
-  // Parse the string containing either schema or JSON data, which will
-  // populate the SymbolTable's or the FlatBufferBuilder above.
-  // include_paths is used to resolve any include statements, and typically
-  // should at least include the project path (where you loaded source_ from).
-  // include_paths must be nullptr terminated if specified.
-  // If include_paths is nullptr, it will attempt to load from the current
-  // directory.
-  // If the source was loaded from a file and isn't an include file,
-  // supply its name in source_filename.
-  // All paths specified in this call must be in posix format, if you accept
-  // paths from user input, please call PosixPath on them first.
-  bool Parse(const char* _source, const char** include_paths = nullptr,
-             const char* source_filename = nullptr);
-
-  bool ParseJson(const char* json, const char* json_filename = nullptr);
-
-  // Returns the number of characters were consumed when parsing a JSON string.
-  std::ptrdiff_t BytesConsumed() const;
-
-  // Set the root type. May override the one set in the schema.
-  bool SetRootType(const char* name);
-
-  // Mark all definitions as already having code generated.
-  void MarkGenerated();
-
-  // Get the files recursively included by the given file. The returned
-  // container will have at least the given file.
-  std::set<std::string> GetIncludedFilesRecursive(
-      const std::string& file_name) const;
-
-  // Fills builder_ with a binary version of the schema parsed.
-  // See reflection/reflection.fbs
-  void Serialize();
-
-  // Deserialize a schema buffer
-  bool Deserialize(const uint8_t* buf, const size_t size);
-
-  // Fills internal structure as if the schema passed had been loaded by parsing
-  // with Parse except that included filenames will not be populated.
-  bool Deserialize(const reflection::Schema* schema);
-
-  Type* DeserializeType(const reflection::Type* type);
-
-  // Checks that the schema represented by this parser is a safe evolution
-  // of the schema provided. Returns non-empty error on any problems.
-  std::string ConformTo(const Parser& base);
-
-  // Similar to Parse(), but now only accepts JSON to be parsed into a
-  // FlexBuffer.
-  bool ParseFlexBuffer(const char* source, const char* source_filename,
-                       flexbuffers::Builder* builder);
-
-  StructDef* LookupStruct(const std::string& id) const;
-  StructDef* LookupStructThruParentNamespaces(const std::string& id) const;
-
-  std::string UnqualifiedName(const std::string& fullQualifiedName);
-
-  FLATBUFFERS_CHECKED_ERROR Error(const std::string& msg);
-
-  // @brief Verify that any of 'opts.lang_to_generate' supports Optional scalars
-  // in a schema.
-  // @param opts Options used to parce a schema and generate code.
-  static bool SupportsOptionalScalars(const flatbuffers::IDLOptions& opts);
-
-  // Get the set of included files that are directly referenced by the file
-  // being parsed. This does not include files that are transitively included by
-  // others includes.
-  std::vector<IncludedFile> GetIncludedFiles() const;
-
-  bool HasCircularStructDependency();
-
- private:
-  class ParseDepthGuard;
-
-  void Message(const std::string& msg);
-  void Warning(const std::string& msg);
-  FLATBUFFERS_CHECKED_ERROR ParseHexNum(int nibbles, uint64_t* val);
-  FLATBUFFERS_CHECKED_ERROR Next();
-  FLATBUFFERS_CHECKED_ERROR SkipByteOrderMark();
-  bool Is(int t) const;
-  bool IsIdent(const char* id) const;
-  FLATBUFFERS_CHECKED_ERROR Expect(int t);
-  std::string TokenToStringId(int t) const;
-  EnumDef* LookupEnum(const std::string& id);
-  FLATBUFFERS_CHECKED_ERROR ParseNamespacing(std::string* id,
-                                             std::string* last);
-  FLATBUFFERS_CHECKED_ERROR ParseTypeIdent(Type& type);
-  FLATBUFFERS_CHECKED_ERROR ParseType(Type& type);
-  FLATBUFFERS_CHECKED_ERROR AddField(StructDef& struct_def,
-                                     const std::string& name, const Type& type,
-                                     FieldDef** dest);
-  FLATBUFFERS_CHECKED_ERROR ParseField(StructDef& struct_def);
-  FLATBUFFERS_CHECKED_ERROR ParseString(Value& val, bool use_string_pooling);
-  FLATBUFFERS_CHECKED_ERROR ParseComma();
-  FLATBUFFERS_CHECKED_ERROR ParseAnyValue(Value& val, FieldDef* field,
-                                          size_t parent_fieldn,
-                                          const StructDef* parent_struct_def,
-                                          size_t count,
-                                          bool inside_vector = false);
-  template <typename F>
-  FLATBUFFERS_CHECKED_ERROR ParseTableDelimiters(size_t& fieldn,
-                                                 const StructDef* struct_def,
-                                                 F body);
-  FLATBUFFERS_CHECKED_ERROR ParseTable(const StructDef& struct_def,
-                                       std::string* value, uoffset_t* ovalue);
-  void SerializeStruct(const StructDef& struct_def, const Value& val);
-  void SerializeStruct(FlatBufferBuilder& builder, const StructDef& struct_def,
-                       const Value& val);
-  template <typename F>
-  FLATBUFFERS_CHECKED_ERROR ParseVectorDelimiters(size_t& count, F body);
-  FLATBUFFERS_CHECKED_ERROR ParseVector(const Type& type, uoffset_t* ovalue,
-                                        FieldDef* field, size_t fieldn);
-  FLATBUFFERS_CHECKED_ERROR ParseArray(Value& array);
-  FLATBUFFERS_CHECKED_ERROR ParseNestedFlatbuffer(
-      Value& val, FieldDef* field, size_t fieldn,
-      const StructDef* parent_struct_def);
-  FLATBUFFERS_CHECKED_ERROR ParseMetaData(SymbolTable<Value>* attributes);
-  FLATBUFFERS_CHECKED_ERROR TryTypedValue(const std::string* name, int dtoken,
-                                          bool check, Value& e, BaseType req,
-                                          bool* destmatch);
-  FLATBUFFERS_CHECKED_ERROR ParseHash(Value& e, FieldDef* field);
-  FLATBUFFERS_CHECKED_ERROR TokenError();
-  FLATBUFFERS_CHECKED_ERROR ParseSingleValue(const std::string* name, Value& e,
-                                             bool check_now);
-  FLATBUFFERS_CHECKED_ERROR ParseFunction(const std::string* name, Value& e);
-  FLATBUFFERS_CHECKED_ERROR ParseEnumFromString(const Type& type,
-                                                std::string* result);
-  StructDef* LookupCreateStruct(const std::string& name,
-                                bool create_if_new = true,
-                                bool definition = false);
-  FLATBUFFERS_CHECKED_ERROR ParseEnum(bool is_union, EnumDef** dest,
-                                      const char* filename);
-  FLATBUFFERS_CHECKED_ERROR ParseNamespace();
-  FLATBUFFERS_CHECKED_ERROR StartStruct(const std::string& name,
-                                        StructDef** dest);
-  FLATBUFFERS_CHECKED_ERROR StartEnum(const std::string& name, bool is_union,
-                                      EnumDef** dest);
-  FLATBUFFERS_CHECKED_ERROR ParseDecl(const char* filename);
-  FLATBUFFERS_CHECKED_ERROR ParseService(const char* filename);
-  FLATBUFFERS_CHECKED_ERROR ParseProtoFields(StructDef* struct_def,
-                                             bool isextend, bool inside_oneof);
-  FLATBUFFERS_CHECKED_ERROR ParseProtoMapField(StructDef* struct_def);
-  FLATBUFFERS_CHECKED_ERROR ParseProtoOption();
-  FLATBUFFERS_CHECKED_ERROR ParseProtoKey();
-  FLATBUFFERS_CHECKED_ERROR ParseProtoDecl();
-  FLATBUFFERS_CHECKED_ERROR ParseProtoCurliesOrIdent();
-  FLATBUFFERS_CHECKED_ERROR ParseTypeFromProtoType(Type* type);
-  FLATBUFFERS_CHECKED_ERROR SkipAnyJsonValue();
-  FLATBUFFERS_CHECKED_ERROR ParseFlexBufferNumericConstant(
-      flexbuffers::Builder* builder);
-  FLATBUFFERS_CHECKED_ERROR ParseFlexBufferValue(flexbuffers::Builder* builder);
-  FLATBUFFERS_CHECKED_ERROR StartParseFile(const char* source,
-                                           const char* source_filename);
-  FLATBUFFERS_CHECKED_ERROR ParseRoot(const char* _source,
-                                      const char** include_paths,
-                                      const char* source_filename);
-  FLATBUFFERS_CHECKED_ERROR CheckPrivateLeak();
-  FLATBUFFERS_CHECKED_ERROR CheckPrivatelyLeakedFields(
-      const Definition& def, const Definition& value_type);
-  FLATBUFFERS_CHECKED_ERROR DoParse(const char* _source,
-                                    const char** include_paths,
-                                    const char* source_filename,
-                                    const char* include_filename);
-  FLATBUFFERS_CHECKED_ERROR DoParseJson();
-  FLATBUFFERS_CHECKED_ERROR CheckClash(std::vector<FieldDef*>& fields,
-                                       StructDef* struct_def,
-                                       const char* suffix, BaseType baseType);
-  FLATBUFFERS_CHECKED_ERROR ParseAlignAttribute(
-      const std::string& align_constant, size_t min_align, size_t* align);
-
-  bool SupportsAdvancedUnionFeatures() const;
-  bool SupportsAdvancedArrayFeatures() const;
-  bool SupportsOptionalScalars() const;
-  bool SupportsDefaultVectorsAndStrings() const;
-  bool Supports64BitOffsets() const;
-  bool SupportsUnionUnderlyingType() const;
-  Namespace* UniqueNamespace(Namespace* ns);
-
-  FLATBUFFERS_CHECKED_ERROR RecurseError();
-  template <typename F>
-  CheckedError Recurse(F f);
-
-  const std::string& GetPooledString(const std::string& s) const;
-
- public:
-  SymbolTable<Type> types_;
-  SymbolTable<StructDef> structs_;
-  SymbolTable<EnumDef> enums_;
-  SymbolTable<ServiceDef> services_;
-  std::vector<Namespace*> namespaces_;
-  Namespace* current_namespace_;
-  Namespace* empty_namespace_;
-  std::string error_;  // User readable error_ if Parse() == false
-
-  FlatBufferBuilder builder_;  // any data contained in the file
-  flexbuffers::Builder flex_builder_;
-  flexbuffers::Reference flex_root_;
-  StructDef* root_struct_def_;
-  std::string file_identifier_;
-  std::string file_extension_;
-
-  std::map<uint64_t, std::string> included_files_;
-  std::map<std::string, std::set<IncludedFile>> files_included_per_file_;
-  std::vector<std::string> native_included_files_;
-
-  std::map<std::string, bool> known_attributes_;
-
-  IDLOptions opts;
-  bool uses_flexbuffers_;
-  bool has_warning_;
-
-  uint64_t advanced_features_;
-
-  std::string file_being_parsed_;
-
- private:
-  const char* source_;
-
-  std::vector<std::pair<Value, FieldDef*>> field_stack_;
-
-  // TODO(cneo): Refactor parser to use string_cache more often to save
-  // on memory usage.
-  mutable std::set<std::string> string_cache_;
-
-  int anonymous_counter_;
-  int parse_depth_counter_;  // stack-overflow guard
-};
-
-// Utility functions for multiple generators:
-
-// Generate text (JSON) from a given FlatBuffer, and a given Parser
-// object that has been populated with the corresponding schema.
-// If ident_step is 0, no indentation will be generated. Additionally,
-// if it is less than 0, no linefeeds will be generated either.
-// See idl_gen_text.cpp.
-// strict_json adds "quotes" around field names if true.
-// These functions return nullptr on success, or an error string,
-// which may happen if the flatbuffer cannot be encoded in JSON (e.g.,
-// it contains non-UTF-8 byte arrays in String values).
-extern bool GenerateTextFromTable(const Parser& parser, const void* table,
-                                  const std::string& tablename,
-                                  std::string* text);
-extern const char* GenerateText(const Parser& parser, const void* flatbuffer,
-                                std::string* text);
-extern const char* GenerateTextFile(const Parser& parser,
-                                    const std::string& path,
-                                    const std::string& file_name);
-
-extern const char* GenTextFromTable(const Parser& parser, const void* table,
-                                    const std::string& tablename,
-                                    std::string* text);
-extern const char* GenText(const Parser& parser, const void* flatbuffer,
-                           std::string* text);
-extern const char* GenTextFile(const Parser& parser, const std::string& path,
-                               const std::string& file_name);
-
-// Generate GRPC Cpp interfaces.
-// See idl_gen_grpc.cpp.
-bool GenerateCppGRPC(const Parser& parser, const std::string& path,
-                     const std::string& file_name);
-
-// Generate GRPC Go interfaces.
-// See idl_gen_grpc.cpp.
-bool GenerateGoGRPC(const Parser& parser, const std::string& path,
-                    const std::string& file_name);
-
-// Generate GRPC Java classes.
-// See idl_gen_grpc.cpp
-bool GenerateJavaGRPC(const Parser& parser, const std::string& path,
-                      const std::string& file_name);
-
-// Generate GRPC Python interfaces.
-// See idl_gen_grpc.cpp.
-bool GeneratePythonGRPC(const Parser& parser, const std::string& path,
-                        const std::string& file_name);
-
-// Generate GRPC Swift interfaces.
-// See idl_gen_grpc.cpp.
-extern bool GenerateSwiftGRPC(const Parser& parser, const std::string& path,
-                              const std::string& file_name);
-
-extern bool GenerateTSGRPC(const Parser& parser, const std::string& path,
-                           const std::string& file_name);
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_IDL_H_
diff --git a/external/flatbuffers/include/flatbuffers/minireflect.h b/external/flatbuffers/include/flatbuffers/minireflect.h
deleted file mode 100644
index 77be5165..00000000
--- a/external/flatbuffers/include/flatbuffers/minireflect.h
+++ /dev/null
@@ -1,441 +0,0 @@
-/*
- * Copyright 2017 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_MINIREFLECT_H_
-#define FLATBUFFERS_MINIREFLECT_H_
-
-#include "flatbuffers/flatbuffers.h"
-#include "flatbuffers/util.h"
-
-namespace flatbuffers {
-
-// Utilities that can be used with the "mini reflection" tables present
-// in generated code with --reflect-types (only types) or --reflect-names
-// (also names).
-// This allows basic reflection functionality such as pretty-printing
-// that does not require the use of the schema parser or loading of binary
-// schema files at runtime (reflection.h).
-
-// For any of the functions below that take `const TypeTable *`, you pass
-// `FooTypeTable()` if the type of the root is `Foo`.
-
-// First, a generic iterator that can be used by multiple algorithms.
-
-struct IterationVisitor {
-  // These mark the scope of a table or struct.
-  virtual void StartSequence() {}
-  virtual void EndSequence() {}
-  // Called for each field regardless of whether it is present or not.
-  // If not present, val == nullptr. set_idx is the index of all set fields.
-  virtual void Field(size_t /*field_idx*/, size_t /*set_idx*/,
-                     ElementaryType /*type*/, bool /*is_vector*/,
-                     const TypeTable* /*type_table*/, const char* /*name*/,
-                     const uint8_t* /*val*/) {}
-  // Called for a value that is actually present, after a field, or as part
-  // of a vector.
-  virtual void UType(uint8_t, const char*) {}
-  virtual void Bool(bool) {}
-  virtual void Char(int8_t, const char*) {}
-  virtual void UChar(uint8_t, const char*) {}
-  virtual void Short(int16_t, const char*) {}
-  virtual void UShort(uint16_t, const char*) {}
-  virtual void Int(int32_t, const char*) {}
-  virtual void UInt(uint32_t, const char*) {}
-  virtual void Long(int64_t) {}
-  virtual void ULong(uint64_t) {}
-  virtual void Float(float) {}
-  virtual void Double(double) {}
-  virtual void String(const String*) {}
-  virtual void Unknown(const uint8_t*) {}  // From a future version.
-  // These mark the scope of a vector.
-  virtual void StartVector() {}
-  virtual void EndVector() {}
-  virtual void Element(size_t /*i*/, ElementaryType /*type*/,
-                       const TypeTable* /*type_table*/,
-                       const uint8_t* /*val*/) {}
-  virtual ~IterationVisitor() {}
-};
-
-inline size_t InlineSize(ElementaryType type, const TypeTable* type_table) {
-  switch (type) {
-    case ET_UTYPE:
-    case ET_BOOL:
-    case ET_CHAR:
-    case ET_UCHAR:
-      return 1;
-    case ET_SHORT:
-    case ET_USHORT:
-      return 2;
-    case ET_INT:
-    case ET_UINT:
-    case ET_FLOAT:
-    case ET_STRING:
-      return 4;
-    case ET_LONG:
-    case ET_ULONG:
-    case ET_DOUBLE:
-      return 8;
-    case ET_SEQUENCE:
-      switch (type_table->st) {
-        case ST_TABLE:
-        case ST_UNION:
-          return 4;
-        case ST_STRUCT:
-          return static_cast<size_t>(type_table->values[type_table->num_elems]);
-        default:
-          FLATBUFFERS_ASSERT(false);
-          return 1;
-      }
-    default:
-      FLATBUFFERS_ASSERT(false);
-      return 1;
-  }
-}
-
-inline int64_t LookupEnum(int64_t enum_val, const int64_t* values,
-                          size_t num_values) {
-  if (!values) return enum_val;
-  for (size_t i = 0; i < num_values; i++) {
-    if (enum_val == values[i]) return static_cast<int64_t>(i);
-  }
-  return -1;  // Unknown enum value.
-}
-
-template <typename T>
-const char* EnumName(T tval, const TypeTable* type_table) {
-  if (!type_table || !type_table->names) return nullptr;
-  auto i = LookupEnum(static_cast<int64_t>(tval), type_table->values,
-                      type_table->num_elems);
-  if (i >= 0 && i < static_cast<int64_t>(type_table->num_elems)) {
-    return type_table->names[i];
-  }
-  return nullptr;
-}
-
-void IterateObject(const uint8_t* obj, const TypeTable* type_table,
-                   IterationVisitor* visitor);
-
-inline void IterateValue(ElementaryType type, const uint8_t* val,
-                         const TypeTable* type_table, const uint8_t* prev_val,
-                         soffset_t vector_index, IterationVisitor* visitor) {
-  switch (type) {
-    case ET_UTYPE: {
-      auto tval = ReadScalar<uint8_t>(val);
-      visitor->UType(tval, EnumName(tval, type_table));
-      break;
-    }
-    case ET_BOOL: {
-      visitor->Bool(ReadScalar<uint8_t>(val) != 0);
-      break;
-    }
-    case ET_CHAR: {
-      auto tval = ReadScalar<int8_t>(val);
-      visitor->Char(tval, EnumName(tval, type_table));
-      break;
-    }
-    case ET_UCHAR: {
-      auto tval = ReadScalar<uint8_t>(val);
-      visitor->UChar(tval, EnumName(tval, type_table));
-      break;
-    }
-    case ET_SHORT: {
-      auto tval = ReadScalar<int16_t>(val);
-      visitor->Short(tval, EnumName(tval, type_table));
-      break;
-    }
-    case ET_USHORT: {
-      auto tval = ReadScalar<uint16_t>(val);
-      visitor->UShort(tval, EnumName(tval, type_table));
-      break;
-    }
-    case ET_INT: {
-      auto tval = ReadScalar<int32_t>(val);
-      visitor->Int(tval, EnumName(tval, type_table));
-      break;
-    }
-    case ET_UINT: {
-      auto tval = ReadScalar<uint32_t>(val);
-      visitor->UInt(tval, EnumName(tval, type_table));
-      break;
-    }
-    case ET_LONG: {
-      visitor->Long(ReadScalar<int64_t>(val));
-      break;
-    }
-    case ET_ULONG: {
-      visitor->ULong(ReadScalar<uint64_t>(val));
-      break;
-    }
-    case ET_FLOAT: {
-      visitor->Float(ReadScalar<float>(val));
-      break;
-    }
-    case ET_DOUBLE: {
-      visitor->Double(ReadScalar<double>(val));
-      break;
-    }
-    case ET_STRING: {
-      val += ReadScalar<uoffset_t>(val);
-      visitor->String(reinterpret_cast<const String*>(val));
-      break;
-    }
-    case ET_SEQUENCE: {
-      switch (type_table->st) {
-        case ST_TABLE:
-          val += ReadScalar<uoffset_t>(val);
-          IterateObject(val, type_table, visitor);
-          break;
-        case ST_STRUCT:
-          IterateObject(val, type_table, visitor);
-          break;
-        case ST_UNION: {
-          val += ReadScalar<uoffset_t>(val);
-          FLATBUFFERS_ASSERT(prev_val);
-          auto union_type = *prev_val;  // Always a uint8_t.
-          if (vector_index >= 0) {
-            auto type_vec = reinterpret_cast<const Vector<uint8_t>*>(prev_val);
-            union_type = type_vec->Get(static_cast<uoffset_t>(vector_index));
-          }
-          auto type_code_idx =
-              LookupEnum(union_type, type_table->values, type_table->num_elems);
-          if (type_code_idx >= 0 &&
-              type_code_idx < static_cast<int32_t>(type_table->num_elems)) {
-            auto type_code = type_table->type_codes[type_code_idx];
-            switch (type_code.base_type) {
-              case ET_SEQUENCE: {
-                auto ref = type_table->type_refs[type_code.sequence_ref]();
-                IterateObject(val, ref, visitor);
-                break;
-              }
-              case ET_STRING:
-                visitor->String(reinterpret_cast<const String*>(val));
-                break;
-              default:
-                visitor->Unknown(val);
-            }
-          } else {
-            visitor->Unknown(val);
-          }
-          break;
-        }
-        case ST_ENUM:
-          FLATBUFFERS_ASSERT(false);
-          break;
-      }
-      break;
-    }
-    default: {
-      visitor->Unknown(val);
-      break;
-    }
-  }
-}
-
-inline void IterateObject(const uint8_t* obj, const TypeTable* type_table,
-                          IterationVisitor* visitor) {
-  visitor->StartSequence();
-  const uint8_t* prev_val = nullptr;
-  size_t set_idx = 0;
-  size_t array_idx = 0;
-  for (size_t i = 0; i < type_table->num_elems; i++) {
-    auto type_code = type_table->type_codes[i];
-    auto type = static_cast<ElementaryType>(type_code.base_type);
-    auto is_repeating = type_code.is_repeating != 0;
-    auto ref_idx = type_code.sequence_ref;
-    const TypeTable* ref = nullptr;
-    if (ref_idx >= 0) {
-      ref = type_table->type_refs[ref_idx]();
-    }
-    auto name = type_table->names ? type_table->names[i] : nullptr;
-    const uint8_t* val = nullptr;
-    if (type_table->st == ST_TABLE) {
-      val = reinterpret_cast<const Table*>(obj)->GetAddressOf(
-          FieldIndexToOffset(static_cast<voffset_t>(i)));
-    } else {
-      val = obj + type_table->values[i];
-    }
-    visitor->Field(i, set_idx, type, is_repeating, ref, name, val);
-    if (val) {
-      set_idx++;
-      if (is_repeating) {
-        auto elem_ptr = val;
-        size_t size = 0;
-        if (type_table->st == ST_TABLE) {
-          // variable length vector
-          val += ReadScalar<uoffset_t>(val);
-          auto vec = reinterpret_cast<const Vector<uint8_t>*>(val);
-          elem_ptr = vec->Data();
-          size = vec->size();
-        } else {
-          // otherwise fixed size array
-          size = type_table->array_sizes[array_idx];
-          ++array_idx;
-        }
-        visitor->StartVector();
-        for (size_t j = 0; j < size; j++) {
-          visitor->Element(j, type, ref, elem_ptr);
-          IterateValue(type, elem_ptr, ref, prev_val, static_cast<soffset_t>(j),
-                       visitor);
-          elem_ptr += InlineSize(type, ref);
-        }
-        visitor->EndVector();
-      } else {
-        IterateValue(type, val, ref, prev_val, -1, visitor);
-      }
-    }
-    prev_val = val;
-  }
-  visitor->EndSequence();
-}
-
-inline void IterateFlatBuffer(const uint8_t* buffer,
-                              const TypeTable* type_table,
-                              IterationVisitor* callback) {
-  IterateObject(GetRoot<uint8_t>(buffer), type_table, callback);
-}
-
-// Outputting a Flatbuffer to a string. Tries to conform as close to JSON /
-// the output generated by idl_gen_text.cpp.
-
-struct ToStringVisitor : public IterationVisitor {
-  std::string s;
-  std::string d;
-  bool q;
-  std::string in;
-  size_t indent_level;
-  bool vector_delimited;
-  ToStringVisitor(std::string delimiter, bool quotes, std::string indent,
-                  bool vdelimited = true)
-      : d(delimiter),
-        q(quotes),
-        in(indent),
-        indent_level(0),
-        vector_delimited(vdelimited) {}
-  ToStringVisitor(std::string delimiter)
-      : d(delimiter),
-        q(false),
-        in(""),
-        indent_level(0),
-        vector_delimited(true) {}
-
-  void append_indent() {
-    for (size_t i = 0; i < indent_level; i++) {
-      s += in;
-    }
-  }
-
-  void StartSequence() {
-    s += "{";
-    s += d;
-    indent_level++;
-  }
-  void EndSequence() {
-    s += d;
-    indent_level--;
-    append_indent();
-    s += "}";
-  }
-  void Field(size_t /*field_idx*/, size_t set_idx, ElementaryType /*type*/,
-             bool /*is_vector*/, const TypeTable* /*type_table*/,
-             const char* name, const uint8_t* val) {
-    if (!val) return;
-    if (set_idx) {
-      s += ",";
-      s += d;
-    }
-    append_indent();
-    if (name) {
-      if (q) s += "\"";
-      s += name;
-      if (q) s += "\"";
-      s += ": ";
-    }
-  }
-  template <typename T>
-  void Named(T x, const char* name) {
-    if (name) {
-      if (q) s += "\"";
-      s += name;
-      if (q) s += "\"";
-    } else {
-      s += NumToString(x);
-    }
-  }
-  void UType(uint8_t x, const char* name) { Named(x, name); }
-  void Bool(bool x) { s += x ? "true" : "false"; }
-  void Char(int8_t x, const char* name) { Named(x, name); }
-  void UChar(uint8_t x, const char* name) { Named(x, name); }
-  void Short(int16_t x, const char* name) { Named(x, name); }
-  void UShort(uint16_t x, const char* name) { Named(x, name); }
-  void Int(int32_t x, const char* name) { Named(x, name); }
-  void UInt(uint32_t x, const char* name) { Named(x, name); }
-  void Long(int64_t x) { s += NumToString(x); }
-  void ULong(uint64_t x) { s += NumToString(x); }
-  void Float(float x) { s += NumToString(x); }
-  void Double(double x) { s += NumToString(x); }
-  void String(const struct String* str) {
-    EscapeString(str->c_str(), str->size(), &s, true, false);
-  }
-  void Unknown(const uint8_t*) { s += "(?)"; }
-  void StartVector() {
-    s += "[";
-    if (vector_delimited) {
-      s += d;
-      indent_level++;
-      append_indent();
-    } else {
-      s += " ";
-    }
-  }
-  void EndVector() {
-    if (vector_delimited) {
-      s += d;
-      indent_level--;
-      append_indent();
-    } else {
-      s += " ";
-    }
-    s += "]";
-  }
-  void Element(size_t i, ElementaryType /*type*/,
-               const TypeTable* /*type_table*/, const uint8_t* /*val*/) {
-    if (i) {
-      s += ",";
-      if (vector_delimited) {
-        s += d;
-        append_indent();
-      } else {
-        s += " ";
-      }
-    }
-  }
-};
-
-inline std::string FlatBufferToString(const uint8_t* buffer,
-                                      const TypeTable* type_table,
-                                      bool multi_line = false,
-                                      bool vector_delimited = true,
-                                      const std::string& indent = "",
-                                      bool quotes = false) {
-  ToStringVisitor tostring_visitor(multi_line ? "\n" : " ", quotes, indent,
-                                   vector_delimited);
-  IterateFlatBuffer(buffer, type_table, &tostring_visitor);
-  return tostring_visitor.s;
-}
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_MINIREFLECT_H_
diff --git a/external/flatbuffers/include/flatbuffers/pch/flatc_pch.h b/external/flatbuffers/include/flatbuffers/pch/flatc_pch.h
deleted file mode 100644
index abdfdedb..00000000
--- a/external/flatbuffers/include/flatbuffers/pch/flatc_pch.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2017 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_FLATC_PCH_H_
-#define FLATBUFFERS_FLATC_PCH_H_
-
-// stl
-#include <cassert>
-#include <cmath>
-#include <functional>
-#include <iostream>
-#include <iterator>
-#include <set>
-#include <sstream>
-#include <tuple>
-#include <unordered_map>
-#include <unordered_set>
-
-// flatbuffers
-#include "flatbuffers/code_generators.h"
-#include "flatbuffers/flatbuffers.h"
-#include "flatbuffers/flexbuffers.h"
-#include "flatbuffers/idl.h"
-#include "flatbuffers/pch/pch.h"
-
-#endif  // FLATBUFFERS_FLATC_PCH_H_
diff --git a/external/flatbuffers/include/flatbuffers/pch/pch.h b/external/flatbuffers/include/flatbuffers/pch/pch.h
deleted file mode 100644
index a7c48ea7..00000000
--- a/external/flatbuffers/include/flatbuffers/pch/pch.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright 2017 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_PCH_H_
-#define FLATBUFFERS_PCH_H_
-
-// stl
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-#include <iomanip>
-#include <limits>
-#include <list>
-#include <map>
-#include <memory>
-#include <stack>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-// flatbuffers
-#include "flatbuffers/util.h"
-
-#endif  // FLATBUFFERS_PCH_H_
diff --git a/external/flatbuffers/include/flatbuffers/reflection.h b/external/flatbuffers/include/flatbuffers/reflection.h
deleted file mode 100644
index bc8c2a92..00000000
--- a/external/flatbuffers/include/flatbuffers/reflection.h
+++ /dev/null
@@ -1,530 +0,0 @@
-/*
- * Copyright 2015 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_REFLECTION_H_
-#define FLATBUFFERS_REFLECTION_H_
-
-// This is somewhat of a circular dependency because flatc (and thus this
-// file) is needed to generate this header in the first place.
-// Should normally not be a problem since it can be generated by the
-// previous version of flatc whenever this code needs to change.
-// See scripts/generate_code.py for generation.
-#include "flatbuffers/reflection_generated.h"
-
-// Helper functionality for reflection.
-
-namespace flatbuffers {
-
-// ------------------------- GETTERS -------------------------
-
-constexpr bool IsScalar(reflection::BaseType t) {
-  return t >= reflection::UType && t <= reflection::Double;
-}
-constexpr bool IsInteger(reflection::BaseType t) {
-  return t >= reflection::UType && t <= reflection::ULong;
-}
-constexpr bool IsFloat(reflection::BaseType t) {
-  return t == reflection::Float || t == reflection::Double;
-}
-constexpr bool IsLong(reflection::BaseType t) {
-  return t == reflection::Long || t == reflection::ULong;
-}
-
-// This needs to correspond to the BaseType enum.
-constexpr size_t kBaseTypeSize[] = {
-    0,  // None
-    1,  // UType
-    1,  // Bool
-    1,  // Byte
-    1,  // UByte
-    2,  // Short
-    2,  // UShort
-    4,  // Int
-    4,  // UInt
-    8,  // Long
-    8,  // ULong
-    4,  // Float
-    8,  // Double
-    4,  // String
-    4,  // Vector
-    4,  // Obj
-    4,  // Union
-    0,  // Array. Only used in structs. 0 was chosen to prevent out-of-bounds
-        // errors.
-    8,  // Vector64
-
-    0  // MaxBaseType. This must be kept the last entry in this array.
-};
-static_assert(sizeof(kBaseTypeSize) / sizeof(size_t) ==
-                  reflection::MaxBaseType + 1,
-              "Size of sizes[] array does not match the count of BaseType "
-              "enum values.");
-
-// Size of a basic type, don't use with structs.
-constexpr size_t GetTypeSize(reflection::BaseType base_type) {
-  return kBaseTypeSize[base_type];
-}
-
-// Same as above, but now correctly returns the size of a struct if
-// the field (or vector element) is a struct.
-inline size_t GetTypeSizeInline(reflection::BaseType base_type, int type_index,
-                                const reflection::Schema& schema) {
-  if (base_type == reflection::Obj &&
-      schema.objects()->Get(type_index)->is_struct()) {
-    return schema.objects()->Get(type_index)->bytesize();
-  } else {
-    return GetTypeSize(base_type);
-  }
-}
-
-// Get the root, regardless of what type it is.
-inline Table* GetAnyRoot(uint8_t* const flatbuf) {
-  return GetMutableRoot<Table>(flatbuf);
-}
-
-inline const Table* GetAnyRoot(const uint8_t* const flatbuf) {
-  return GetRoot<Table>(flatbuf);
-}
-
-inline Table* GetAnySizePrefixedRoot(uint8_t* const flatbuf) {
-  return GetMutableSizePrefixedRoot<Table>(flatbuf);
-}
-
-inline const Table* GetAnySizePrefixedRoot(const uint8_t* const flatbuf) {
-  return GetSizePrefixedRoot<Table>(flatbuf);
-}
-
-// Get a field's default, if you know it's an integer, and its exact type.
-template <typename T>
-T GetFieldDefaultI(const reflection::Field& field) {
-  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
-  return static_cast<T>(field.default_integer());
-}
-
-// Get a field's default, if you know it's floating point and its exact type.
-template <typename T>
-T GetFieldDefaultF(const reflection::Field& field) {
-  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
-  return static_cast<T>(field.default_real());
-}
-
-// Get a field, if you know it's an integer, and its exact type.
-template <typename T>
-T GetFieldI(const Table& table, const reflection::Field& field) {
-  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
-  return table.GetField<T>(field.offset(),
-                           static_cast<T>(field.default_integer()));
-}
-
-// Get a field, if you know it's floating point and its exact type.
-template <typename T>
-T GetFieldF(const Table& table, const reflection::Field& field) {
-  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
-  return table.GetField<T>(field.offset(),
-                           static_cast<T>(field.default_real()));
-}
-
-// Get a field, if you know it's a string.
-inline const String* GetFieldS(const Table& table,
-                               const reflection::Field& field) {
-  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::String);
-  return table.GetPointer<const String*>(field.offset());
-}
-
-// Get a field, if you know it's a vector.
-template <typename T>
-Vector<T>* GetFieldV(const Table& table, const reflection::Field& field) {
-  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Vector &&
-                     sizeof(T) == GetTypeSize(field.type()->element()));
-  return table.GetPointer<Vector<T>*>(field.offset());
-}
-
-// Get a field, if you know it's a vector, generically.
-// To actually access elements, use the return value together with
-// field.type()->element() in any of GetAnyVectorElemI below etc.
-inline VectorOfAny* GetFieldAnyV(const Table& table,
-                                 const reflection::Field& field) {
-  return table.GetPointer<VectorOfAny*>(field.offset());
-}
-
-// Get a field, if you know it's a table.
-inline Table* GetFieldT(const Table& table, const reflection::Field& field) {
-  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj ||
-                     field.type()->base_type() == reflection::Union);
-  return table.GetPointer<Table*>(field.offset());
-}
-
-// Get a field, if you know it's a struct.
-inline const Struct* GetFieldStruct(const Table& table,
-                                    const reflection::Field& field) {
-  // TODO: This does NOT check if the field is a table or struct, but we'd need
-  // access to the schema to check the is_struct flag.
-  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj);
-  return table.GetStruct<const Struct*>(field.offset());
-}
-
-// Get a structure's field, if you know it's a struct.
-inline const Struct* GetFieldStruct(const Struct& structure,
-                                    const reflection::Field& field) {
-  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj);
-  return structure.GetStruct<const Struct*>(field.offset());
-}
-
-// Raw helper functions used below: get any value in memory as a 64bit int, a
-// double or a string.
-// All scalars get static_cast to an int64_t, strings use strtoull, every other
-// data type returns 0.
-int64_t GetAnyValueI(reflection::BaseType type, const uint8_t* data);
-// All scalars static cast to double, strings use strtod, every other data
-// type is 0.0.
-double GetAnyValueF(reflection::BaseType type, const uint8_t* data);
-// All scalars converted using stringstream, strings as-is, and all other
-// data types provide some level of debug-pretty-printing.
-std::string GetAnyValueS(reflection::BaseType type, const uint8_t* data,
-                         const reflection::Schema* schema, int type_index);
-
-// Get any table field as a 64bit int, regardless of what type it is.
-inline int64_t GetAnyFieldI(const Table& table,
-                            const reflection::Field& field) {
-  auto field_ptr = table.GetAddressOf(field.offset());
-  return field_ptr ? GetAnyValueI(field.type()->base_type(), field_ptr)
-                   : field.default_integer();
-}
-
-// Get any table field as a double, regardless of what type it is.
-inline double GetAnyFieldF(const Table& table, const reflection::Field& field) {
-  auto field_ptr = table.GetAddressOf(field.offset());
-  return field_ptr ? GetAnyValueF(field.type()->base_type(), field_ptr)
-                   : field.default_real();
-}
-
-// Get any table field as a string, regardless of what type it is.
-// You may pass nullptr for the schema if you don't care to have fields that
-// are of table type pretty-printed.
-inline std::string GetAnyFieldS(const Table& table,
-                                const reflection::Field& field,
-                                const reflection::Schema* schema) {
-  auto field_ptr = table.GetAddressOf(field.offset());
-  return field_ptr ? GetAnyValueS(field.type()->base_type(), field_ptr, schema,
-                                  field.type()->index())
-                   : "";
-}
-
-// Get any struct field as a 64bit int, regardless of what type it is.
-inline int64_t GetAnyFieldI(const Struct& st, const reflection::Field& field) {
-  return GetAnyValueI(field.type()->base_type(),
-                      st.GetAddressOf(field.offset()));
-}
-
-// Get any struct field as a double, regardless of what type it is.
-inline double GetAnyFieldF(const Struct& st, const reflection::Field& field) {
-  return GetAnyValueF(field.type()->base_type(),
-                      st.GetAddressOf(field.offset()));
-}
-
-// Get any struct field as a string, regardless of what type it is.
-inline std::string GetAnyFieldS(const Struct& st,
-                                const reflection::Field& field) {
-  return GetAnyValueS(field.type()->base_type(),
-                      st.GetAddressOf(field.offset()), nullptr, -1);
-}
-
-// Get any vector element as a 64bit int, regardless of what type it is.
-inline int64_t GetAnyVectorElemI(const VectorOfAny* vec,
-                                 reflection::BaseType elem_type, size_t i) {
-  return GetAnyValueI(elem_type, vec->Data() + GetTypeSize(elem_type) * i);
-}
-
-// Get any vector element as a double, regardless of what type it is.
-inline double GetAnyVectorElemF(const VectorOfAny* vec,
-                                reflection::BaseType elem_type, size_t i) {
-  return GetAnyValueF(elem_type, vec->Data() + GetTypeSize(elem_type) * i);
-}
-
-// Get any vector element as a string, regardless of what type it is.
-inline std::string GetAnyVectorElemS(const VectorOfAny* vec,
-                                     reflection::BaseType elem_type, size_t i) {
-  return GetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i,
-                      nullptr, -1);
-}
-
-// Get a vector element that's a table/string/vector from a generic vector.
-// Pass Table/String/VectorOfAny as template parameter.
-// Warning: does no typechecking.
-template <typename T>
-T* GetAnyVectorElemPointer(const VectorOfAny* vec, size_t i) {
-  auto elem_ptr = vec->Data() + sizeof(uoffset_t) * i;
-  return reinterpret_cast<T*>(elem_ptr + ReadScalar<uoffset_t>(elem_ptr));
-}
-
-// Get the inline-address of a vector element. Useful for Structs (pass Struct
-// as template arg), or being able to address a range of scalars in-line.
-// Get elem_size from GetTypeSizeInline().
-// Note: little-endian data on all platforms, use EndianScalar() instead of
-// raw pointer access with scalars).
-template <typename T>
-T* GetAnyVectorElemAddressOf(const VectorOfAny* vec, size_t i,
-                             size_t elem_size) {
-  return reinterpret_cast<T*>(vec->Data() + elem_size * i);
-}
-
-// Similarly, for elements of tables.
-template <typename T>
-T* GetAnyFieldAddressOf(const Table& table, const reflection::Field& field) {
-  return reinterpret_cast<T*>(table.GetAddressOf(field.offset()));
-}
-
-// Similarly, for elements of structs.
-template <typename T>
-T* GetAnyFieldAddressOf(const Struct& st, const reflection::Field& field) {
-  return reinterpret_cast<T*>(st.GetAddressOf(field.offset()));
-}
-
-// Loop over all the fields of the provided `object` and call `func` on each one
-// in increasing order by their field->id(). If `reverse` is true, `func` is
-// called in descending order
-void ForAllFields(const reflection::Object* object, bool reverse,
-                  std::function<void(const reflection::Field*)> func);
-
-// ------------------------- SETTERS -------------------------
-
-// Set any scalar field, if you know its exact type.
-template <typename T>
-bool SetField(Table* table, const reflection::Field& field, T val) {
-  reflection::BaseType type = field.type()->base_type();
-  if (!IsScalar(type)) {
-    return false;
-  }
-  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(type));
-  T def;
-  if (IsInteger(type)) {
-    def = GetFieldDefaultI<T>(field);
-  } else {
-    FLATBUFFERS_ASSERT(IsFloat(type));
-    def = GetFieldDefaultF<T>(field);
-  }
-  return table->SetField(field.offset(), val, def);
-}
-
-// Raw helper functions used below: set any value in memory as a 64bit int, a
-// double or a string.
-// These work for all scalar values, but do nothing for other data types.
-// To set a string, see SetString below.
-void SetAnyValueI(reflection::BaseType type, uint8_t* data, int64_t val);
-void SetAnyValueF(reflection::BaseType type, uint8_t* data, double val);
-void SetAnyValueS(reflection::BaseType type, uint8_t* data, const char* val);
-
-// Set any table field as a 64bit int, regardless of type what it is.
-inline bool SetAnyFieldI(Table* table, const reflection::Field& field,
-                         int64_t val) {
-  auto field_ptr = table->GetAddressOf(field.offset());
-  if (!field_ptr) return val == GetFieldDefaultI<int64_t>(field);
-  SetAnyValueI(field.type()->base_type(), field_ptr, val);
-  return true;
-}
-
-// Set any table field as a double, regardless of what type it is.
-inline bool SetAnyFieldF(Table* table, const reflection::Field& field,
-                         double val) {
-  auto field_ptr = table->GetAddressOf(field.offset());
-  if (!field_ptr) return val == GetFieldDefaultF<double>(field);
-  SetAnyValueF(field.type()->base_type(), field_ptr, val);
-  return true;
-}
-
-// Set any table field as a string, regardless of what type it is.
-inline bool SetAnyFieldS(Table* table, const reflection::Field& field,
-                         const char* val) {
-  auto field_ptr = table->GetAddressOf(field.offset());
-  if (!field_ptr) return false;
-  SetAnyValueS(field.type()->base_type(), field_ptr, val);
-  return true;
-}
-
-// Set any struct field as a 64bit int, regardless of type what it is.
-inline void SetAnyFieldI(Struct* st, const reflection::Field& field,
-                         int64_t val) {
-  SetAnyValueI(field.type()->base_type(), st->GetAddressOf(field.offset()),
-               val);
-}
-
-// Set any struct field as a double, regardless of type what it is.
-inline void SetAnyFieldF(Struct* st, const reflection::Field& field,
-                         double val) {
-  SetAnyValueF(field.type()->base_type(), st->GetAddressOf(field.offset()),
-               val);
-}
-
-// Set any struct field as a string, regardless of type what it is.
-inline void SetAnyFieldS(Struct* st, const reflection::Field& field,
-                         const char* val) {
-  SetAnyValueS(field.type()->base_type(), st->GetAddressOf(field.offset()),
-               val);
-}
-
-// Set any vector element as a 64bit int, regardless of type what it is.
-inline void SetAnyVectorElemI(VectorOfAny* vec, reflection::BaseType elem_type,
-                              size_t i, int64_t val) {
-  SetAnyValueI(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
-}
-
-// Set any vector element as a double, regardless of type what it is.
-inline void SetAnyVectorElemF(VectorOfAny* vec, reflection::BaseType elem_type,
-                              size_t i, double val) {
-  SetAnyValueF(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
-}
-
-// Set any vector element as a string, regardless of type what it is.
-inline void SetAnyVectorElemS(VectorOfAny* vec, reflection::BaseType elem_type,
-                              size_t i, const char* val) {
-  SetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
-}
-
-// ------------------------- RESIZING SETTERS -------------------------
-
-// "smart" pointer for use with resizing vectors: turns a pointer inside
-// a vector into a relative offset, such that it is not affected by resizes.
-template <typename T, typename U>
-class pointer_inside_vector {
- public:
-  pointer_inside_vector(T* ptr, std::vector<U>& vec)
-      : offset_(reinterpret_cast<uint8_t*>(ptr) -
-                reinterpret_cast<uint8_t*>(vec.data())),
-        vec_(vec) {}
-
-  T* operator*() const {
-    return reinterpret_cast<T*>(reinterpret_cast<uint8_t*>(vec_.data()) +
-                                offset_);
-  }
-  T* operator->() const { return operator*(); }
-
- private:
-  size_t offset_;
-  std::vector<U>& vec_;
-};
-
-// Helper to create the above easily without specifying template args.
-template <typename T, typename U>
-pointer_inside_vector<T, U> piv(T* ptr, std::vector<U>& vec) {
-  return pointer_inside_vector<T, U>(ptr, vec);
-}
-
-constexpr const char* UnionTypeFieldSuffix() { return "_type"; }
-
-// Helper to figure out the actual table type a union refers to.
-inline const reflection::Object& GetUnionType(
-    const reflection::Schema& schema, const reflection::Object& parent,
-    const reflection::Field& unionfield, const Table& table) {
-  auto enumdef = schema.enums()->Get(unionfield.type()->index());
-  // TODO: this is clumsy and slow, but no other way to find it?
-  auto type_field = parent.fields()->LookupByKey(
-      (unionfield.name()->str() + UnionTypeFieldSuffix()).c_str());
-  FLATBUFFERS_ASSERT(type_field);
-  auto union_type = GetFieldI<uint8_t>(table, *type_field);
-  auto enumval = enumdef->values()->LookupByKey(union_type);
-  return *schema.objects()->Get(enumval->union_type()->index());
-}
-
-// Changes the contents of a string inside a FlatBuffer. FlatBuffer must
-// live inside a std::vector so we can resize the buffer if needed.
-// "str" must live inside "flatbuf" and may be invalidated after this call.
-// If your FlatBuffer's root table is not the schema's root table, you should
-// pass in your root_table type as well.
-void SetString(const reflection::Schema& schema, const std::string& val,
-               const String* str, std::vector<uint8_t>* flatbuf,
-               const reflection::Object* root_table = nullptr);
-
-// Resizes a flatbuffers::Vector inside a FlatBuffer. FlatBuffer must
-// live inside a std::vector so we can resize the buffer if needed.
-// "vec" must live inside "flatbuf" and may be invalidated after this call.
-// If your FlatBuffer's root table is not the schema's root table, you should
-// pass in your root_table type as well.
-uint8_t* ResizeAnyVector(const reflection::Schema& schema, uoffset_t newsize,
-                         const VectorOfAny* vec, uoffset_t num_elems,
-                         uoffset_t elem_size, std::vector<uint8_t>* flatbuf,
-                         const reflection::Object* root_table = nullptr);
-
-template <typename T>
-void ResizeVector(const reflection::Schema& schema, uoffset_t newsize, T val,
-                  const Vector<T>* vec, std::vector<uint8_t>* flatbuf,
-                  const reflection::Object* root_table = nullptr) {
-  auto delta_elem = static_cast<int>(newsize) - static_cast<int>(vec->size());
-  auto newelems = ResizeAnyVector(
-      schema, newsize, reinterpret_cast<const VectorOfAny*>(vec), vec->size(),
-      static_cast<uoffset_t>(sizeof(T)), flatbuf, root_table);
-  // Set new elements to "val".
-  for (int i = 0; i < delta_elem; i++) {
-    auto loc = newelems + i * sizeof(T);
-    auto is_scalar = flatbuffers::is_scalar<T>::value;
-    if (is_scalar) {
-      WriteScalar(loc, val);
-    } else {  // struct
-      *reinterpret_cast<T*>(loc) = val;
-    }
-  }
-}
-
-// Adds any new data (in the form of a new FlatBuffer) to an existing
-// FlatBuffer. This can be used when any of the above methods are not
-// sufficient, in particular for adding new tables and new fields.
-// This is potentially slightly less efficient than a FlatBuffer constructed
-// in one piece, since the new FlatBuffer doesn't share any vtables with the
-// existing one.
-// The return value can now be set using Vector::MutateOffset or SetFieldT
-// below.
-const uint8_t* AddFlatBuffer(std::vector<uint8_t>& flatbuf,
-                             const uint8_t* newbuf, size_t newlen);
-
-inline bool SetFieldT(Table* table, const reflection::Field& field,
-                      const uint8_t* val) {
-  FLATBUFFERS_ASSERT(sizeof(uoffset_t) ==
-                     GetTypeSize(field.type()->base_type()));
-  return table->SetPointer(field.offset(), val);
-}
-
-// ------------------------- COPYING -------------------------
-
-// Generic copying of tables from a FlatBuffer into a FlatBuffer builder.
-// Can be used to do any kind of merging/selecting you may want to do out
-// of existing buffers. Also useful to reconstruct a whole buffer if the
-// above resizing functionality has introduced garbage in a buffer you want
-// to remove.
-// Note: this does not deal with DAGs correctly. If the table passed forms a
-// DAG, the copy will be a tree instead (with duplicates). Strings can be
-// shared however, by passing true for use_string_pooling.
-
-Offset<const Table*> CopyTable(FlatBufferBuilder& fbb,
-                               const reflection::Schema& schema,
-                               const reflection::Object& objectdef,
-                               const Table& table,
-                               bool use_string_pooling = false);
-
-// Verifies the provided flatbuffer using reflection.
-// root should point to the root type for this flatbuffer.
-// buf should point to the start of flatbuffer data.
-// length specifies the size of the flatbuffer data.
-bool Verify(const reflection::Schema& schema, const reflection::Object& root,
-            const uint8_t* buf, size_t length, uoffset_t max_depth = 64,
-            uoffset_t max_tables = 1000000);
-
-bool VerifySizePrefixed(const reflection::Schema& schema,
-                        const reflection::Object& root, const uint8_t* buf,
-                        size_t length, uoffset_t max_depth = 64,
-                        uoffset_t max_tables = 1000000);
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_REFLECTION_H_
diff --git a/external/flatbuffers/include/flatbuffers/reflection_generated.h b/external/flatbuffers/include/flatbuffers/reflection_generated.h
deleted file mode 100644
index 32ee1aa6..00000000
--- a/external/flatbuffers/include/flatbuffers/reflection_generated.h
+++ /dev/null
@@ -1,1541 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
-#define FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
-              FLATBUFFERS_VERSION_MINOR == 12 &&
-              FLATBUFFERS_VERSION_REVISION == 19,
-             "Non-compatible flatbuffers version included");
-
-namespace reflection {
-
-struct Type;
-struct TypeBuilder;
-
-struct KeyValue;
-struct KeyValueBuilder;
-
-struct EnumVal;
-struct EnumValBuilder;
-
-struct Enum;
-struct EnumBuilder;
-
-struct Field;
-struct FieldBuilder;
-
-struct Object;
-struct ObjectBuilder;
-
-struct RPCCall;
-struct RPCCallBuilder;
-
-struct Service;
-struct ServiceBuilder;
-
-struct SchemaFile;
-struct SchemaFileBuilder;
-
-struct Schema;
-struct SchemaBuilder;
-
-enum BaseType {
-  None = 0,
-  UType = 1,
-  Bool = 2,
-  Byte = 3,
-  UByte = 4,
-  Short = 5,
-  UShort = 6,
-  Int = 7,
-  UInt = 8,
-  Long = 9,
-  ULong = 10,
-  Float = 11,
-  Double = 12,
-  String = 13,
-  Vector = 14,
-  Obj = 15,
-  Union = 16,
-  Array = 17,
-  Vector64 = 18,
-  MaxBaseType = 19
-};
-
-inline const BaseType (&EnumValuesBaseType())[20] {
-  static const BaseType values[] = {
-    None,
-    UType,
-    Bool,
-    Byte,
-    UByte,
-    Short,
-    UShort,
-    Int,
-    UInt,
-    Long,
-    ULong,
-    Float,
-    Double,
-    String,
-    Vector,
-    Obj,
-    Union,
-    Array,
-    Vector64,
-    MaxBaseType
-  };
-  return values;
-}
-
-inline const char * const *EnumNamesBaseType() {
-  static const char * const names[21] = {
-    "None",
-    "UType",
-    "Bool",
-    "Byte",
-    "UByte",
-    "Short",
-    "UShort",
-    "Int",
-    "UInt",
-    "Long",
-    "ULong",
-    "Float",
-    "Double",
-    "String",
-    "Vector",
-    "Obj",
-    "Union",
-    "Array",
-    "Vector64",
-    "MaxBaseType",
-    nullptr
-  };
-  return names;
-}
-
-inline const char *EnumNameBaseType(BaseType e) {
-  if (::flatbuffers::IsOutRange(e, None, MaxBaseType)) return "";
-  const size_t index = static_cast<size_t>(e);
-  return EnumNamesBaseType()[index];
-}
-
-/// New schema language features that are not supported by old code generators.
-enum AdvancedFeatures {
-  AdvancedArrayFeatures = 1ULL,
-  AdvancedUnionFeatures = 2ULL,
-  OptionalScalars = 4ULL,
-  DefaultVectorsAndStrings = 8ULL
-};
-
-inline const AdvancedFeatures (&EnumValuesAdvancedFeatures())[4] {
-  static const AdvancedFeatures values[] = {
-    AdvancedArrayFeatures,
-    AdvancedUnionFeatures,
-    OptionalScalars,
-    DefaultVectorsAndStrings
-  };
-  return values;
-}
-
-inline const char * const *EnumNamesAdvancedFeatures() {
-  static const char * const names[9] = {
-    "AdvancedArrayFeatures",
-    "AdvancedUnionFeatures",
-    "",
-    "OptionalScalars",
-    "",
-    "",
-    "",
-    "DefaultVectorsAndStrings",
-    nullptr
-  };
-  return names;
-}
-
-inline const char *EnumNameAdvancedFeatures(AdvancedFeatures e) {
-  if (::flatbuffers::IsOutRange(e, AdvancedArrayFeatures, DefaultVectorsAndStrings)) return "";
-  const size_t index = static_cast<size_t>(e) - static_cast<size_t>(AdvancedArrayFeatures);
-  return EnumNamesAdvancedFeatures()[index];
-}
-
-struct Type FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef TypeBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_BASE_TYPE = 4,
-    VT_ELEMENT = 6,
-    VT_INDEX = 8,
-    VT_FIXED_LENGTH = 10,
-    VT_BASE_SIZE = 12,
-    VT_ELEMENT_SIZE = 14
-  };
-  reflection::BaseType base_type() const {
-    return static_cast<reflection::BaseType>(GetField<int8_t>(VT_BASE_TYPE, 0));
-  }
-  reflection::BaseType element() const {
-    return static_cast<reflection::BaseType>(GetField<int8_t>(VT_ELEMENT, 0));
-  }
-  int32_t index() const {
-    return GetField<int32_t>(VT_INDEX, -1);
-  }
-  uint16_t fixed_length() const {
-    return GetField<uint16_t>(VT_FIXED_LENGTH, 0);
-  }
-  /// The size (octets) of the `base_type` field.
-  uint32_t base_size() const {
-    return GetField<uint32_t>(VT_BASE_SIZE, 4);
-  }
-  /// The size (octets) of the `element` field, if present.
-  uint32_t element_size() const {
-    return GetField<uint32_t>(VT_ELEMENT_SIZE, 0);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyField<int8_t>(verifier, VT_BASE_TYPE, 1) &&
-           VerifyField<int8_t>(verifier, VT_ELEMENT, 1) &&
-           VerifyField<int32_t>(verifier, VT_INDEX, 4) &&
-           VerifyField<uint16_t>(verifier, VT_FIXED_LENGTH, 2) &&
-           VerifyField<uint32_t>(verifier, VT_BASE_SIZE, 4) &&
-           VerifyField<uint32_t>(verifier, VT_ELEMENT_SIZE, 4) &&
-           verifier.EndTable();
-  }
-};
-
-struct TypeBuilder {
-  typedef Type Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_base_type(reflection::BaseType base_type) {
-    fbb_.AddElement<int8_t>(Type::VT_BASE_TYPE, static_cast<int8_t>(base_type), 0);
-  }
-  void add_element(reflection::BaseType element) {
-    fbb_.AddElement<int8_t>(Type::VT_ELEMENT, static_cast<int8_t>(element), 0);
-  }
-  void add_index(int32_t index) {
-    fbb_.AddElement<int32_t>(Type::VT_INDEX, index, -1);
-  }
-  void add_fixed_length(uint16_t fixed_length) {
-    fbb_.AddElement<uint16_t>(Type::VT_FIXED_LENGTH, fixed_length, 0);
-  }
-  void add_base_size(uint32_t base_size) {
-    fbb_.AddElement<uint32_t>(Type::VT_BASE_SIZE, base_size, 4);
-  }
-  void add_element_size(uint32_t element_size) {
-    fbb_.AddElement<uint32_t>(Type::VT_ELEMENT_SIZE, element_size, 0);
-  }
-  explicit TypeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<Type> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<Type>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<Type> CreateType(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    reflection::BaseType base_type = reflection::None,
-    reflection::BaseType element = reflection::None,
-    int32_t index = -1,
-    uint16_t fixed_length = 0,
-    uint32_t base_size = 4,
-    uint32_t element_size = 0) {
-  TypeBuilder builder_(_fbb);
-  builder_.add_element_size(element_size);
-  builder_.add_base_size(base_size);
-  builder_.add_index(index);
-  builder_.add_fixed_length(fixed_length);
-  builder_.add_element(element);
-  builder_.add_base_type(base_type);
-  return builder_.Finish();
-}
-
-struct KeyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef KeyValueBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_KEY = 4,
-    VT_VALUE = 6
-  };
-  const ::flatbuffers::String *key() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_KEY);
-  }
-  bool KeyCompareLessThan(const KeyValue * const o) const {
-    return *key() < *o->key();
-  }
-  int KeyCompareWithValue(const char *_key) const {
-    return strcmp(key()->c_str(), _key);
-  }
-  template<typename StringType>
-  int KeyCompareWithValue(const StringType& _key) const {
-    if (key()->c_str() < _key) return -1;
-    if (_key < key()->c_str()) return 1;
-    return 0;
-  }
-  const ::flatbuffers::String *value() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffsetRequired(verifier, VT_KEY) &&
-           verifier.VerifyString(key()) &&
-           VerifyOffset(verifier, VT_VALUE) &&
-           verifier.VerifyString(value()) &&
-           verifier.EndTable();
-  }
-};
-
-struct KeyValueBuilder {
-  typedef KeyValue Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_key(::flatbuffers::Offset<::flatbuffers::String> key) {
-    fbb_.AddOffset(KeyValue::VT_KEY, key);
-  }
-  void add_value(::flatbuffers::Offset<::flatbuffers::String> value) {
-    fbb_.AddOffset(KeyValue::VT_VALUE, value);
-  }
-  explicit KeyValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<KeyValue> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<KeyValue>(end);
-    fbb_.Required(o, KeyValue::VT_KEY);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<KeyValue> CreateKeyValue(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> key = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> value = 0) {
-  KeyValueBuilder builder_(_fbb);
-  builder_.add_value(value);
-  builder_.add_key(key);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<KeyValue> CreateKeyValueDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *key = nullptr,
-    const char *value = nullptr) {
-  auto key__ = key ? _fbb.CreateString(key) : 0;
-  auto value__ = value ? _fbb.CreateString(value) : 0;
-  return reflection::CreateKeyValue(
-      _fbb,
-      key__,
-      value__);
-}
-
-struct EnumVal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef EnumValBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_NAME = 4,
-    VT_VALUE = 6,
-    VT_UNION_TYPE = 10,
-    VT_DOCUMENTATION = 12,
-    VT_ATTRIBUTES = 14
-  };
-  const ::flatbuffers::String *name() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
-  }
-  int64_t value() const {
-    return GetField<int64_t>(VT_VALUE, 0);
-  }
-  bool KeyCompareLessThan(const EnumVal * const o) const {
-    return value() < o->value();
-  }
-  int KeyCompareWithValue(int64_t _value) const {
-    return static_cast<int>(value() > _value) - static_cast<int>(value() < _value);
-  }
-  const reflection::Type *union_type() const {
-    return GetPointer<const reflection::Type *>(VT_UNION_TYPE);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffsetRequired(verifier, VT_NAME) &&
-           verifier.VerifyString(name()) &&
-           VerifyField<int64_t>(verifier, VT_VALUE, 8) &&
-           VerifyOffset(verifier, VT_UNION_TYPE) &&
-           verifier.VerifyTable(union_type()) &&
-           VerifyOffset(verifier, VT_DOCUMENTATION) &&
-           verifier.VerifyVector(documentation()) &&
-           verifier.VerifyVectorOfStrings(documentation()) &&
-           VerifyOffset(verifier, VT_ATTRIBUTES) &&
-           verifier.VerifyVector(attributes()) &&
-           verifier.VerifyVectorOfTables(attributes()) &&
-           verifier.EndTable();
-  }
-};
-
-struct EnumValBuilder {
-  typedef EnumVal Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
-    fbb_.AddOffset(EnumVal::VT_NAME, name);
-  }
-  void add_value(int64_t value) {
-    fbb_.AddElement<int64_t>(EnumVal::VT_VALUE, value, 0);
-  }
-  void add_union_type(::flatbuffers::Offset<reflection::Type> union_type) {
-    fbb_.AddOffset(EnumVal::VT_UNION_TYPE, union_type);
-  }
-  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
-    fbb_.AddOffset(EnumVal::VT_DOCUMENTATION, documentation);
-  }
-  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
-    fbb_.AddOffset(EnumVal::VT_ATTRIBUTES, attributes);
-  }
-  explicit EnumValBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<EnumVal> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<EnumVal>(end);
-    fbb_.Required(o, EnumVal::VT_NAME);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<EnumVal> CreateEnumVal(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
-    int64_t value = 0,
-    ::flatbuffers::Offset<reflection::Type> union_type = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0) {
-  EnumValBuilder builder_(_fbb);
-  builder_.add_value(value);
-  builder_.add_attributes(attributes);
-  builder_.add_documentation(documentation);
-  builder_.add_union_type(union_type);
-  builder_.add_name(name);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<EnumVal> CreateEnumValDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *name = nullptr,
-    int64_t value = 0,
-    ::flatbuffers::Offset<reflection::Type> union_type = 0,
-    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
-    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr) {
-  auto name__ = name ? _fbb.CreateString(name) : 0;
-  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
-  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
-  return reflection::CreateEnumVal(
-      _fbb,
-      name__,
-      value,
-      union_type,
-      documentation__,
-      attributes__);
-}
-
-struct Enum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef EnumBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_NAME = 4,
-    VT_VALUES = 6,
-    VT_IS_UNION = 8,
-    VT_UNDERLYING_TYPE = 10,
-    VT_ATTRIBUTES = 12,
-    VT_DOCUMENTATION = 14,
-    VT_DECLARATION_FILE = 16
-  };
-  const ::flatbuffers::String *name() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
-  }
-  bool KeyCompareLessThan(const Enum * const o) const {
-    return *name() < *o->name();
-  }
-  int KeyCompareWithValue(const char *_name) const {
-    return strcmp(name()->c_str(), _name);
-  }
-  template<typename StringType>
-  int KeyCompareWithValue(const StringType& _name) const {
-    if (name()->c_str() < _name) return -1;
-    if (_name < name()->c_str()) return 1;
-    return 0;
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>> *values() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>> *>(VT_VALUES);
-  }
-  bool is_union() const {
-    return GetField<uint8_t>(VT_IS_UNION, 0) != 0;
-  }
-  const reflection::Type *underlying_type() const {
-    return GetPointer<const reflection::Type *>(VT_UNDERLYING_TYPE);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
-  }
-  /// File that this Enum is declared in.
-  const ::flatbuffers::String *declaration_file() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffsetRequired(verifier, VT_NAME) &&
-           verifier.VerifyString(name()) &&
-           VerifyOffsetRequired(verifier, VT_VALUES) &&
-           verifier.VerifyVector(values()) &&
-           verifier.VerifyVectorOfTables(values()) &&
-           VerifyField<uint8_t>(verifier, VT_IS_UNION, 1) &&
-           VerifyOffsetRequired(verifier, VT_UNDERLYING_TYPE) &&
-           verifier.VerifyTable(underlying_type()) &&
-           VerifyOffset(verifier, VT_ATTRIBUTES) &&
-           verifier.VerifyVector(attributes()) &&
-           verifier.VerifyVectorOfTables(attributes()) &&
-           VerifyOffset(verifier, VT_DOCUMENTATION) &&
-           verifier.VerifyVector(documentation()) &&
-           verifier.VerifyVectorOfStrings(documentation()) &&
-           VerifyOffset(verifier, VT_DECLARATION_FILE) &&
-           verifier.VerifyString(declaration_file()) &&
-           verifier.EndTable();
-  }
-};
-
-struct EnumBuilder {
-  typedef Enum Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
-    fbb_.AddOffset(Enum::VT_NAME, name);
-  }
-  void add_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>>> values) {
-    fbb_.AddOffset(Enum::VT_VALUES, values);
-  }
-  void add_is_union(bool is_union) {
-    fbb_.AddElement<uint8_t>(Enum::VT_IS_UNION, static_cast<uint8_t>(is_union), 0);
-  }
-  void add_underlying_type(::flatbuffers::Offset<reflection::Type> underlying_type) {
-    fbb_.AddOffset(Enum::VT_UNDERLYING_TYPE, underlying_type);
-  }
-  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
-    fbb_.AddOffset(Enum::VT_ATTRIBUTES, attributes);
-  }
-  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
-    fbb_.AddOffset(Enum::VT_DOCUMENTATION, documentation);
-  }
-  void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
-    fbb_.AddOffset(Enum::VT_DECLARATION_FILE, declaration_file);
-  }
-  explicit EnumBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<Enum> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<Enum>(end);
-    fbb_.Required(o, Enum::VT_NAME);
-    fbb_.Required(o, Enum::VT_VALUES);
-    fbb_.Required(o, Enum::VT_UNDERLYING_TYPE);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<Enum> CreateEnum(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::EnumVal>>> values = 0,
-    bool is_union = false,
-    ::flatbuffers::Offset<reflection::Type> underlying_type = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
-  EnumBuilder builder_(_fbb);
-  builder_.add_declaration_file(declaration_file);
-  builder_.add_documentation(documentation);
-  builder_.add_attributes(attributes);
-  builder_.add_underlying_type(underlying_type);
-  builder_.add_values(values);
-  builder_.add_name(name);
-  builder_.add_is_union(is_union);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<Enum> CreateEnumDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *name = nullptr,
-    std::vector<::flatbuffers::Offset<reflection::EnumVal>> *values = nullptr,
-    bool is_union = false,
-    ::flatbuffers::Offset<reflection::Type> underlying_type = 0,
-    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
-    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
-    const char *declaration_file = nullptr) {
-  auto name__ = name ? _fbb.CreateString(name) : 0;
-  auto values__ = values ? _fbb.CreateVectorOfSortedTables<reflection::EnumVal>(values) : 0;
-  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
-  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
-  auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
-  return reflection::CreateEnum(
-      _fbb,
-      name__,
-      values__,
-      is_union,
-      underlying_type,
-      attributes__,
-      documentation__,
-      declaration_file__);
-}
-
-struct Field FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef FieldBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_NAME = 4,
-    VT_TYPE = 6,
-    VT_ID = 8,
-    VT_OFFSET = 10,
-    VT_DEFAULT_INTEGER = 12,
-    VT_DEFAULT_REAL = 14,
-    VT_DEPRECATED = 16,
-    VT_REQUIRED = 18,
-    VT_KEY = 20,
-    VT_ATTRIBUTES = 22,
-    VT_DOCUMENTATION = 24,
-    VT_OPTIONAL = 26,
-    VT_PADDING = 28,
-    VT_OFFSET64 = 30
-  };
-  const ::flatbuffers::String *name() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
-  }
-  bool KeyCompareLessThan(const Field * const o) const {
-    return *name() < *o->name();
-  }
-  int KeyCompareWithValue(const char *_name) const {
-    return strcmp(name()->c_str(), _name);
-  }
-  template<typename StringType>
-  int KeyCompareWithValue(const StringType& _name) const {
-    if (name()->c_str() < _name) return -1;
-    if (_name < name()->c_str()) return 1;
-    return 0;
-  }
-  const reflection::Type *type() const {
-    return GetPointer<const reflection::Type *>(VT_TYPE);
-  }
-  uint16_t id() const {
-    return GetField<uint16_t>(VT_ID, 0);
-  }
-  uint16_t offset() const {
-    return GetField<uint16_t>(VT_OFFSET, 0);
-  }
-  int64_t default_integer() const {
-    return GetField<int64_t>(VT_DEFAULT_INTEGER, 0);
-  }
-  double default_real() const {
-    return GetField<double>(VT_DEFAULT_REAL, 0.0);
-  }
-  bool deprecated() const {
-    return GetField<uint8_t>(VT_DEPRECATED, 0) != 0;
-  }
-  bool required() const {
-    return GetField<uint8_t>(VT_REQUIRED, 0) != 0;
-  }
-  bool key() const {
-    return GetField<uint8_t>(VT_KEY, 0) != 0;
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
-  }
-  bool optional() const {
-    return GetField<uint8_t>(VT_OPTIONAL, 0) != 0;
-  }
-  /// Number of padding octets to always add after this field. Structs only.
-  uint16_t padding() const {
-    return GetField<uint16_t>(VT_PADDING, 0);
-  }
-  /// If the field uses 64-bit offsets.
-  bool offset64() const {
-    return GetField<uint8_t>(VT_OFFSET64, 0) != 0;
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffsetRequired(verifier, VT_NAME) &&
-           verifier.VerifyString(name()) &&
-           VerifyOffsetRequired(verifier, VT_TYPE) &&
-           verifier.VerifyTable(type()) &&
-           VerifyField<uint16_t>(verifier, VT_ID, 2) &&
-           VerifyField<uint16_t>(verifier, VT_OFFSET, 2) &&
-           VerifyField<int64_t>(verifier, VT_DEFAULT_INTEGER, 8) &&
-           VerifyField<double>(verifier, VT_DEFAULT_REAL, 8) &&
-           VerifyField<uint8_t>(verifier, VT_DEPRECATED, 1) &&
-           VerifyField<uint8_t>(verifier, VT_REQUIRED, 1) &&
-           VerifyField<uint8_t>(verifier, VT_KEY, 1) &&
-           VerifyOffset(verifier, VT_ATTRIBUTES) &&
-           verifier.VerifyVector(attributes()) &&
-           verifier.VerifyVectorOfTables(attributes()) &&
-           VerifyOffset(verifier, VT_DOCUMENTATION) &&
-           verifier.VerifyVector(documentation()) &&
-           verifier.VerifyVectorOfStrings(documentation()) &&
-           VerifyField<uint8_t>(verifier, VT_OPTIONAL, 1) &&
-           VerifyField<uint16_t>(verifier, VT_PADDING, 2) &&
-           VerifyField<uint8_t>(verifier, VT_OFFSET64, 1) &&
-           verifier.EndTable();
-  }
-};
-
-struct FieldBuilder {
-  typedef Field Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
-    fbb_.AddOffset(Field::VT_NAME, name);
-  }
-  void add_type(::flatbuffers::Offset<reflection::Type> type) {
-    fbb_.AddOffset(Field::VT_TYPE, type);
-  }
-  void add_id(uint16_t id) {
-    fbb_.AddElement<uint16_t>(Field::VT_ID, id, 0);
-  }
-  void add_offset(uint16_t offset) {
-    fbb_.AddElement<uint16_t>(Field::VT_OFFSET, offset, 0);
-  }
-  void add_default_integer(int64_t default_integer) {
-    fbb_.AddElement<int64_t>(Field::VT_DEFAULT_INTEGER, default_integer, 0);
-  }
-  void add_default_real(double default_real) {
-    fbb_.AddElement<double>(Field::VT_DEFAULT_REAL, default_real, 0.0);
-  }
-  void add_deprecated(bool deprecated) {
-    fbb_.AddElement<uint8_t>(Field::VT_DEPRECATED, static_cast<uint8_t>(deprecated), 0);
-  }
-  void add_required(bool required) {
-    fbb_.AddElement<uint8_t>(Field::VT_REQUIRED, static_cast<uint8_t>(required), 0);
-  }
-  void add_key(bool key) {
-    fbb_.AddElement<uint8_t>(Field::VT_KEY, static_cast<uint8_t>(key), 0);
-  }
-  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
-    fbb_.AddOffset(Field::VT_ATTRIBUTES, attributes);
-  }
-  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
-    fbb_.AddOffset(Field::VT_DOCUMENTATION, documentation);
-  }
-  void add_optional(bool optional) {
-    fbb_.AddElement<uint8_t>(Field::VT_OPTIONAL, static_cast<uint8_t>(optional), 0);
-  }
-  void add_padding(uint16_t padding) {
-    fbb_.AddElement<uint16_t>(Field::VT_PADDING, padding, 0);
-  }
-  void add_offset64(bool offset64) {
-    fbb_.AddElement<uint8_t>(Field::VT_OFFSET64, static_cast<uint8_t>(offset64), 0);
-  }
-  explicit FieldBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<Field> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<Field>(end);
-    fbb_.Required(o, Field::VT_NAME);
-    fbb_.Required(o, Field::VT_TYPE);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<Field> CreateField(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
-    ::flatbuffers::Offset<reflection::Type> type = 0,
-    uint16_t id = 0,
-    uint16_t offset = 0,
-    int64_t default_integer = 0,
-    double default_real = 0.0,
-    bool deprecated = false,
-    bool required = false,
-    bool key = false,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
-    bool optional = false,
-    uint16_t padding = 0,
-    bool offset64 = false) {
-  FieldBuilder builder_(_fbb);
-  builder_.add_default_real(default_real);
-  builder_.add_default_integer(default_integer);
-  builder_.add_documentation(documentation);
-  builder_.add_attributes(attributes);
-  builder_.add_type(type);
-  builder_.add_name(name);
-  builder_.add_padding(padding);
-  builder_.add_offset(offset);
-  builder_.add_id(id);
-  builder_.add_offset64(offset64);
-  builder_.add_optional(optional);
-  builder_.add_key(key);
-  builder_.add_required(required);
-  builder_.add_deprecated(deprecated);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<Field> CreateFieldDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *name = nullptr,
-    ::flatbuffers::Offset<reflection::Type> type = 0,
-    uint16_t id = 0,
-    uint16_t offset = 0,
-    int64_t default_integer = 0,
-    double default_real = 0.0,
-    bool deprecated = false,
-    bool required = false,
-    bool key = false,
-    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
-    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
-    bool optional = false,
-    uint16_t padding = 0,
-    bool offset64 = false) {
-  auto name__ = name ? _fbb.CreateString(name) : 0;
-  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
-  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
-  return reflection::CreateField(
-      _fbb,
-      name__,
-      type,
-      id,
-      offset,
-      default_integer,
-      default_real,
-      deprecated,
-      required,
-      key,
-      attributes__,
-      documentation__,
-      optional,
-      padding,
-      offset64);
-}
-
-struct Object FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef ObjectBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_NAME = 4,
-    VT_FIELDS = 6,
-    VT_IS_STRUCT = 8,
-    VT_MINALIGN = 10,
-    VT_BYTESIZE = 12,
-    VT_ATTRIBUTES = 14,
-    VT_DOCUMENTATION = 16,
-    VT_DECLARATION_FILE = 18
-  };
-  const ::flatbuffers::String *name() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
-  }
-  bool KeyCompareLessThan(const Object * const o) const {
-    return *name() < *o->name();
-  }
-  int KeyCompareWithValue(const char *_name) const {
-    return strcmp(name()->c_str(), _name);
-  }
-  template<typename StringType>
-  int KeyCompareWithValue(const StringType& _name) const {
-    if (name()->c_str() < _name) return -1;
-    if (_name < name()->c_str()) return 1;
-    return 0;
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>> *fields() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>> *>(VT_FIELDS);
-  }
-  bool is_struct() const {
-    return GetField<uint8_t>(VT_IS_STRUCT, 0) != 0;
-  }
-  int32_t minalign() const {
-    return GetField<int32_t>(VT_MINALIGN, 0);
-  }
-  int32_t bytesize() const {
-    return GetField<int32_t>(VT_BYTESIZE, 0);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
-  }
-  /// File that this Object is declared in.
-  const ::flatbuffers::String *declaration_file() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffsetRequired(verifier, VT_NAME) &&
-           verifier.VerifyString(name()) &&
-           VerifyOffsetRequired(verifier, VT_FIELDS) &&
-           verifier.VerifyVector(fields()) &&
-           verifier.VerifyVectorOfTables(fields()) &&
-           VerifyField<uint8_t>(verifier, VT_IS_STRUCT, 1) &&
-           VerifyField<int32_t>(verifier, VT_MINALIGN, 4) &&
-           VerifyField<int32_t>(verifier, VT_BYTESIZE, 4) &&
-           VerifyOffset(verifier, VT_ATTRIBUTES) &&
-           verifier.VerifyVector(attributes()) &&
-           verifier.VerifyVectorOfTables(attributes()) &&
-           VerifyOffset(verifier, VT_DOCUMENTATION) &&
-           verifier.VerifyVector(documentation()) &&
-           verifier.VerifyVectorOfStrings(documentation()) &&
-           VerifyOffset(verifier, VT_DECLARATION_FILE) &&
-           verifier.VerifyString(declaration_file()) &&
-           verifier.EndTable();
-  }
-};
-
-struct ObjectBuilder {
-  typedef Object Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
-    fbb_.AddOffset(Object::VT_NAME, name);
-  }
-  void add_fields(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>>> fields) {
-    fbb_.AddOffset(Object::VT_FIELDS, fields);
-  }
-  void add_is_struct(bool is_struct) {
-    fbb_.AddElement<uint8_t>(Object::VT_IS_STRUCT, static_cast<uint8_t>(is_struct), 0);
-  }
-  void add_minalign(int32_t minalign) {
-    fbb_.AddElement<int32_t>(Object::VT_MINALIGN, minalign, 0);
-  }
-  void add_bytesize(int32_t bytesize) {
-    fbb_.AddElement<int32_t>(Object::VT_BYTESIZE, bytesize, 0);
-  }
-  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
-    fbb_.AddOffset(Object::VT_ATTRIBUTES, attributes);
-  }
-  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
-    fbb_.AddOffset(Object::VT_DOCUMENTATION, documentation);
-  }
-  void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
-    fbb_.AddOffset(Object::VT_DECLARATION_FILE, declaration_file);
-  }
-  explicit ObjectBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<Object> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<Object>(end);
-    fbb_.Required(o, Object::VT_NAME);
-    fbb_.Required(o, Object::VT_FIELDS);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<Object> CreateObject(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Field>>> fields = 0,
-    bool is_struct = false,
-    int32_t minalign = 0,
-    int32_t bytesize = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
-  ObjectBuilder builder_(_fbb);
-  builder_.add_declaration_file(declaration_file);
-  builder_.add_documentation(documentation);
-  builder_.add_attributes(attributes);
-  builder_.add_bytesize(bytesize);
-  builder_.add_minalign(minalign);
-  builder_.add_fields(fields);
-  builder_.add_name(name);
-  builder_.add_is_struct(is_struct);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<Object> CreateObjectDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *name = nullptr,
-    std::vector<::flatbuffers::Offset<reflection::Field>> *fields = nullptr,
-    bool is_struct = false,
-    int32_t minalign = 0,
-    int32_t bytesize = 0,
-    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
-    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
-    const char *declaration_file = nullptr) {
-  auto name__ = name ? _fbb.CreateString(name) : 0;
-  auto fields__ = fields ? _fbb.CreateVectorOfSortedTables<reflection::Field>(fields) : 0;
-  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
-  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
-  auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
-  return reflection::CreateObject(
-      _fbb,
-      name__,
-      fields__,
-      is_struct,
-      minalign,
-      bytesize,
-      attributes__,
-      documentation__,
-      declaration_file__);
-}
-
-struct RPCCall FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef RPCCallBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_NAME = 4,
-    VT_REQUEST = 6,
-    VT_RESPONSE = 8,
-    VT_ATTRIBUTES = 10,
-    VT_DOCUMENTATION = 12
-  };
-  const ::flatbuffers::String *name() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
-  }
-  bool KeyCompareLessThan(const RPCCall * const o) const {
-    return *name() < *o->name();
-  }
-  int KeyCompareWithValue(const char *_name) const {
-    return strcmp(name()->c_str(), _name);
-  }
-  template<typename StringType>
-  int KeyCompareWithValue(const StringType& _name) const {
-    if (name()->c_str() < _name) return -1;
-    if (_name < name()->c_str()) return 1;
-    return 0;
-  }
-  const reflection::Object *request() const {
-    return GetPointer<const reflection::Object *>(VT_REQUEST);
-  }
-  const reflection::Object *response() const {
-    return GetPointer<const reflection::Object *>(VT_RESPONSE);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffsetRequired(verifier, VT_NAME) &&
-           verifier.VerifyString(name()) &&
-           VerifyOffsetRequired(verifier, VT_REQUEST) &&
-           verifier.VerifyTable(request()) &&
-           VerifyOffsetRequired(verifier, VT_RESPONSE) &&
-           verifier.VerifyTable(response()) &&
-           VerifyOffset(verifier, VT_ATTRIBUTES) &&
-           verifier.VerifyVector(attributes()) &&
-           verifier.VerifyVectorOfTables(attributes()) &&
-           VerifyOffset(verifier, VT_DOCUMENTATION) &&
-           verifier.VerifyVector(documentation()) &&
-           verifier.VerifyVectorOfStrings(documentation()) &&
-           verifier.EndTable();
-  }
-};
-
-struct RPCCallBuilder {
-  typedef RPCCall Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
-    fbb_.AddOffset(RPCCall::VT_NAME, name);
-  }
-  void add_request(::flatbuffers::Offset<reflection::Object> request) {
-    fbb_.AddOffset(RPCCall::VT_REQUEST, request);
-  }
-  void add_response(::flatbuffers::Offset<reflection::Object> response) {
-    fbb_.AddOffset(RPCCall::VT_RESPONSE, response);
-  }
-  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
-    fbb_.AddOffset(RPCCall::VT_ATTRIBUTES, attributes);
-  }
-  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
-    fbb_.AddOffset(RPCCall::VT_DOCUMENTATION, documentation);
-  }
-  explicit RPCCallBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<RPCCall> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<RPCCall>(end);
-    fbb_.Required(o, RPCCall::VT_NAME);
-    fbb_.Required(o, RPCCall::VT_REQUEST);
-    fbb_.Required(o, RPCCall::VT_RESPONSE);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<RPCCall> CreateRPCCall(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
-    ::flatbuffers::Offset<reflection::Object> request = 0,
-    ::flatbuffers::Offset<reflection::Object> response = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0) {
-  RPCCallBuilder builder_(_fbb);
-  builder_.add_documentation(documentation);
-  builder_.add_attributes(attributes);
-  builder_.add_response(response);
-  builder_.add_request(request);
-  builder_.add_name(name);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<RPCCall> CreateRPCCallDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *name = nullptr,
-    ::flatbuffers::Offset<reflection::Object> request = 0,
-    ::flatbuffers::Offset<reflection::Object> response = 0,
-    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
-    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr) {
-  auto name__ = name ? _fbb.CreateString(name) : 0;
-  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
-  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
-  return reflection::CreateRPCCall(
-      _fbb,
-      name__,
-      request,
-      response,
-      attributes__,
-      documentation__);
-}
-
-struct Service FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef ServiceBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_NAME = 4,
-    VT_CALLS = 6,
-    VT_ATTRIBUTES = 8,
-    VT_DOCUMENTATION = 10,
-    VT_DECLARATION_FILE = 12
-  };
-  const ::flatbuffers::String *name() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
-  }
-  bool KeyCompareLessThan(const Service * const o) const {
-    return *name() < *o->name();
-  }
-  int KeyCompareWithValue(const char *_name) const {
-    return strcmp(name()->c_str(), _name);
-  }
-  template<typename StringType>
-  int KeyCompareWithValue(const StringType& _name) const {
-    if (name()->c_str() < _name) return -1;
-    if (_name < name()->c_str()) return 1;
-    return 0;
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>> *calls() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>> *>(VT_CALLS);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
-  }
-  /// File that this Service is declared in.
-  const ::flatbuffers::String *declaration_file() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffsetRequired(verifier, VT_NAME) &&
-           verifier.VerifyString(name()) &&
-           VerifyOffset(verifier, VT_CALLS) &&
-           verifier.VerifyVector(calls()) &&
-           verifier.VerifyVectorOfTables(calls()) &&
-           VerifyOffset(verifier, VT_ATTRIBUTES) &&
-           verifier.VerifyVector(attributes()) &&
-           verifier.VerifyVectorOfTables(attributes()) &&
-           VerifyOffset(verifier, VT_DOCUMENTATION) &&
-           verifier.VerifyVector(documentation()) &&
-           verifier.VerifyVectorOfStrings(documentation()) &&
-           VerifyOffset(verifier, VT_DECLARATION_FILE) &&
-           verifier.VerifyString(declaration_file()) &&
-           verifier.EndTable();
-  }
-};
-
-struct ServiceBuilder {
-  typedef Service Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
-    fbb_.AddOffset(Service::VT_NAME, name);
-  }
-  void add_calls(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>>> calls) {
-    fbb_.AddOffset(Service::VT_CALLS, calls);
-  }
-  void add_attributes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes) {
-    fbb_.AddOffset(Service::VT_ATTRIBUTES, attributes);
-  }
-  void add_documentation(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation) {
-    fbb_.AddOffset(Service::VT_DOCUMENTATION, documentation);
-  }
-  void add_declaration_file(::flatbuffers::Offset<::flatbuffers::String> declaration_file) {
-    fbb_.AddOffset(Service::VT_DECLARATION_FILE, declaration_file);
-  }
-  explicit ServiceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<Service> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<Service>(end);
-    fbb_.Required(o, Service::VT_NAME);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<Service> CreateService(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::RPCCall>>> calls = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>>> attributes = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> documentation = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> declaration_file = 0) {
-  ServiceBuilder builder_(_fbb);
-  builder_.add_declaration_file(declaration_file);
-  builder_.add_documentation(documentation);
-  builder_.add_attributes(attributes);
-  builder_.add_calls(calls);
-  builder_.add_name(name);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<Service> CreateServiceDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *name = nullptr,
-    std::vector<::flatbuffers::Offset<reflection::RPCCall>> *calls = nullptr,
-    std::vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes = nullptr,
-    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation = nullptr,
-    const char *declaration_file = nullptr) {
-  auto name__ = name ? _fbb.CreateString(name) : 0;
-  auto calls__ = calls ? _fbb.CreateVectorOfSortedTables<reflection::RPCCall>(calls) : 0;
-  auto attributes__ = attributes ? _fbb.CreateVectorOfSortedTables<reflection::KeyValue>(attributes) : 0;
-  auto documentation__ = documentation ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*documentation) : 0;
-  auto declaration_file__ = declaration_file ? _fbb.CreateString(declaration_file) : 0;
-  return reflection::CreateService(
-      _fbb,
-      name__,
-      calls__,
-      attributes__,
-      documentation__,
-      declaration_file__);
-}
-
-/// File specific information.
-/// Symbols declared within a file may be recovered by iterating over all
-/// symbols and examining the `declaration_file` field.
-struct SchemaFile FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef SchemaFileBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_FILENAME = 4,
-    VT_INCLUDED_FILENAMES = 6
-  };
-  /// Filename, relative to project root.
-  const ::flatbuffers::String *filename() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_FILENAME);
-  }
-  bool KeyCompareLessThan(const SchemaFile * const o) const {
-    return *filename() < *o->filename();
-  }
-  int KeyCompareWithValue(const char *_filename) const {
-    return strcmp(filename()->c_str(), _filename);
-  }
-  template<typename StringType>
-  int KeyCompareWithValue(const StringType& _filename) const {
-    if (filename()->c_str() < _filename) return -1;
-    if (_filename < filename()->c_str()) return 1;
-    return 0;
-  }
-  /// Names of included files, relative to project root.
-  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *included_filenames() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_INCLUDED_FILENAMES);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffsetRequired(verifier, VT_FILENAME) &&
-           verifier.VerifyString(filename()) &&
-           VerifyOffset(verifier, VT_INCLUDED_FILENAMES) &&
-           verifier.VerifyVector(included_filenames()) &&
-           verifier.VerifyVectorOfStrings(included_filenames()) &&
-           verifier.EndTable();
-  }
-};
-
-struct SchemaFileBuilder {
-  typedef SchemaFile Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_filename(::flatbuffers::Offset<::flatbuffers::String> filename) {
-    fbb_.AddOffset(SchemaFile::VT_FILENAME, filename);
-  }
-  void add_included_filenames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> included_filenames) {
-    fbb_.AddOffset(SchemaFile::VT_INCLUDED_FILENAMES, included_filenames);
-  }
-  explicit SchemaFileBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<SchemaFile> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<SchemaFile>(end);
-    fbb_.Required(o, SchemaFile::VT_FILENAME);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<SchemaFile> CreateSchemaFile(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::String> filename = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> included_filenames = 0) {
-  SchemaFileBuilder builder_(_fbb);
-  builder_.add_included_filenames(included_filenames);
-  builder_.add_filename(filename);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<SchemaFile> CreateSchemaFileDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    const char *filename = nullptr,
-    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *included_filenames = nullptr) {
-  auto filename__ = filename ? _fbb.CreateString(filename) : 0;
-  auto included_filenames__ = included_filenames ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*included_filenames) : 0;
-  return reflection::CreateSchemaFile(
-      _fbb,
-      filename__,
-      included_filenames__);
-}
-
-struct Schema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef SchemaBuilder Builder;
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_OBJECTS = 4,
-    VT_ENUMS = 6,
-    VT_FILE_IDENT = 8,
-    VT_FILE_EXT = 10,
-    VT_ROOT_TABLE = 12,
-    VT_SERVICES = 14,
-    VT_ADVANCED_FEATURES = 16,
-    VT_FBS_FILES = 18
-  };
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>> *objects() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>> *>(VT_OBJECTS);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>> *enums() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>> *>(VT_ENUMS);
-  }
-  const ::flatbuffers::String *file_ident() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_FILE_IDENT);
-  }
-  const ::flatbuffers::String *file_ext() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_FILE_EXT);
-  }
-  const reflection::Object *root_table() const {
-    return GetPointer<const reflection::Object *>(VT_ROOT_TABLE);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>> *services() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>> *>(VT_SERVICES);
-  }
-  reflection::AdvancedFeatures advanced_features() const {
-    return static_cast<reflection::AdvancedFeatures>(GetField<uint64_t>(VT_ADVANCED_FEATURES, 0));
-  }
-  /// All the files used in this compilation. Files are relative to where
-  /// flatc was invoked.
-  const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *fbs_files() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *>(VT_FBS_FILES);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffsetRequired(verifier, VT_OBJECTS) &&
-           verifier.VerifyVector(objects()) &&
-           verifier.VerifyVectorOfTables(objects()) &&
-           VerifyOffsetRequired(verifier, VT_ENUMS) &&
-           verifier.VerifyVector(enums()) &&
-           verifier.VerifyVectorOfTables(enums()) &&
-           VerifyOffset(verifier, VT_FILE_IDENT) &&
-           verifier.VerifyString(file_ident()) &&
-           VerifyOffset(verifier, VT_FILE_EXT) &&
-           verifier.VerifyString(file_ext()) &&
-           VerifyOffset(verifier, VT_ROOT_TABLE) &&
-           verifier.VerifyTable(root_table()) &&
-           VerifyOffset(verifier, VT_SERVICES) &&
-           verifier.VerifyVector(services()) &&
-           verifier.VerifyVectorOfTables(services()) &&
-           VerifyField<uint64_t>(verifier, VT_ADVANCED_FEATURES, 8) &&
-           VerifyOffset(verifier, VT_FBS_FILES) &&
-           verifier.VerifyVector(fbs_files()) &&
-           verifier.VerifyVectorOfTables(fbs_files()) &&
-           verifier.EndTable();
-  }
-};
-
-struct SchemaBuilder {
-  typedef Schema Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_objects(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>>> objects) {
-    fbb_.AddOffset(Schema::VT_OBJECTS, objects);
-  }
-  void add_enums(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>>> enums) {
-    fbb_.AddOffset(Schema::VT_ENUMS, enums);
-  }
-  void add_file_ident(::flatbuffers::Offset<::flatbuffers::String> file_ident) {
-    fbb_.AddOffset(Schema::VT_FILE_IDENT, file_ident);
-  }
-  void add_file_ext(::flatbuffers::Offset<::flatbuffers::String> file_ext) {
-    fbb_.AddOffset(Schema::VT_FILE_EXT, file_ext);
-  }
-  void add_root_table(::flatbuffers::Offset<reflection::Object> root_table) {
-    fbb_.AddOffset(Schema::VT_ROOT_TABLE, root_table);
-  }
-  void add_services(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>>> services) {
-    fbb_.AddOffset(Schema::VT_SERVICES, services);
-  }
-  void add_advanced_features(reflection::AdvancedFeatures advanced_features) {
-    fbb_.AddElement<uint64_t>(Schema::VT_ADVANCED_FEATURES, static_cast<uint64_t>(advanced_features), 0);
-  }
-  void add_fbs_files(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>>> fbs_files) {
-    fbb_.AddOffset(Schema::VT_FBS_FILES, fbs_files);
-  }
-  explicit SchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<Schema> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<Schema>(end);
-    fbb_.Required(o, Schema::VT_OBJECTS);
-    fbb_.Required(o, Schema::VT_ENUMS);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<Schema> CreateSchema(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Object>>> objects = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Enum>>> enums = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> file_ident = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> file_ext = 0,
-    ::flatbuffers::Offset<reflection::Object> root_table = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::Service>>> services = 0,
-    reflection::AdvancedFeatures advanced_features = static_cast<reflection::AdvancedFeatures>(0),
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>>> fbs_files = 0) {
-  SchemaBuilder builder_(_fbb);
-  builder_.add_advanced_features(advanced_features);
-  builder_.add_fbs_files(fbs_files);
-  builder_.add_services(services);
-  builder_.add_root_table(root_table);
-  builder_.add_file_ext(file_ext);
-  builder_.add_file_ident(file_ident);
-  builder_.add_enums(enums);
-  builder_.add_objects(objects);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<Schema> CreateSchemaDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    std::vector<::flatbuffers::Offset<reflection::Object>> *objects = nullptr,
-    std::vector<::flatbuffers::Offset<reflection::Enum>> *enums = nullptr,
-    const char *file_ident = nullptr,
-    const char *file_ext = nullptr,
-    ::flatbuffers::Offset<reflection::Object> root_table = 0,
-    std::vector<::flatbuffers::Offset<reflection::Service>> *services = nullptr,
-    reflection::AdvancedFeatures advanced_features = static_cast<reflection::AdvancedFeatures>(0),
-    std::vector<::flatbuffers::Offset<reflection::SchemaFile>> *fbs_files = nullptr) {
-  auto objects__ = objects ? _fbb.CreateVectorOfSortedTables<reflection::Object>(objects) : 0;
-  auto enums__ = enums ? _fbb.CreateVectorOfSortedTables<reflection::Enum>(enums) : 0;
-  auto file_ident__ = file_ident ? _fbb.CreateString(file_ident) : 0;
-  auto file_ext__ = file_ext ? _fbb.CreateString(file_ext) : 0;
-  auto services__ = services ? _fbb.CreateVectorOfSortedTables<reflection::Service>(services) : 0;
-  auto fbs_files__ = fbs_files ? _fbb.CreateVectorOfSortedTables<reflection::SchemaFile>(fbs_files) : 0;
-  return reflection::CreateSchema(
-      _fbb,
-      objects__,
-      enums__,
-      file_ident__,
-      file_ext__,
-      root_table,
-      services__,
-      advanced_features,
-      fbs_files__);
-}
-
-inline const reflection::Schema *GetSchema(const void *buf) {
-  return ::flatbuffers::GetRoot<reflection::Schema>(buf);
-}
-
-inline const reflection::Schema *GetSizePrefixedSchema(const void *buf) {
-  return ::flatbuffers::GetSizePrefixedRoot<reflection::Schema>(buf);
-}
-
-inline const char *SchemaIdentifier() {
-  return "BFBS";
-}
-
-inline bool SchemaBufferHasIdentifier(const void *buf) {
-  return ::flatbuffers::BufferHasIdentifier(
-      buf, SchemaIdentifier());
-}
-
-inline bool SizePrefixedSchemaBufferHasIdentifier(const void *buf) {
-  return ::flatbuffers::BufferHasIdentifier(
-      buf, SchemaIdentifier(), true);
-}
-
-template <bool B = false>
-inline bool VerifySchemaBuffer(
-    ::flatbuffers::VerifierTemplate<B> &verifier) {
-  return verifier.template VerifyBuffer<reflection::Schema>(SchemaIdentifier());
-}
-
-template <bool B = false>
-inline bool VerifySizePrefixedSchemaBuffer(
-    ::flatbuffers::VerifierTemplate<B> &verifier) {
-  return verifier.template VerifySizePrefixedBuffer<reflection::Schema>(SchemaIdentifier());
-}
-
-inline const char *SchemaExtension() {
-  return "bfbs";
-}
-
-inline void FinishSchemaBuffer(
-    ::flatbuffers::FlatBufferBuilder &fbb,
-    ::flatbuffers::Offset<reflection::Schema> root) {
-  fbb.Finish(root, SchemaIdentifier());
-}
-
-inline void FinishSizePrefixedSchemaBuffer(
-    ::flatbuffers::FlatBufferBuilder &fbb,
-    ::flatbuffers::Offset<reflection::Schema> root) {
-  fbb.FinishSizePrefixed(root, SchemaIdentifier());
-}
-
-}  // namespace reflection
-
-#endif  // FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
diff --git a/external/flatbuffers/include/flatbuffers/registry.h b/external/flatbuffers/include/flatbuffers/registry.h
deleted file mode 100644
index e70cfc33..00000000
--- a/external/flatbuffers/include/flatbuffers/registry.h
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright 2017 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_REGISTRY_H_
-#define FLATBUFFERS_REGISTRY_H_
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/idl.h"
-
-namespace flatbuffers {
-
-// Convenience class to easily parse or generate text for arbitrary FlatBuffers.
-// Simply pre-populate it with all schema filenames that may be in use, and
-// This class will look them up using the file_identifier declared in the
-// schema.
-class Registry {
- public:
-  // Call this for all schemas that may be in use. The identifier has
-  // a function in the generated code, e.g. MonsterIdentifier().
-  void Register(const char* file_identifier, const char* schema_path) {
-    Schema schema;
-    schema.path_ = schema_path;
-    schemas_[file_identifier] = schema;
-  }
-
-  // Generate text from an arbitrary FlatBuffer by looking up its
-  // file_identifier in the registry.
-  bool FlatBufferToText(const uint8_t* flatbuf, size_t len, std::string* dest) {
-    // Get the identifier out of the buffer.
-    // If the buffer is truncated, exit.
-    if (len < sizeof(uoffset_t) + kFileIdentifierLength) {
-      lasterror_ = "buffer truncated";
-      return false;
-    }
-    std::string ident(
-        reinterpret_cast<const char*>(flatbuf) + sizeof(uoffset_t),
-        kFileIdentifierLength);
-    // Load and parse the schema.
-    Parser parser;
-    if (!LoadSchema(ident, &parser)) return false;
-    // Now we're ready to generate text.
-    auto err = GenText(parser, flatbuf, dest);
-    if (err) {
-      lasterror_ =
-          "unable to generate text for FlatBuffer binary: " + std::string(err);
-      return false;
-    }
-    return true;
-  }
-
-  // Converts a binary buffer to text using one of the schemas in the registry,
-  // use the file_identifier to indicate which.
-  // If DetachedBuffer::data() is null then parsing failed.
-  DetachedBuffer TextToFlatBuffer(const char* text,
-                                  const char* file_identifier) {
-    // Load and parse the schema.
-    Parser parser;
-    if (!LoadSchema(file_identifier, &parser)) return DetachedBuffer();
-    // Parse the text.
-    if (!parser.Parse(text)) {
-      lasterror_ = parser.error_;
-      return DetachedBuffer();
-    }
-    // We have a valid FlatBuffer. Detach it from the builder and return.
-    return parser.builder_.Release();
-  }
-
-  // Modify any parsing / output options used by the other functions.
-  void SetOptions(const IDLOptions& opts) { opts_ = opts; }
-
-  // If schemas used contain include statements, call this function for every
-  // directory the parser should search them for.
-  void AddIncludeDirectory(const char* path) { include_paths_.push_back(path); }
-
-  // Returns a human readable error if any of the above functions fail.
-  const std::string& GetLastError() { return lasterror_; }
-
- private:
-  bool LoadSchema(const std::string& ident, Parser* parser) {
-    // Find the schema, if not, exit.
-    auto it = schemas_.find(ident);
-    if (it == schemas_.end()) {
-      // Don't attach the identifier, since it may not be human readable.
-      lasterror_ = "identifier for this buffer not in the registry";
-      return false;
-    }
-    auto& schema = it->second;
-    // Load the schema from disk. If not, exit.
-    std::string schematext;
-    if (!LoadFile(schema.path_.c_str(), false, &schematext)) {
-      lasterror_ = "could not load schema: " + schema.path_;
-      return false;
-    }
-    // Parse schema.
-    parser->opts = opts_;
-    if (!parser->Parse(schematext.c_str(), include_paths_.data(),
-                       schema.path_.c_str())) {
-      lasterror_ = parser->error_;
-      return false;
-    }
-    return true;
-  }
-
-  struct Schema {
-    std::string path_;
-    // TODO(wvo) optionally cache schema file or parsed schema here.
-  };
-
-  std::string lasterror_;
-  IDLOptions opts_;
-  std::vector<const char*> include_paths_;
-  std::map<std::string, Schema> schemas_;
-};
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_REGISTRY_H_
diff --git a/external/flatbuffers/include/flatbuffers/stl_emulation.h b/external/flatbuffers/include/flatbuffers/stl_emulation.h
deleted file mode 100644
index fc8e4b1d..00000000
--- a/external/flatbuffers/include/flatbuffers/stl_emulation.h
+++ /dev/null
@@ -1,516 +0,0 @@
-/*
- * Copyright 2017 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_STL_EMULATION_H_
-#define FLATBUFFERS_STL_EMULATION_H_
-
-// clang-format off
-#include "flatbuffers/base.h"
-
-#include <string>
-#include <type_traits>
-#include <vector>
-#include <memory>
-#include <limits>
-
-#ifndef FLATBUFFERS_USE_STD_OPTIONAL
-  // Detect C++17 compatible compiler.
-  // __cplusplus >= 201703L - a compiler has support of 'static inline' variables.
-  #if (defined(__cplusplus) && __cplusplus >= 201703L) \
-      || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-    #define FLATBUFFERS_USE_STD_OPTIONAL 1
-  #else
-    #define FLATBUFFERS_USE_STD_OPTIONAL 0
-  #endif // (defined(__cplusplus) && __cplusplus >= 201703L) ...
-#endif // FLATBUFFERS_USE_STD_OPTIONAL
-
-#if FLATBUFFERS_USE_STD_OPTIONAL
-  #include <optional>
-#endif
-
-#ifndef FLATBUFFERS_USE_STD_SPAN
-  // Testing __cpp_lib_span requires including either <version> or <span>,
-  // both of which were added in C++20.
-  // See: https://en.cppreference.com/w/cpp/utility/feature_test
-  #if defined(__cplusplus) && __cplusplus >= 202002L \
-      || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
-    #if __has_include(<span>)
-      #define FLATBUFFERS_USE_STD_SPAN 1
-    #endif
-  #endif
-#endif // FLATBUFFERS_USE_STD_SPAN
-
-#if defined(FLATBUFFERS_USE_STD_SPAN)
-  #include <array>
-  #include <span>
-#else
-  // Disable non-trivial ctors if FLATBUFFERS_SPAN_MINIMAL defined.
-  #if !defined(FLATBUFFERS_TEMPLATES_ALIASES)
-    #define FLATBUFFERS_SPAN_MINIMAL
-  #else
-    // Enable implicit construction of a span<T,N> from a std::array<T,N>.
-    #include <array>
-  #endif
-#endif // defined(FLATBUFFERS_USE_STD_SPAN)
-
-// This header provides backwards compatibility for older versions of the STL.
-namespace flatbuffers {
-
-#if defined(FLATBUFFERS_TEMPLATES_ALIASES)
-  template <typename T>
-  using numeric_limits = std::numeric_limits<T>;
-#else
-  template <typename T> class numeric_limits :
-    public std::numeric_limits<T> {};
-#endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
-
-#if defined(FLATBUFFERS_TEMPLATES_ALIASES)
-  template <typename T> using is_scalar = std::is_scalar<T>;
-  template <typename T, typename U> using is_same = std::is_same<T,U>;
-  template <typename T> using is_floating_point = std::is_floating_point<T>;
-  template <typename T> using is_unsigned = std::is_unsigned<T>;
-  template <typename T> using is_enum = std::is_enum<T>;
-  template <typename T> using make_unsigned = std::make_unsigned<T>;
-  template<bool B, class T, class F>
-  using conditional = std::conditional<B, T, F>;
-  template<class T, T v>
-  using integral_constant = std::integral_constant<T, v>;
-  template <bool B>
-  using bool_constant = integral_constant<bool, B>;
-  using true_type  = std::true_type;
-  using false_type = std::false_type;
-#else
-  // MSVC 2010 doesn't support C++11 aliases.
-  template <typename T> struct is_scalar : public std::is_scalar<T> {};
-  template <typename T, typename U> struct is_same : public std::is_same<T,U> {};
-  template <typename T> struct is_floating_point :
-        public std::is_floating_point<T> {};
-  template <typename T> struct is_unsigned : public std::is_unsigned<T> {};
-  template <typename T> struct is_enum : public std::is_enum<T> {};
-  template <typename T> struct make_unsigned : public std::make_unsigned<T> {};
-  template<bool B, class T, class F>
-  struct conditional : public std::conditional<B, T, F> {};
-  template<class T, T v>
-  struct integral_constant : public std::integral_constant<T, v> {};
-  template <bool B>
-  struct bool_constant : public integral_constant<bool, B> {};
-  typedef bool_constant<true>  true_type;
-  typedef bool_constant<false> false_type;
-#endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
-
-#if defined(FLATBUFFERS_TEMPLATES_ALIASES)
-  template <class T> using unique_ptr = std::unique_ptr<T>;
-#else
-  // MSVC 2010 doesn't support C++11 aliases.
-  // We're manually "aliasing" the class here as we want to bring unique_ptr
-  // into the flatbuffers namespace.  We have unique_ptr in the flatbuffers
-  // namespace we have a completely independent implementation (see below)
-  // for C++98 STL implementations.
-  template <class T> class unique_ptr : public std::unique_ptr<T> {
-    public:
-    unique_ptr() {}
-    explicit unique_ptr(T* p) : std::unique_ptr<T>(p) {}
-    unique_ptr(std::unique_ptr<T>&& u) { *this = std::move(u); }
-    unique_ptr(unique_ptr&& u) { *this = std::move(u); }
-    unique_ptr& operator=(std::unique_ptr<T>&& u) {
-      std::unique_ptr<T>::reset(u.release());
-      return *this;
-    }
-    unique_ptr& operator=(unique_ptr&& u) {
-      std::unique_ptr<T>::reset(u.release());
-      return *this;
-    }
-    unique_ptr& operator=(T* p) {
-      return std::unique_ptr<T>::operator=(p);
-    }
-  };
-#endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
-
-#if FLATBUFFERS_USE_STD_OPTIONAL
-template<class T>
-using Optional = std::optional<T>;
-using nullopt_t = std::nullopt_t;
-inline constexpr nullopt_t nullopt = std::nullopt;
-
-#else
-// Limited implementation of Optional<T> type for a scalar T.
-// This implementation limited by trivial types compatible with
-// std::is_arithmetic<T> or std::is_enum<T> type traits.
-
-// A tag to indicate an empty flatbuffers::optional<T>.
-struct nullopt_t {
-  explicit FLATBUFFERS_CONSTEXPR_CPP11 nullopt_t(int) {}
-};
-
-#if defined(FLATBUFFERS_CONSTEXPR_DEFINED)
-  namespace internal {
-    template <class> struct nullopt_holder {
-      static constexpr nullopt_t instance_ = nullopt_t(0);
-    };
-    template<class Dummy>
-    constexpr nullopt_t nullopt_holder<Dummy>::instance_;
-  }
-  static constexpr const nullopt_t &nullopt = internal::nullopt_holder<void>::instance_;
-
-#else
-  namespace internal {
-    template <class> struct nullopt_holder {
-      static const nullopt_t instance_;
-    };
-    template<class Dummy>
-    const nullopt_t nullopt_holder<Dummy>::instance_  = nullopt_t(0);
-  }
-  static const nullopt_t &nullopt = internal::nullopt_holder<void>::instance_;
-
-#endif
-
-template<class T>
-class Optional FLATBUFFERS_FINAL_CLASS {
-  // Non-scalar 'T' would extremely complicated Optional<T>.
-  // Use is_scalar<T> checking because flatbuffers flatbuffers::is_arithmetic<T>
-  // isn't implemented.
-  static_assert(flatbuffers::is_scalar<T>::value, "unexpected type T");
-
- public:
-  ~Optional() {}
-
-  FLATBUFFERS_CONSTEXPR_CPP11 Optional() FLATBUFFERS_NOEXCEPT
-    : value_(), has_value_(false) {}
-
-  FLATBUFFERS_CONSTEXPR_CPP11 Optional(nullopt_t) FLATBUFFERS_NOEXCEPT
-    : value_(), has_value_(false) {}
-
-  FLATBUFFERS_CONSTEXPR_CPP11 Optional(T val) FLATBUFFERS_NOEXCEPT
-    : value_(val), has_value_(true) {}
-
-  FLATBUFFERS_CONSTEXPR_CPP11 Optional(const Optional &other) FLATBUFFERS_NOEXCEPT
-    : value_(other.value_), has_value_(other.has_value_) {}
-
-  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(const Optional &other) FLATBUFFERS_NOEXCEPT {
-    value_ = other.value_;
-    has_value_ = other.has_value_;
-    return *this;
-  }
-
-  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(nullopt_t) FLATBUFFERS_NOEXCEPT {
-    value_ = T();
-    has_value_ = false;
-    return *this;
-  }
-
-  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(T val) FLATBUFFERS_NOEXCEPT {
-    value_ = val;
-    has_value_ = true;
-    return *this;
-  }
-
-  void reset() FLATBUFFERS_NOEXCEPT {
-    *this = nullopt;
-  }
-
-  void swap(Optional &other) FLATBUFFERS_NOEXCEPT {
-    std::swap(value_, other.value_);
-    std::swap(has_value_, other.has_value_);
-  }
-
-  FLATBUFFERS_CONSTEXPR_CPP11 FLATBUFFERS_EXPLICIT_CPP11 operator bool() const FLATBUFFERS_NOEXCEPT {
-    return has_value_;
-  }
-
-  FLATBUFFERS_CONSTEXPR_CPP11 bool has_value() const FLATBUFFERS_NOEXCEPT {
-    return has_value_;
-  }
-
-  FLATBUFFERS_CONSTEXPR_CPP11 const T& operator*() const FLATBUFFERS_NOEXCEPT {
-    return value_;
-  }
-
-  const T& value() const {
-    FLATBUFFERS_ASSERT(has_value());
-    return value_;
-  }
-
-  T value_or(T default_value) const FLATBUFFERS_NOEXCEPT {
-    return has_value() ? value_ : default_value;
-  }
-
- private:
-  T value_;
-  bool has_value_;
-};
-
-template<class T>
-FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& opt, nullopt_t) FLATBUFFERS_NOEXCEPT {
-  return !opt;
-}
-template<class T>
-FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(nullopt_t, const Optional<T>& opt) FLATBUFFERS_NOEXCEPT {
-  return !opt;
-}
-
-template<class T, class U>
-FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& lhs, const U& rhs) FLATBUFFERS_NOEXCEPT {
-  return static_cast<bool>(lhs) && (*lhs == rhs);
-}
-
-template<class T, class U>
-FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const T& lhs, const Optional<U>& rhs) FLATBUFFERS_NOEXCEPT {
-  return static_cast<bool>(rhs) && (lhs == *rhs);
-}
-
-template<class T, class U>
-FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& lhs, const Optional<U>& rhs) FLATBUFFERS_NOEXCEPT {
-  return static_cast<bool>(lhs) != static_cast<bool>(rhs)
-              ? false
-              : !static_cast<bool>(lhs) ? true : (*lhs == *rhs);
-}
-#endif // FLATBUFFERS_USE_STD_OPTIONAL
-
-
-// Very limited and naive partial implementation of C++20 std::span<T,Extent>.
-#if defined(FLATBUFFERS_USE_STD_SPAN)
-  inline constexpr std::size_t dynamic_extent = std::dynamic_extent;
-  template<class T, std::size_t Extent = std::dynamic_extent>
-  using span = std::span<T, Extent>;
-
-#else // !defined(FLATBUFFERS_USE_STD_SPAN)
-FLATBUFFERS_CONSTEXPR std::size_t dynamic_extent = static_cast<std::size_t>(-1);
-
-// Exclude this code if MSVC2010 or non-STL Android is active.
-// The non-STL Android doesn't have `std::is_convertible` required for SFINAE.
-#if !defined(FLATBUFFERS_SPAN_MINIMAL)
-namespace internal {
-  // This is SFINAE helper class for checking of a common condition:
-  // > This overload only participates in overload resolution
-  // > Check whether a pointer to an array of From can be converted
-  // > to a pointer to an array of To.
-  // This helper is used for checking of 'From -> const From'.
-  template<class To, std::size_t Extent, class From, std::size_t N>
-  struct is_span_convertible {
-    using type =
-      typename std::conditional<std::is_convertible<From (*)[], To (*)[]>::value
-                                && (Extent == dynamic_extent || N == Extent),
-                                int, void>::type;
-  };
-
-  template<typename T>
-  struct SpanIterator {
-    // TODO: upgrade to std::random_access_iterator_tag.
-    using iterator_category = std::forward_iterator_tag;
-    using difference_type  = std::ptrdiff_t;
-    using value_type = typename std::remove_cv<T>::type;
-    using reference = T&;
-    using pointer   = T*;
-
-    // Convince MSVC compiler that this iterator is trusted (it is verified).
-    #ifdef _MSC_VER
-      using _Unchecked_type = pointer;
-    #endif // _MSC_VER
-
-    SpanIterator(pointer ptr) : ptr_(ptr) {}
-    reference operator*() const { return *ptr_; }
-    pointer operator->() { return ptr_; }
-    SpanIterator& operator++() { ptr_++; return *this; }
-    SpanIterator  operator++(int) { auto tmp = *this; ++(*this); return tmp; }
-
-    friend bool operator== (const SpanIterator& lhs, const SpanIterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
-    friend bool operator!= (const SpanIterator& lhs, const SpanIterator& rhs) { return lhs.ptr_ != rhs.ptr_; }
-
-   private:
-    pointer ptr_;
-  };
-}  // namespace internal
-#endif  // !defined(FLATBUFFERS_SPAN_MINIMAL)
-
-// T - element type; must be a complete type that is not an abstract
-// class type.
-// Extent - the number of elements in the sequence, or dynamic.
-template<class T, std::size_t Extent = dynamic_extent>
-class span FLATBUFFERS_FINAL_CLASS {
- public:
-  typedef T element_type;
-  typedef T& reference;
-  typedef const T& const_reference;
-  typedef T* pointer;
-  typedef const T* const_pointer;
-  typedef std::size_t size_type;
-
-  static FLATBUFFERS_CONSTEXPR size_type extent = Extent;
-
-  // Returns the number of elements in the span.
-  FLATBUFFERS_CONSTEXPR_CPP11 size_type size() const FLATBUFFERS_NOEXCEPT {
-    return count_;
-  }
-
-  // Returns the size of the sequence in bytes.
-  FLATBUFFERS_CONSTEXPR_CPP11
-  size_type size_bytes() const FLATBUFFERS_NOEXCEPT {
-    return size() * sizeof(element_type);
-  }
-
-  // Checks if the span is empty.
-  FLATBUFFERS_CONSTEXPR_CPP11 bool empty() const FLATBUFFERS_NOEXCEPT {
-    return size() == 0;
-  }
-
-  // Returns a pointer to the beginning of the sequence.
-  FLATBUFFERS_CONSTEXPR_CPP11 pointer data() const FLATBUFFERS_NOEXCEPT {
-    return data_;
-  }
-
-  #if !defined(FLATBUFFERS_SPAN_MINIMAL)
-    using Iterator = internal::SpanIterator<T>;
-
-    Iterator begin() const { return Iterator(data()); }
-    Iterator end() const   { return Iterator(data() + size()); }
-  #endif
-
-  // Returns a reference to the idx-th element of the sequence.
-  // The behavior is undefined if the idx is greater than or equal to size().
-  FLATBUFFERS_CONSTEXPR_CPP11 reference operator[](size_type idx) const {
-    return data()[idx];
-  }
-
-  FLATBUFFERS_CONSTEXPR_CPP11 span(const span &other) FLATBUFFERS_NOEXCEPT
-      : data_(other.data_), count_(other.count_) {}
-
-  FLATBUFFERS_CONSTEXPR_CPP14 span &operator=(const span &other)
-      FLATBUFFERS_NOEXCEPT {
-    data_ = other.data_;
-    count_ = other.count_;
-  }
-
-  // Limited implementation of
-  // `template <class It> constexpr std::span(It first, size_type count);`.
-  //
-  // Constructs a span that is a view over the range [first, first + count);
-  // the resulting span has: data() == first and size() == count.
-  // The behavior is undefined if [first, first + count) is not a valid range,
-  // or if (extent != flatbuffers::dynamic_extent && count != extent).
-  FLATBUFFERS_CONSTEXPR_CPP11
-  explicit span(pointer first, size_type count) FLATBUFFERS_NOEXCEPT
-    : data_ (Extent == dynamic_extent ? first : (Extent == count ? first : nullptr)),
-      count_(Extent == dynamic_extent ? count : (Extent == count ? Extent : 0)) {
-      // Make span empty if the count argument is incompatible with span<T,N>.
-  }
-
-  // Exclude this code if MSVC2010 is active. The MSVC2010 isn't C++11
-  // compliant, it doesn't support default template arguments for functions.
-  #if defined(FLATBUFFERS_SPAN_MINIMAL)
-  FLATBUFFERS_CONSTEXPR_CPP11 span() FLATBUFFERS_NOEXCEPT : data_(nullptr),
-                                                            count_(0) {
-    static_assert(extent == 0 || extent == dynamic_extent, "invalid span");
-  }
-
-  #else
-  // Constructs an empty span whose data() == nullptr and size() == 0.
-  // This overload only participates in overload resolution if
-  // extent == 0 || extent == flatbuffers::dynamic_extent.
-  // A dummy template argument N is need dependency for SFINAE.
-  template<std::size_t N = 0,
-    typename internal::is_span_convertible<element_type, Extent, element_type, (N - N)>::type = 0>
-  FLATBUFFERS_CONSTEXPR_CPP11 span() FLATBUFFERS_NOEXCEPT : data_(nullptr),
-                                                            count_(0) {
-    static_assert(extent == 0 || extent == dynamic_extent, "invalid span");
-  }
-
-  // Constructs a span that is a view over the array arr; the resulting span
-  // has size() == N and data() == std::data(arr). These overloads only
-  // participate in overload resolution if
-  // extent == std::dynamic_extent || N == extent is true and
-  // std::remove_pointer_t<decltype(std::data(arr))>(*)[]
-  // is convertible to element_type (*)[].
-  template<std::size_t N,
-    typename internal::is_span_convertible<element_type, Extent, element_type, N>::type = 0>
-  FLATBUFFERS_CONSTEXPR_CPP11 span(element_type (&arr)[N]) FLATBUFFERS_NOEXCEPT
-      : data_(arr), count_(N) {}
-
-  template<class U, std::size_t N,
-    typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
-  FLATBUFFERS_CONSTEXPR_CPP11 span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
-     : data_(arr.data()), count_(N) {}
-
-  //template<class U, std::size_t N,
-  //  int = 0>
-  //FLATBUFFERS_CONSTEXPR_CPP11 span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
-  //   : data_(arr.data()), count_(N) {}
-
-  template<class U, std::size_t N,
-    typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
-  FLATBUFFERS_CONSTEXPR_CPP11 span(const std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
-    : data_(arr.data()), count_(N) {}
-
-  // Converting constructor from another span s;
-  // the resulting span has size() == s.size() and data() == s.data().
-  // This overload only participates in overload resolution
-  // if extent == std::dynamic_extent || N == extent is true and U (*)[]
-  // is convertible to element_type (*)[].
-  template<class U, std::size_t N,
-    typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
-  FLATBUFFERS_CONSTEXPR_CPP11 span(const flatbuffers::span<U, N> &s) FLATBUFFERS_NOEXCEPT
-      : span(s.data(), s.size()) {
-  }
-
-  #endif  // !defined(FLATBUFFERS_SPAN_MINIMAL)
-
- private:
-  // This is a naive implementation with 'count_' member even if (Extent != dynamic_extent).
-  pointer const data_;
-  size_type count_;
-};
-#endif  // defined(FLATBUFFERS_USE_STD_SPAN)
-
-#if !defined(FLATBUFFERS_SPAN_MINIMAL)
-template<class ElementType, std::size_t Extent>
-FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<ElementType, Extent> make_span(ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
-  return span<ElementType, Extent>(arr);
-}
-
-template<class ElementType, std::size_t Extent>
-FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<const ElementType, Extent> make_span(const ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
-  return span<const ElementType, Extent>(arr);
-}
-
-template<class ElementType, std::size_t Extent>
-FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<ElementType, Extent> make_span(std::array<ElementType, Extent> &arr) FLATBUFFERS_NOEXCEPT {
-  return span<ElementType, Extent>(arr);
-}
-
-template<class ElementType, std::size_t Extent>
-FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<const ElementType, Extent> make_span(const std::array<ElementType, Extent> &arr) FLATBUFFERS_NOEXCEPT {
-  return span<const ElementType, Extent>(arr);
-}
-
-template<class ElementType, std::size_t Extent>
-FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<ElementType, dynamic_extent> make_span(ElementType *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
-  return span<ElementType, dynamic_extent>(first, count);
-}
-
-template<class ElementType, std::size_t Extent>
-FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<const ElementType, dynamic_extent> make_span(const ElementType *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
-  return span<const ElementType, dynamic_extent>(first, count);
-}
-#endif // !defined(FLATBUFFERS_SPAN_MINIMAL)
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_STL_EMULATION_H_
diff --git a/external/flatbuffers/include/flatbuffers/string.h b/external/flatbuffers/include/flatbuffers/string.h
deleted file mode 100644
index d9c62f96..00000000
--- a/external/flatbuffers/include/flatbuffers/string.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_STRING_H_
-#define FLATBUFFERS_STRING_H_
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/vector.h"
-
-namespace flatbuffers {
-
-struct String : public Vector<char> {
-  const char* c_str() const { return reinterpret_cast<const char*>(Data()); }
-  std::string str() const { return std::string(c_str(), size()); }
-
-  // clang-format off
-  #ifdef FLATBUFFERS_HAS_STRING_VIEW
-  flatbuffers::string_view string_view() const {
-    return flatbuffers::string_view(c_str(), size());
-  }
-
-  /* implicit */
-  operator flatbuffers::string_view() const {
-    return flatbuffers::string_view(c_str(), size());
-  }
-  #endif // FLATBUFFERS_HAS_STRING_VIEW
-  // clang-format on
-
-  bool operator<(const String& o) const {
-    return StringLessThan(this->data(), this->size(), o.data(), o.size());
-  }
-};
-
-// Convenience function to get std::string from a String returning an empty
-// string on null pointer.
-static inline std::string GetString(const String* str) {
-  return str ? str->str() : "";
-}
-
-// Convenience function to get char* from a String returning an empty string on
-// null pointer.
-static inline const char* GetCstring(const String* str) {
-  return str ? str->c_str() : "";
-}
-
-#ifdef FLATBUFFERS_HAS_STRING_VIEW
-// Convenience function to get string_view from a String returning an empty
-// string_view on null pointer.
-static inline flatbuffers::string_view GetStringView(const String* str) {
-  return str ? str->string_view() : flatbuffers::string_view();
-}
-#endif  // FLATBUFFERS_HAS_STRING_VIEW
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_STRING_H_
diff --git a/external/flatbuffers/include/flatbuffers/struct.h b/external/flatbuffers/include/flatbuffers/struct.h
deleted file mode 100644
index 3aa434c0..00000000
--- a/external/flatbuffers/include/flatbuffers/struct.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_STRUCT_H_
-#define FLATBUFFERS_STRUCT_H_
-
-#include "flatbuffers/base.h"
-
-namespace flatbuffers {
-
-// "structs" are flat structures that do not have an offset table, thus
-// always have all members present and do not support forwards/backwards
-// compatible extensions.
-
-class Struct FLATBUFFERS_FINAL_CLASS {
- public:
-  template <typename T>
-  T GetField(uoffset_t o) const {
-    return ReadScalar<T>(&data_[o]);
-  }
-
-  template <typename T>
-  T GetStruct(uoffset_t o) const {
-    return reinterpret_cast<T>(&data_[o]);
-  }
-
-  const uint8_t* GetAddressOf(uoffset_t o) const { return &data_[o]; }
-  uint8_t* GetAddressOf(uoffset_t o) { return &data_[o]; }
-
- private:
-  // private constructor & copy constructor: you obtain instances of this
-  // class by pointing to existing data only
-  Struct();
-  Struct(const Struct&);
-  Struct& operator=(const Struct&);
-
-  uint8_t data_[1];
-};
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_STRUCT_H_
diff --git a/external/flatbuffers/include/flatbuffers/table.h b/external/flatbuffers/include/flatbuffers/table.h
deleted file mode 100644
index 622d1340..00000000
--- a/external/flatbuffers/include/flatbuffers/table.h
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_TABLE_H_
-#define FLATBUFFERS_TABLE_H_
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/vector.h"
-#include "flatbuffers/verifier.h"
-
-namespace flatbuffers {
-
-// "tables" use an offset table (possibly shared) that allows fields to be
-// omitted and added at will, but uses an extra indirection to read.
-class Table {
- public:
-  const uint8_t* GetVTable() const {
-    return data_ - ReadScalar<soffset_t>(data_);
-  }
-
-  // This gets the field offset for any of the functions below it, or 0
-  // if the field was not present.
-  voffset_t GetOptionalFieldOffset(voffset_t field) const {
-    // The vtable offset is always at the start.
-    auto vtable = GetVTable();
-    // The first element is the size of the vtable (fields + type id + itself).
-    auto vtsize = ReadScalar<voffset_t>(vtable);
-    // If the field we're accessing is outside the vtable, we're reading older
-    // data, so it's the same as if the offset was 0 (not present).
-    return field < vtsize ? ReadScalar<voffset_t>(vtable + field) : 0;
-  }
-
-  template <typename T>
-  T GetField(voffset_t field, T defaultval) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
-  }
-
-  template <typename P, typename OffsetSize = uoffset_t>
-  P GetPointer(voffset_t field) {
-    auto field_offset = GetOptionalFieldOffset(field);
-    auto p = data_ + field_offset;
-    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
-                        : nullptr;
-  }
-  template <typename P, typename OffsetSize = uoffset_t>
-  P GetPointer(voffset_t field) const {
-    return const_cast<Table*>(this)->GetPointer<P, OffsetSize>(field);
-  }
-
-  template <typename P>
-  P GetPointer64(voffset_t field) {
-    return GetPointer<P, uoffset64_t>(field);
-  }
-
-  template <typename P>
-  P GetPointer64(voffset_t field) const {
-    return GetPointer<P, uoffset64_t>(field);
-  }
-
-  template <typename P, typename SizeT = uoffset_t,
-            typename OffsetSize = uoffset_t>
-  const Vector<P, SizeT>* GetVectorPointerOrEmpty(voffset_t field) const {
-    auto* ptr = GetPointer<const Vector<P, SizeT>*, OffsetSize>(field);
-    return ptr ? ptr : EmptyVector<P, SizeT>();
-  }
-
-  template <typename P, typename SizeT = uoffset_t>
-  const Vector<P, SizeT>* GetVectorPointer64OrEmpty(voffset_t field) const {
-    return GetVectorPointerOrEmpty<P, SizeT, uoffset64_t>(field);
-  }
-
-  template <typename P, typename SizeT = uoffset_t,
-            typename OffsetSize = uoffset_t>
-  Vector<P, SizeT>* GetMutableVectorPointerOrEmpty(voffset_t field) {
-    auto* ptr = GetPointer<Vector<P, SizeT>*, OffsetSize>(field);
-    // This is a const_cast, but safe, since all mutable operations on an
-    // empty vector are NOPs.
-    return ptr ? ptr : const_cast<Vector<P, SizeT>*>(EmptyVector<P, SizeT>());
-  }
-
-  template <typename P, typename SizeT = uoffset_t>
-  Vector<P, SizeT>* GetMutableVectorPointer64OrEmpty(voffset_t field) {
-    return GetMutableVectorPointerOrEmpty<P, SizeT, uoffset64_t>(field);
-  }
-
-  template <typename P>
-  P GetStruct(voffset_t field) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    auto p = const_cast<uint8_t*>(data_ + field_offset);
-    return field_offset ? reinterpret_cast<P>(p) : nullptr;
-  }
-
-  template <typename Raw, typename Face>
-  flatbuffers::Optional<Face> GetOptional(voffset_t field) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    auto p = data_ + field_offset;
-    return field_offset ? Optional<Face>(static_cast<Face>(ReadScalar<Raw>(p)))
-                        : Optional<Face>();
-  }
-
-  template <typename T>
-  bool SetField(voffset_t field, T val, T def) {
-    auto field_offset = GetOptionalFieldOffset(field);
-    if (!field_offset) return IsTheSameAs(val, def);
-    WriteScalar(data_ + field_offset, val);
-    return true;
-  }
-  template <typename T>
-  bool SetField(voffset_t field, T val) {
-    auto field_offset = GetOptionalFieldOffset(field);
-    if (!field_offset) return false;
-    WriteScalar(data_ + field_offset, val);
-    return true;
-  }
-
-  bool SetPointer(voffset_t field, const uint8_t* val) {
-    auto field_offset = GetOptionalFieldOffset(field);
-    if (!field_offset) return false;
-    WriteScalar(data_ + field_offset,
-                static_cast<uoffset_t>(val - (data_ + field_offset)));
-    return true;
-  }
-
-  uint8_t* GetAddressOf(voffset_t field) {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return field_offset ? data_ + field_offset : nullptr;
-  }
-  const uint8_t* GetAddressOf(voffset_t field) const {
-    return const_cast<Table*>(this)->GetAddressOf(field);
-  }
-
-  bool CheckField(voffset_t field) const {
-    return GetOptionalFieldOffset(field) != 0;
-  }
-
-  // Verify the vtable of this table.
-  // Call this once per table, followed by VerifyField once per field.
-  template <bool B>
-  bool VerifyTableStart(VerifierTemplate<B>& verifier) const {
-    return verifier.VerifyTableStart(data_);
-  }
-
-  // Verify a particular field.
-  template <typename T, bool B>
-  bool VerifyField(const VerifierTemplate<B>& verifier, voffset_t field,
-                   size_t align) const {
-    // Calling GetOptionalFieldOffset should be safe now thanks to
-    // VerifyTable().
-    auto field_offset = GetOptionalFieldOffset(field);
-    // Check the actual field.
-    return !field_offset ||
-           verifier.template VerifyField<T>(data_, field_offset, align);
-  }
-
-  // VerifyField for required fields.
-  template <typename T, bool B>
-  bool VerifyFieldRequired(const VerifierTemplate<B>& verifier, voffset_t field,
-                           size_t align) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return verifier.Check(field_offset != 0) &&
-           verifier.template VerifyField<T>(data_, field_offset, align);
-  }
-
-  // Versions for offsets.
-  template <typename OffsetT = uoffset_t, bool B = false>
-  bool VerifyOffset(const VerifierTemplate<B>& verifier,
-                    voffset_t field) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return !field_offset ||
-           verifier.template VerifyOffset<OffsetT>(data_, field_offset);
-  }
-
-  template <typename OffsetT = uoffset_t, bool B = false>
-  bool VerifyOffsetRequired(const VerifierTemplate<B>& verifier,
-                            voffset_t field) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return verifier.Check(field_offset != 0) &&
-           verifier.template VerifyOffset<OffsetT>(data_, field_offset);
-  }
-
-  template <bool B>
-  bool VerifyOffset64(const VerifierTemplate<B>& verifier,
-                      voffset_t field) const {
-    return VerifyOffset<uoffset64_t>(verifier, field);
-  }
-
-  template <bool B>
-  bool VerifyOffset64Required(const VerifierTemplate<B>& verifier,
-                              voffset_t field) const {
-    return VerifyOffsetRequired<uoffset64_t>(verifier, field);
-  }
-
-  // Verify a string that may have a default value.
-  template <typename OffsetT = uoffset_t>
-  bool VerifyStringWithDefault(const Verifier& verifier,
-                               voffset_t field) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return field_offset == 0 ||
-           verifier.VerifyString(GetPointer<const String*, OffsetT>(field));
-  }
-
-  // Verify a vector that has a default empty value.
-  template <typename P, typename SizeT = uoffset_t,
-            typename OffsetSize = uoffset_t>
-  bool VerifyVectorWithDefault(const Verifier& verifier,
-                               voffset_t field) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return field_offset == 0 ||
-           verifier.VerifyVector(
-               GetPointer<const Vector<P, SizeT>*, OffsetSize>(field));
-  }
-
-  template <typename P, typename SizeT = uoffset_t>
-  bool VerifyVector64WithDefault(const Verifier& verifier,
-                                 voffset_t field) const {
-    return VerifyVectorWithDefault<P, SizeT, uoffset64_t>(verifier, field);
-  }
-
- protected:
-  template <typename T, typename SizeT = uoffset_t>
-  static const Vector<T, SizeT>* EmptyVector() {
-    static const SizeT empty_vector_length = 0;
-    return reinterpret_cast<const Vector<T, SizeT>*>(&empty_vector_length);
-  }
-
- private:
-  // private constructor & copy constructor: you obtain instances of this
-  // class by pointing to existing data only
-  Table();
-  Table(const Table& other);
-  Table& operator=(const Table&);
-
-  uint8_t data_[1];
-};
-
-// This specialization allows avoiding warnings like:
-// MSVC C4800: type: forcing value to bool 'true' or 'false'.
-template <>
-inline flatbuffers::Optional<bool> Table::GetOptional<uint8_t, bool>(
-    voffset_t field) const {
-  auto field_offset = GetOptionalFieldOffset(field);
-  auto p = data_ + field_offset;
-  return field_offset ? Optional<bool>(ReadScalar<uint8_t>(p) != 0)
-                      : Optional<bool>();
-}
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_TABLE_H_
diff --git a/external/flatbuffers/include/flatbuffers/util.h b/external/flatbuffers/include/flatbuffers/util.h
deleted file mode 100644
index d8387e17..00000000
--- a/external/flatbuffers/include/flatbuffers/util.h
+++ /dev/null
@@ -1,781 +0,0 @@
-/*
- * Copyright 2014 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_UTIL_H_
-#define FLATBUFFERS_UTIL_H_
-
-#include <ctype.h>
-#include <errno.h>
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/stl_emulation.h"
-
-#ifndef FLATBUFFERS_PREFER_PRINTF
-#include <iomanip>
-#include <sstream>
-#else  // FLATBUFFERS_PREFER_PRINTF
-#include <float.h>
-#include <stdio.h>
-#endif  // FLATBUFFERS_PREFER_PRINTF
-
-#include <cmath>
-#include <limits>
-#include <string>
-
-namespace flatbuffers {
-
-// @locale-independent functions for ASCII characters set.
-
-// Fast checking that character lies in closed range: [a <= x <= b]
-// using one compare (conditional branch) operator.
-inline bool check_ascii_range(char x, char a, char b) {
-  FLATBUFFERS_ASSERT(a <= b);
-  // (Hacker's Delight): `a <= x <= b` <=> `(x-a) <={u} (b-a)`.
-  // The x, a, b will be promoted to int and subtracted without overflow.
-  return static_cast<unsigned int>(x - a) <= static_cast<unsigned int>(b - a);
-}
-
-// Case-insensitive isalpha
-inline bool is_alpha(char c) {
-  // ASCII only: alpha to upper case => reset bit 0x20 (~0x20 = 0xDF).
-  return check_ascii_range(c & 0xDF, 'a' & 0xDF, 'z' & 0xDF);
-}
-
-// Check for uppercase alpha
-inline bool is_alpha_upper(char c) { return check_ascii_range(c, 'A', 'Z'); }
-
-// Check (case-insensitive) that `c` is equal to alpha.
-inline bool is_alpha_char(char c, char alpha) {
-  FLATBUFFERS_ASSERT(is_alpha(alpha));
-  // ASCII only: alpha to upper case => reset bit 0x20 (~0x20 = 0xDF).
-  return ((c & 0xDF) == (alpha & 0xDF));
-}
-
-// https://en.cppreference.com/w/cpp/string/byte/isxdigit
-// isdigit and isxdigit are the only standard narrow character classification
-// functions that are not affected by the currently installed C locale. although
-// some implementations (e.g. Microsoft in 1252 codepage) may classify
-// additional single-byte characters as digits.
-inline bool is_digit(char c) { return check_ascii_range(c, '0', '9'); }
-
-inline bool is_xdigit(char c) {
-  // Replace by look-up table.
-  return is_digit(c) || check_ascii_range(c & 0xDF, 'a' & 0xDF, 'f' & 0xDF);
-}
-
-// Case-insensitive isalnum
-inline bool is_alnum(char c) { return is_alpha(c) || is_digit(c); }
-
-inline char CharToUpper(char c) {
-  return static_cast<char>(::toupper(static_cast<unsigned char>(c)));
-}
-
-inline char CharToLower(char c) {
-  return static_cast<char>(::tolower(static_cast<unsigned char>(c)));
-}
-
-// @end-locale-independent functions for ASCII character set
-
-#ifdef FLATBUFFERS_PREFER_PRINTF
-template <typename T>
-size_t IntToDigitCount(T t) {
-  size_t digit_count = 0;
-  // Count the sign for negative numbers
-  if (t < 0) digit_count++;
-  // Count a single 0 left of the dot for fractional numbers
-  if (-1 < t && t < 1) digit_count++;
-  // Count digits until fractional part
-  T eps = std::numeric_limits<T>::epsilon();
-  while (t <= (-1 + eps) || (1 - eps) <= t) {
-    t /= 10;
-    digit_count++;
-  }
-  return digit_count;
-}
-
-template <typename T>
-size_t NumToStringWidth(T t, int precision = 0) {
-  size_t string_width = IntToDigitCount(t);
-  // Count the dot for floating point numbers
-  if (precision) string_width += (precision + 1);
-  return string_width;
-}
-
-template <typename T>
-std::string NumToStringImplWrapper(T t, const char* fmt, int precision = 0) {
-  size_t string_width = NumToStringWidth(t, precision);
-  std::string s(string_width, 0x00);
-  // Allow snprintf to use std::string trailing null to detect buffer overflow
-  snprintf(const_cast<char*>(s.data()), (s.size() + 1), fmt, string_width, t);
-  return s;
-}
-#endif  // FLATBUFFERS_PREFER_PRINTF
-
-// Convert an integer or floating point value to a string.
-// In contrast to std::stringstream, "char" values are
-// converted to a string of digits, and we don't use scientific notation.
-template <typename T>
-std::string NumToString(T t) {
-  // clang-format off
-
-  #ifndef FLATBUFFERS_PREFER_PRINTF
-    std::stringstream ss;
-    ss << t;
-    return ss.str();
-  #else // FLATBUFFERS_PREFER_PRINTF
-    auto v = static_cast<long long>(t);
-    return NumToStringImplWrapper(v, "%.*lld");
-  #endif // FLATBUFFERS_PREFER_PRINTF
-  // clang-format on
-}
-// Avoid char types used as character data.
-template <>
-inline std::string NumToString<signed char>(signed char t) {
-  return NumToString(static_cast<int>(t));
-}
-template <>
-inline std::string NumToString<unsigned char>(unsigned char t) {
-  return NumToString(static_cast<int>(t));
-}
-template <>
-inline std::string NumToString<char>(char t) {
-  return NumToString(static_cast<int>(t));
-}
-
-// Special versions for floats/doubles.
-template <typename T>
-std::string FloatToString(T t, int precision) {
-  // clang-format off
-
-  #ifndef FLATBUFFERS_PREFER_PRINTF
-    // to_string() prints different numbers of digits for floats depending on
-    // platform and isn't available on Android, so we use stringstream
-    std::stringstream ss;
-    // Use std::fixed to suppress scientific notation.
-    ss << std::fixed;
-    // Default precision is 6, we want that to be higher for doubles.
-    ss << std::setprecision(precision);
-    ss << t;
-    auto s = ss.str();
-  #else // FLATBUFFERS_PREFER_PRINTF
-    auto v = static_cast<double>(t);
-    auto s = NumToStringImplWrapper(v, "%0.*f", precision);
-  #endif // FLATBUFFERS_PREFER_PRINTF
-  // clang-format on
-  // Sadly, std::fixed turns "1" into "1.00000", so here we undo that.
-  auto p = s.find_last_not_of('0');
-  if (p != std::string::npos) {
-    // Strip trailing zeroes. If it is a whole number, keep one zero.
-    s.resize(p + (s[p] == '.' ? 2 : 1));
-  }
-  return s;
-}
-
-template <>
-inline std::string NumToString<double>(double t) {
-  return FloatToString(t, 12);
-}
-template <>
-inline std::string NumToString<float>(float t) {
-  return FloatToString(t, 6);
-}
-
-// Convert an integer value to a hexadecimal string.
-// The returned string length is always xdigits long, prefixed by 0 digits.
-// For example, IntToStringHex(0x23, 8) returns the string "00000023".
-inline std::string IntToStringHex(int i, int xdigits) {
-  FLATBUFFERS_ASSERT(i >= 0);
-  // clang-format off
-
-  #ifndef FLATBUFFERS_PREFER_PRINTF
-    std::stringstream ss;
-    ss << std::setw(xdigits) << std::setfill('0') << std::hex << std::uppercase
-       << i;
-    return ss.str();
-  #else // FLATBUFFERS_PREFER_PRINTF
-    return NumToStringImplWrapper(i, "%.*X", xdigits);
-  #endif // FLATBUFFERS_PREFER_PRINTF
-  // clang-format on
-}
-
-// clang-format off
-// Use locale independent functions {strtod_l, strtof_l, strtoll_l, strtoull_l}.
-#if defined(FLATBUFFERS_LOCALE_INDEPENDENT) && (FLATBUFFERS_LOCALE_INDEPENDENT > 0)
-  class ClassicLocale {
-    #ifdef _MSC_VER
-      typedef _locale_t locale_type;
-    #else
-      typedef locale_t locale_type;  // POSIX.1-2008 locale_t type
-    #endif
-    ClassicLocale();
-    ~ClassicLocale();
-    locale_type locale_;
-    static ClassicLocale instance_;
-  public:
-    static locale_type Get() { return instance_.locale_; }
-  };
-
-  #ifdef _MSC_VER
-    #define __strtoull_impl(s, pe, b) _strtoui64_l(s, pe, b, ClassicLocale::Get())
-    #define __strtoll_impl(s, pe, b) _strtoi64_l(s, pe, b, ClassicLocale::Get())
-    #define __strtod_impl(s, pe) _strtod_l(s, pe, ClassicLocale::Get())
-    #define __strtof_impl(s, pe) _strtof_l(s, pe, ClassicLocale::Get())
-  #else
-    #define __strtoull_impl(s, pe, b) strtoull_l(s, pe, b, ClassicLocale::Get())
-    #define __strtoll_impl(s, pe, b) strtoll_l(s, pe, b, ClassicLocale::Get())
-    #define __strtod_impl(s, pe) strtod_l(s, pe, ClassicLocale::Get())
-    #define __strtof_impl(s, pe) strtof_l(s, pe, ClassicLocale::Get())
-  #endif
-#else
-  #define __strtod_impl(s, pe) strtod(s, pe)
-  #define __strtof_impl(s, pe) static_cast<float>(strtod(s, pe))
-  #ifdef _MSC_VER
-    #define __strtoull_impl(s, pe, b) _strtoui64(s, pe, b)
-    #define __strtoll_impl(s, pe, b) _strtoi64(s, pe, b)
-  #else
-    #define __strtoull_impl(s, pe, b) strtoull(s, pe, b)
-    #define __strtoll_impl(s, pe, b) strtoll(s, pe, b)
-  #endif
-#endif
-
-inline void strtoval_impl(int64_t *val, const char *str, char **endptr,
-                                 int base) {
-    *val = __strtoll_impl(str, endptr, base);
-}
-
-inline void strtoval_impl(uint64_t *val, const char *str, char **endptr,
-                                 int base) {
-  *val = __strtoull_impl(str, endptr, base);
-}
-
-inline void strtoval_impl(double *val, const char *str, char **endptr) {
-  *val = __strtod_impl(str, endptr);
-}
-
-// UBSAN: double to float is safe if numeric_limits<float>::is_iec559 is true.
-FLATBUFFERS_SUPPRESS_UBSAN("float-cast-overflow")
-inline void strtoval_impl(float *val, const char *str, char **endptr) {
-  *val = __strtof_impl(str, endptr);
-}
-#undef __strtoull_impl
-#undef __strtoll_impl
-#undef __strtod_impl
-#undef __strtof_impl
-// clang-format on
-
-// Adaptor for strtoull()/strtoll().
-// Flatbuffers accepts numbers with any count of leading zeros (-009 is -9),
-// while strtoll with base=0 interprets first leading zero as octal prefix.
-// In future, it is possible to add prefixed 0b0101.
-// 1) Checks errno code for overflow condition (out of range).
-// 2) If base <= 0, function try to detect base of number by prefix.
-//
-// Return value (like strtoull and strtoll, but reject partial result):
-// - If successful, an integer value corresponding to the str is returned.
-// - If full string conversion can't be performed, 0 is returned.
-// - If the converted value falls out of range of corresponding return type, a
-// range error occurs. In this case value MAX(T)/MIN(T) is returned.
-template <typename T>
-inline bool StringToIntegerImpl(T* val, const char* const str,
-                                const int base = 0,
-                                const bool check_errno = true) {
-  // T is int64_t or uint64_T
-  FLATBUFFERS_ASSERT(str);
-  if (base <= 0) {
-    auto s = str;
-    while (*s && !is_digit(*s)) s++;
-    if (s[0] == '0' && is_alpha_char(s[1], 'X'))
-      return StringToIntegerImpl(val, str, 16, check_errno);
-    // if a prefix not match, try base=10
-    return StringToIntegerImpl(val, str, 10, check_errno);
-  } else {
-    if (check_errno) errno = 0;  // clear thread-local errno
-    auto endptr = str;
-    strtoval_impl(val, str, const_cast<char**>(&endptr), base);
-    if ((*endptr != '\0') || (endptr == str)) {
-      *val = 0;      // erase partial result
-      return false;  // invalid string
-    }
-    // errno is out-of-range, return MAX/MIN
-    if (check_errno && errno) return false;
-    return true;
-  }
-}
-
-template <typename T>
-inline bool StringToFloatImpl(T* val, const char* const str) {
-  // Type T must be either float or double.
-  FLATBUFFERS_ASSERT(str && val);
-  auto end = str;
-  strtoval_impl(val, str, const_cast<char**>(&end));
-  auto done = (end != str) && (*end == '\0');
-  if (!done) *val = 0;  // erase partial result
-  if (done && std::isnan(*val)) {
-    *val = std::numeric_limits<T>::quiet_NaN();
-  }
-  return done;
-}
-
-// Convert a string to an instance of T.
-// Return value (matched with StringToInteger64Impl and strtod):
-// - If successful, a numeric value corresponding to the str is returned.
-// - If full string conversion can't be performed, 0 is returned.
-// - If the converted value falls out of range of corresponding return type, a
-// range error occurs. In this case value MAX(T)/MIN(T) is returned.
-template <typename T>
-inline bool StringToNumber(const char* s, T* val) {
-  // Assert on `unsigned long` and `signed long` on LP64.
-  // If it is necessary, it could be solved with flatbuffers::enable_if<B,T>.
-  static_assert(sizeof(T) < sizeof(int64_t), "unexpected type T");
-  FLATBUFFERS_ASSERT(s && val);
-  int64_t i64;
-  // The errno check isn't needed, will return MAX/MIN on overflow.
-  if (StringToIntegerImpl(&i64, s, 0, false)) {
-    const int64_t max = (flatbuffers::numeric_limits<T>::max)();
-    const int64_t min = flatbuffers::numeric_limits<T>::lowest();
-    if (i64 > max) {
-      *val = static_cast<T>(max);
-      return false;
-    }
-    if (i64 < min) {
-      // For unsigned types return max to distinguish from
-      // "no conversion can be performed" when 0 is returned.
-      *val = static_cast<T>(flatbuffers::is_unsigned<T>::value ? max : min);
-      return false;
-    }
-    *val = static_cast<T>(i64);
-    return true;
-  }
-  *val = 0;
-  return false;
-}
-
-template <>
-inline bool StringToNumber<int64_t>(const char* str, int64_t* val) {
-  return StringToIntegerImpl(val, str);
-}
-
-template <>
-inline bool StringToNumber<uint64_t>(const char* str, uint64_t* val) {
-  if (!StringToIntegerImpl(val, str)) return false;
-  // The strtoull accepts negative numbers:
-  // If the minus sign was part of the input sequence, the numeric value
-  // calculated from the sequence of digits is negated as if by unary minus
-  // in the result type, which applies unsigned integer wraparound rules.
-  // Fix this behaviour (except -0).
-  if (*val) {
-    auto s = str;
-    while (*s && !is_digit(*s)) s++;
-    s = (s > str) ? (s - 1) : s;  // step back to one symbol
-    if (*s == '-') {
-      // For unsigned types return the max to distinguish from
-      // "no conversion can be performed".
-      *val = (flatbuffers::numeric_limits<uint64_t>::max)();
-      return false;
-    }
-  }
-  return true;
-}
-
-template <>
-inline bool StringToNumber(const char* s, float* val) {
-  return StringToFloatImpl(val, s);
-}
-
-template <>
-inline bool StringToNumber(const char* s, double* val) {
-  return StringToFloatImpl(val, s);
-}
-
-inline int64_t StringToInt(const char* s, int base = 10) {
-  int64_t val;
-  return StringToIntegerImpl(&val, s, base) ? val : 0;
-}
-
-inline uint64_t StringToUInt(const char* s, int base = 10) {
-  uint64_t val;
-  return StringToIntegerImpl(&val, s, base) ? val : 0;
-}
-
-inline bool StringIsFlatbufferNan(const std::string& s) {
-  return s == "nan" || s == "+nan" || s == "-nan";
-}
-
-inline bool StringIsFlatbufferPositiveInfinity(const std::string& s) {
-  return s == "inf" || s == "+inf" || s == "infinity" || s == "+infinity";
-}
-
-inline bool StringIsFlatbufferNegativeInfinity(const std::string& s) {
-  return s == "-inf" || s == "-infinity";
-}
-
-typedef bool (*LoadFileFunction)(const char* filename, bool binary,
-                                 std::string* dest);
-typedef bool (*FileExistsFunction)(const char* filename);
-
-LoadFileFunction SetLoadFileFunction(LoadFileFunction load_file_function);
-
-FileExistsFunction SetFileExistsFunction(
-    FileExistsFunction file_exists_function);
-
-// Check if file "name" exists.
-bool FileExists(const char* name);
-
-// Check if "name" exists and it is also a directory.
-bool DirExists(const char* name);
-
-// Load file "name" into "buf" returning true if successful
-// false otherwise.  If "binary" is false data is read
-// using ifstream's text mode, otherwise data is read with
-// no transcoding.
-bool LoadFile(const char* name, bool binary, std::string* buf);
-
-// Save data "buf" of length "len" bytes into a file
-// "name" returning true if successful, false otherwise.
-// If "binary" is false data is written using ifstream's
-// text mode, otherwise data is written with no
-// transcoding.
-// NOTE: this function is deprecated in favor of FileSaver class,
-// but left here for compatibility.
-bool SaveFile(const char* name, const char* buf, size_t len, bool binary);
-
-// Save data "buf" into file "name" returning true if
-// successful, false otherwise.  If "binary" is false
-// data is written using ifstream's text mode, otherwise
-// data is written with no transcoding.
-// NOTE: this function is deprecated in favor of FileSaver class,
-// but left here for compatibility.
-inline bool SaveFile(const char* name, const std::string& buf, bool binary) {
-  return SaveFile(name, buf.c_str(), buf.size(), binary);
-}
-
-// Functionality for minimalistic portable path handling.
-
-// The functions below behave correctly regardless of whether posix ('/') or
-// Windows ('/' or '\\') separators are used.
-
-// Any new separators inserted are always posix.
-FLATBUFFERS_CONSTEXPR char kPathSeparator = '/';
-
-// Returns the path with the extension, if any, removed.
-std::string StripExtension(const std::string& filepath);
-
-// Returns the extension, if any.
-std::string GetExtension(const std::string& filepath);
-
-// Return the last component of the path, after the last separator.
-std::string StripPath(const std::string& filepath);
-
-// Strip the last component of the path + separator.
-std::string StripFileName(const std::string& filepath);
-
-std::string StripPrefix(const std::string& filepath,
-                        const std::string& prefix_to_remove);
-
-// Concatenates a path with a filename, regardless of whether the path
-// ends in a separator or not.
-std::string ConCatPathFileName(const std::string& path,
-                               const std::string& filename);
-
-// Replaces any '\\' separators with '/'
-std::string PosixPath(const char* path);
-std::string PosixPath(const std::string& path);
-
-// This function ensure a directory exists, by recursively
-// creating dirs for any parts of the path that don't exist yet.
-void EnsureDirExists(const std::string& filepath);
-
-// Obtains the relative or absolute path.
-std::string FilePath(const std::string& project, const std::string& filePath,
-                     bool absolute);
-
-// Obtains the absolute path from any other path.
-// Returns the input path if the absolute path couldn't be resolved.
-std::string AbsolutePath(const std::string& filepath);
-
-// Returns files relative to the --project_root path, prefixed with `//`.
-std::string RelativeToRootPath(const std::string& project,
-                               const std::string& filepath);
-
-// To and from UTF-8 unicode conversion functions
-
-// Convert a unicode code point into a UTF-8 representation by appending it
-// to a string. Returns the number of bytes generated.
-inline int ToUTF8(uint32_t ucc, std::string* out) {
-  FLATBUFFERS_ASSERT(!(ucc & 0x80000000));  // Top bit can't be set.
-  // 6 possible encodings: http://en.wikipedia.org/wiki/UTF-8
-  for (int i = 0; i < 6; i++) {
-    // Max bits this encoding can represent.
-    uint32_t max_bits = 6 + i * 5 + static_cast<int>(!i);
-    if (ucc < (1u << max_bits)) {  // does it fit?
-      // Remaining bits not encoded in the first byte, store 6 bits each
-      uint32_t remain_bits = i * 6;
-      // Store first byte:
-      (*out) += static_cast<char>((0xFE << (max_bits - remain_bits)) |
-                                  (ucc >> remain_bits));
-      // Store remaining bytes:
-      for (int j = i - 1; j >= 0; j--) {
-        (*out) += static_cast<char>(((ucc >> (j * 6)) & 0x3F) | 0x80);
-      }
-      return i + 1;  // Return the number of bytes added.
-    }
-  }
-  FLATBUFFERS_ASSERT(0);  // Impossible to arrive here.
-  return -1;
-}
-
-// Converts whatever prefix of the incoming string corresponds to a valid
-// UTF-8 sequence into a unicode code. The incoming pointer will have been
-// advanced past all bytes parsed.
-// returns -1 upon corrupt UTF-8 encoding (ignore the incoming pointer in
-// this case).
-inline int FromUTF8(const char** in) {
-  int len = 0;
-  // Count leading 1 bits.
-  for (int mask = 0x80; mask >= 0x04; mask >>= 1) {
-    if (**in & mask) {
-      len++;
-    } else {
-      break;
-    }
-  }
-  if ((static_cast<unsigned char>(**in) << len) & 0x80)
-    return -1;  // Bit after leading 1's must be 0.
-  if (!len) return *(*in)++;
-  // UTF-8 encoded values with a length are between 2 and 4 bytes.
-  if (len < 2 || len > 4) {
-    return -1;
-  }
-  // Grab initial bits of the code.
-  int ucc = *(*in)++ & ((1 << (7 - len)) - 1);
-  for (int i = 0; i < len - 1; i++) {
-    if ((**in & 0xC0) != 0x80) return -1;  // Upper bits must 1 0.
-    ucc <<= 6;
-    ucc |= *(*in)++ & 0x3F;  // Grab 6 more bits of the code.
-  }
-  // UTF-8 cannot encode values between 0xD800 and 0xDFFF (reserved for
-  // UTF-16 surrogate pairs).
-  if (ucc >= 0xD800 && ucc <= 0xDFFF) {
-    return -1;
-  }
-  // UTF-8 must represent code points in their shortest possible encoding.
-  switch (len) {
-    case 2:
-      // Two bytes of UTF-8 can represent code points from U+0080 to U+07FF.
-      if (ucc < 0x0080 || ucc > 0x07FF) {
-        return -1;
-      }
-      break;
-    case 3:
-      // Three bytes of UTF-8 can represent code points from U+0800 to U+FFFF.
-      if (ucc < 0x0800 || ucc > 0xFFFF) {
-        return -1;
-      }
-      break;
-    case 4:
-      // Four bytes of UTF-8 can represent code points from U+10000 to U+10FFFF.
-      if (ucc < 0x10000 || ucc > 0x10FFFF) {
-        return -1;
-      }
-      break;
-  }
-  return ucc;
-}
-
-#ifndef FLATBUFFERS_PREFER_PRINTF
-// Wraps a string to a maximum length, inserting new lines where necessary. Any
-// existing whitespace will be collapsed down to a single space. A prefix or
-// suffix can be provided, which will be inserted before or after a wrapped
-// line, respectively.
-inline std::string WordWrap(const std::string in, size_t max_length,
-                            const std::string wrapped_line_prefix,
-                            const std::string wrapped_line_suffix) {
-  std::istringstream in_stream(in);
-  std::string wrapped, line, word;
-
-  in_stream >> word;
-  line = word;
-
-  while (in_stream >> word) {
-    if ((line.length() + 1 + word.length() + wrapped_line_suffix.length()) <
-        max_length) {
-      line += " " + word;
-    } else {
-      wrapped += line + wrapped_line_suffix + "\n";
-      line = wrapped_line_prefix + word;
-    }
-  }
-  wrapped += line;
-
-  return wrapped;
-}
-#endif  // !FLATBUFFERS_PREFER_PRINTF
-
-inline bool EscapeString(const char* s, size_t length, std::string* _text,
-                         bool allow_non_utf8, bool natural_utf8) {
-  std::string& text = *_text;
-  text += "\"";
-  for (uoffset_t i = 0; i < length; i++) {
-    char c = s[i];
-    switch (c) {
-      case '\n':
-        text += "\\n";
-        break;
-      case '\t':
-        text += "\\t";
-        break;
-      case '\r':
-        text += "\\r";
-        break;
-      case '\b':
-        text += "\\b";
-        break;
-      case '\f':
-        text += "\\f";
-        break;
-      case '\"':
-        text += "\\\"";
-        break;
-      case '\\':
-        text += "\\\\";
-        break;
-      default:
-        if (c >= ' ' && c <= '~') {
-          text += c;
-        } else {
-          // Not printable ASCII data. Let's see if it's valid UTF-8 first:
-          const char* utf8 = s + i;
-          int ucc = FromUTF8(&utf8);
-          if (ucc < 0) {
-            if (allow_non_utf8) {
-              text += "\\x";
-              text += IntToStringHex(static_cast<uint8_t>(c), 2);
-            } else {
-              // There are two cases here:
-              //
-              // 1) We reached here by parsing an IDL file. In that case,
-              // we previously checked for non-UTF-8, so we shouldn't reach
-              // here.
-              //
-              // 2) We reached here by someone calling GenText()
-              // on a previously-serialized flatbuffer. The data might have
-              // non-UTF-8 Strings, or might be corrupt.
-              //
-              // In both cases, we have to give up and inform the caller
-              // they have no JSON.
-              return false;
-            }
-          } else {
-            if (natural_utf8) {
-              // utf8 points to past all utf-8 bytes parsed
-              text.append(s + i, static_cast<size_t>(utf8 - s - i));
-            } else if (ucc <= 0xFFFF) {
-              // Parses as Unicode within JSON's \uXXXX range, so use that.
-              text += "\\u";
-              text += IntToStringHex(ucc, 4);
-            } else if (ucc <= 0x10FFFF) {
-              // Encode Unicode SMP values to a surrogate pair using two \u
-              // escapes.
-              uint32_t base = ucc - 0x10000;
-              auto high_surrogate = (base >> 10) + 0xD800;
-              auto low_surrogate = (base & 0x03FF) + 0xDC00;
-              text += "\\u";
-              text += IntToStringHex(high_surrogate, 4);
-              text += "\\u";
-              text += IntToStringHex(low_surrogate, 4);
-            }
-            // Skip past characters recognized.
-            i = static_cast<uoffset_t>(utf8 - s - 1);
-          }
-        }
-        break;
-    }
-  }
-  text += "\"";
-  return true;
-}
-
-inline std::string BufferToHexText(const void* buffer, size_t buffer_size,
-                                   size_t max_length,
-                                   const std::string& wrapped_line_prefix,
-                                   const std::string& wrapped_line_suffix) {
-  std::string text = wrapped_line_prefix;
-  size_t start_offset = 0;
-  const char* s = reinterpret_cast<const char*>(buffer);
-  for (size_t i = 0; s && i < buffer_size; i++) {
-    // Last iteration or do we have more?
-    bool have_more = i + 1 < buffer_size;
-    text += "0x";
-    text += IntToStringHex(static_cast<uint8_t>(s[i]), 2);
-    if (have_more) {
-      text += ',';
-    }
-    // If we have more to process and we reached max_length
-    if (have_more &&
-        text.size() + wrapped_line_suffix.size() >= start_offset + max_length) {
-      text += wrapped_line_suffix;
-      text += '\n';
-      start_offset = text.size();
-      text += wrapped_line_prefix;
-    }
-  }
-  text += wrapped_line_suffix;
-  return text;
-}
-
-// Remove paired quotes in a string: "text"|'text' -> text.
-std::string RemoveStringQuotes(const std::string& s);
-
-// Change th global C-locale to locale with name <locale_name>.
-// Returns an actual locale name in <_value>, useful if locale_name is "" or
-// null.
-bool SetGlobalTestLocale(const char* locale_name,
-                         std::string* _value = nullptr);
-
-// Read (or test) a value of environment variable.
-bool ReadEnvironmentVariable(const char* var_name,
-                             std::string* _value = nullptr);
-
-enum class Case {
-  kUnknown = 0,
-  // TheQuickBrownFox
-  kUpperCamel = 1,
-  // theQuickBrownFox
-  kLowerCamel = 2,
-  // the_quick_brown_fox
-  kSnake = 3,
-  // THE_QUICK_BROWN_FOX
-  kScreamingSnake = 4,
-  // THEQUICKBROWNFOX
-  kAllUpper = 5,
-  // thequickbrownfox
-  kAllLower = 6,
-  // the-quick-brown-fox
-  kDasher = 7,
-  // THEQuiCKBr_ownFox (or whatever you want, we won't change it)
-  kKeep = 8,
-  // the_quick_brown_fox123 (as opposed to the_quick_brown_fox_123)
-  kSnake2 = 9,
-};
-
-// Convert the `input` string of case `input_case` to the specified
-// `output_case`.
-std::string ConvertCase(const std::string& input, Case output_case,
-                        Case input_case = Case::kSnake);
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_UTIL_H_
diff --git a/external/flatbuffers/include/flatbuffers/vector.h b/external/flatbuffers/include/flatbuffers/vector.h
deleted file mode 100644
index 759a9269..00000000
--- a/external/flatbuffers/include/flatbuffers/vector.h
+++ /dev/null
@@ -1,455 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_VECTOR_H_
-#define FLATBUFFERS_VECTOR_H_
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/buffer.h"
-#include "flatbuffers/stl_emulation.h"
-
-namespace flatbuffers {
-
-struct String;
-
-// An STL compatible iterator implementation for Vector below, effectively
-// calling Get() for every element.
-template <typename T, typename IT, typename Data = uint8_t*,
-          typename SizeT = uoffset_t>
-struct VectorIterator {
-  typedef std::random_access_iterator_tag iterator_category;
-  typedef IT value_type;
-  typedef ptrdiff_t difference_type;
-  typedef IT* pointer;
-  typedef IT& reference;
-
-  static const SizeT element_stride = IndirectHelper<T>::element_stride;
-
-  VectorIterator(Data data, SizeT i) : data_(data + element_stride * i) {}
-  VectorIterator(const VectorIterator& other) : data_(other.data_) {}
-  VectorIterator() : data_(nullptr) {}
-
-  VectorIterator& operator=(const VectorIterator& other) {
-    data_ = other.data_;
-    return *this;
-  }
-
-  VectorIterator& operator=(VectorIterator&& other) {
-    data_ = other.data_;
-    return *this;
-  }
-
-  bool operator==(const VectorIterator& other) const {
-    return data_ == other.data_;
-  }
-
-  bool operator!=(const VectorIterator& other) const {
-    return data_ != other.data_;
-  }
-
-  bool operator<(const VectorIterator& other) const {
-    return data_ < other.data_;
-  }
-
-  bool operator>(const VectorIterator& other) const {
-    return data_ > other.data_;
-  }
-
-  bool operator<=(const VectorIterator& other) const {
-    return !(data_ > other.data_);
-  }
-
-  bool operator>=(const VectorIterator& other) const {
-    return !(data_ < other.data_);
-  }
-
-  difference_type operator-(const VectorIterator& other) const {
-    return (data_ - other.data_) / element_stride;
-  }
-
-  // Note: return type is incompatible with the standard
-  // `reference operator*()`.
-  IT operator*() const { return IndirectHelper<T>::Read(data_, 0); }
-
-  // Note: return type is incompatible with the standard
-  // `pointer operator->()`.
-  IT operator->() const { return IndirectHelper<T>::Read(data_, 0); }
-
-  VectorIterator& operator++() {
-    data_ += element_stride;
-    return *this;
-  }
-
-  VectorIterator operator++(int) {
-    VectorIterator temp(data_, 0);
-    data_ += element_stride;
-    return temp;
-  }
-
-  VectorIterator operator+(const SizeT& offset) const {
-    return VectorIterator(data_ + offset * element_stride, 0);
-  }
-
-  VectorIterator& operator+=(const SizeT& offset) {
-    data_ += offset * element_stride;
-    return *this;
-  }
-
-  VectorIterator& operator--() {
-    data_ -= element_stride;
-    return *this;
-  }
-
-  VectorIterator operator--(int) {
-    VectorIterator temp(data_, 0);
-    data_ -= element_stride;
-    return temp;
-  }
-
-  VectorIterator operator-(const SizeT& offset) const {
-    return VectorIterator(data_ - offset * element_stride, 0);
-  }
-
-  VectorIterator& operator-=(const SizeT& offset) {
-    data_ -= offset * element_stride;
-    return *this;
-  }
-
- private:
-  Data data_;
-};
-
-template <typename T, typename IT, typename SizeT = uoffset_t>
-using VectorConstIterator = VectorIterator<T, IT, const uint8_t*, SizeT>;
-
-template <typename Iterator>
-struct VectorReverseIterator : public std::reverse_iterator<Iterator> {
-  explicit VectorReverseIterator(Iterator iter)
-      : std::reverse_iterator<Iterator>(iter) {}
-
-  // Note: return type is incompatible with the standard
-  // `reference operator*()`.
-  typename Iterator::value_type operator*() const {
-    auto tmp = std::reverse_iterator<Iterator>::current;
-    return *--tmp;
-  }
-
-  // Note: return type is incompatible with the standard
-  // `pointer operator->()`.
-  typename Iterator::value_type operator->() const {
-    auto tmp = std::reverse_iterator<Iterator>::current;
-    return *--tmp;
-  }
-};
-
-// This is used as a helper type for accessing vectors.
-// Vector::data() assumes the vector elements start after the length field.
-template <typename T, typename SizeT = uoffset_t>
-class Vector {
- public:
-  typedef VectorIterator<T, typename IndirectHelper<T>::mutable_return_type,
-                         uint8_t*, SizeT>
-      iterator;
-  typedef VectorConstIterator<T, typename IndirectHelper<T>::return_type, SizeT>
-      const_iterator;
-  typedef VectorReverseIterator<iterator> reverse_iterator;
-  typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
-
-  typedef typename flatbuffers::bool_constant<flatbuffers::is_scalar<T>::value>
-      scalar_tag;
-
-  static FLATBUFFERS_CONSTEXPR bool is_span_observable =
-      scalar_tag::value && !std::is_pointer<T>::value &&
-      (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1);
-
-  SizeT size() const { return EndianScalar(length_); }
-
-  // Returns true if the vector is empty.
-  //
-  // This just provides another standardized method that is expected of vectors.
-  bool empty() const { return size() == 0; }
-
-  // Deprecated: use size(). Here for backwards compatibility.
-  FLATBUFFERS_ATTRIBUTE([[deprecated("use size() instead")]])
-  SizeT Length() const { return size(); }
-
-  typedef SizeT size_type;
-  typedef typename IndirectHelper<T>::return_type return_type;
-  typedef typename IndirectHelper<T>::mutable_return_type mutable_return_type;
-  typedef return_type value_type;
-
-  return_type Get(SizeT i) const {
-    FLATBUFFERS_ASSERT(i < size());
-    return IndirectHelper<T>::Read(Data(), i);
-  }
-
-  return_type operator[](SizeT i) const { return Get(i); }
-
-  // If this is a Vector of enums, T will be its storage type, not the enum
-  // type. This function makes it convenient to retrieve value with enum
-  // type E.
-  template <typename E>
-  E GetEnum(SizeT i) const {
-    return static_cast<E>(Get(i));
-  }
-
-  // If this a vector of unions, this does the cast for you. There's no check
-  // to make sure this is the right type!
-  template <typename U>
-  const U* GetAs(SizeT i) const {
-    return reinterpret_cast<const U*>(Get(i));
-  }
-
-  // If this a vector of unions, this does the cast for you. There's no check
-  // to make sure this is actually a string!
-  const String* GetAsString(SizeT i) const {
-    return reinterpret_cast<const String*>(Get(i));
-  }
-
-  const void* GetStructFromOffset(size_t o) const {
-    return reinterpret_cast<const void*>(Data() + o);
-  }
-
-  iterator begin() { return iterator(Data(), 0); }
-  const_iterator begin() const { return const_iterator(Data(), 0); }
-
-  iterator end() { return iterator(Data(), size()); }
-  const_iterator end() const { return const_iterator(Data(), size()); }
-
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin());
-  }
-
-  const_iterator cbegin() const { return begin(); }
-
-  const_iterator cend() const { return end(); }
-
-  const_reverse_iterator crbegin() const { return rbegin(); }
-
-  const_reverse_iterator crend() const { return rend(); }
-
-  // Change elements if you have a non-const pointer to this object.
-  // Scalars only. See reflection.h, and the documentation.
-  void Mutate(SizeT i, const T& val) {
-    FLATBUFFERS_ASSERT(i < size());
-    WriteScalar(data() + i, val);
-  }
-
-  // Change an element of a vector of tables (or strings).
-  // "val" points to the new table/string, as you can obtain from
-  // e.g. reflection::AddFlatBuffer().
-  void MutateOffset(SizeT i, const uint8_t* val) {
-    FLATBUFFERS_ASSERT(i < size());
-    static_assert(sizeof(T) == sizeof(SizeT), "Unrelated types");
-    WriteScalar(data() + i,
-                static_cast<SizeT>(val - (Data() + i * sizeof(SizeT))));
-  }
-
-  // Get a mutable pointer to tables/strings inside this vector.
-  mutable_return_type GetMutableObject(SizeT i) const {
-    FLATBUFFERS_ASSERT(i < size());
-    return const_cast<mutable_return_type>(IndirectHelper<T>::Read(Data(), i));
-  }
-
-  // The raw data in little endian format. Use with care.
-  const uint8_t* Data() const {
-    return reinterpret_cast<const uint8_t*>(&length_ + 1);
-  }
-
-  uint8_t* Data() { return reinterpret_cast<uint8_t*>(&length_ + 1); }
-
-  // Similarly, but typed, much like std::vector::data
-  const T* data() const { return reinterpret_cast<const T*>(Data()); }
-  T* data() { return reinterpret_cast<T*>(Data()); }
-
-  template <typename K>
-  return_type LookupByKey(K key) const {
-    void* search_result = std::bsearch(
-        &key, Data(), size(), IndirectHelper<T>::element_stride, KeyCompare<K>);
-
-    if (!search_result) {
-      return nullptr;  // Key not found.
-    }
-
-    const uint8_t* element = reinterpret_cast<const uint8_t*>(search_result);
-
-    return IndirectHelper<T>::Read(element, 0);
-  }
-
-  template <typename K>
-  mutable_return_type MutableLookupByKey(K key) {
-    return const_cast<mutable_return_type>(LookupByKey(key));
-  }
-
- protected:
-  // This class is only used to access pre-existing data. Don't ever
-  // try to construct these manually.
-  Vector();
-
-  SizeT length_;
-
- private:
-  // This class is a pointer. Copying will therefore create an invalid object.
-  // Private and unimplemented copy constructor.
-  Vector(const Vector&);
-  Vector& operator=(const Vector&);
-
-  template <typename K>
-  static int KeyCompare(const void* ap, const void* bp) {
-    const K* key = reinterpret_cast<const K*>(ap);
-    const uint8_t* data = reinterpret_cast<const uint8_t*>(bp);
-    auto table = IndirectHelper<T>::Read(data, 0);
-
-    // std::bsearch compares with the operands transposed, so we negate the
-    // result here.
-    return -table->KeyCompareWithValue(*key);
-  }
-};
-
-template <typename T>
-using Vector64 = Vector<T, uoffset64_t>;
-
-template <class U>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_span(Vector<U>& vec)
-    FLATBUFFERS_NOEXCEPT {
-  static_assert(Vector<U>::is_span_observable,
-                "wrong type U, only LE-scalar, or byte types are allowed");
-  return span<U>(vec.data(), vec.size());
-}
-
-template <class U>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_span(
-    const Vector<U>& vec) FLATBUFFERS_NOEXCEPT {
-  static_assert(Vector<U>::is_span_observable,
-                "wrong type U, only LE-scalar, or byte types are allowed");
-  return span<const U>(vec.data(), vec.size());
-}
-
-template <class U>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<uint8_t> make_bytes_span(
-    Vector<U>& vec) FLATBUFFERS_NOEXCEPT {
-  static_assert(Vector<U>::scalar_tag::value,
-                "wrong type U, only LE-scalar, or byte types are allowed");
-  return span<uint8_t>(vec.Data(), vec.size() * sizeof(U));
-}
-
-template <class U>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const uint8_t> make_bytes_span(
-    const Vector<U>& vec) FLATBUFFERS_NOEXCEPT {
-  static_assert(Vector<U>::scalar_tag::value,
-                "wrong type U, only LE-scalar, or byte types are allowed");
-  return span<const uint8_t>(vec.Data(), vec.size() * sizeof(U));
-}
-
-#if FLATBUFFERS_LITTLEENDIAN
-
-template <class U>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_structs_span(
-    Vector<const U*>& vec) FLATBUFFERS_NOEXCEPT {
-  return span<U>(reinterpret_cast<U*>(vec.data()), vec.size());
-}
-
-template <class U>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_structs_span(
-    const Vector<const U*>& vec) FLATBUFFERS_NOEXCEPT {
-  return span<const U>(reinterpret_cast<const U*>(vec.data()), vec.size());
-}
-
-#endif
-
-// Convenient helper functions to get a span of any vector, regardless
-// of whether it is null or not (the field is not set).
-template <class U>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_span(Vector<U>* ptr)
-    FLATBUFFERS_NOEXCEPT {
-  static_assert(Vector<U>::is_span_observable,
-                "wrong type U, only LE-scalar, or byte types are allowed");
-  return ptr ? make_span(*ptr) : span<U>();
-}
-
-template <class U>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_span(
-    const Vector<U>* ptr) FLATBUFFERS_NOEXCEPT {
-  static_assert(Vector<U>::is_span_observable,
-                "wrong type U, only LE-scalar, or byte types are allowed");
-  return ptr ? make_span(*ptr) : span<const U>();
-}
-
-#if FLATBUFFERS_LITTLEENDIAN
-
-template <class U>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_structs_span(
-    Vector<const U*>* ptr) FLATBUFFERS_NOEXCEPT {
-  return ptr ? make_span(*ptr) : span<U>();
-}
-
-template <class U>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_structs_span(
-    const Vector<const U*>* ptr) FLATBUFFERS_NOEXCEPT {
-  return ptr ? make_span(*ptr) : span<const U>();
-}
-
-#endif
-
-// Represent a vector much like the template above, but in this case we
-// don't know what the element types are (used with reflection.h).
-class VectorOfAny {
- public:
-  uoffset_t size() const { return EndianScalar(length_); }
-
-  const uint8_t* Data() const {
-    return reinterpret_cast<const uint8_t*>(&length_ + 1);
-  }
-  uint8_t* Data() { return reinterpret_cast<uint8_t*>(&length_ + 1); }
-
- protected:
-  VectorOfAny();
-
-  uoffset_t length_;
-
- private:
-  VectorOfAny(const VectorOfAny&);
-  VectorOfAny& operator=(const VectorOfAny&);
-};
-
-template <typename T, typename U>
-Vector<Offset<T>>* VectorCast(Vector<Offset<U>>* ptr) {
-  static_assert(std::is_base_of<T, U>::value, "Unrelated types");
-  return reinterpret_cast<Vector<Offset<T>>*>(ptr);
-}
-
-template <typename T, typename U>
-const Vector<Offset<T>>* VectorCast(const Vector<Offset<U>>* ptr) {
-  static_assert(std::is_base_of<T, U>::value, "Unrelated types");
-  return reinterpret_cast<const Vector<Offset<T>>*>(ptr);
-}
-
-// Convenient helper function to get the length of any vector, regardless
-// of whether it is null or not (the field is not set).
-template <typename T>
-static inline size_t VectorLength(const Vector<T>* v) {
-  return v ? v->size() : 0;
-}
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_VERIFIER_H_
diff --git a/external/flatbuffers/include/flatbuffers/vector_downward.h b/external/flatbuffers/include/flatbuffers/vector_downward.h
deleted file mode 100644
index 3e6da8e9..00000000
--- a/external/flatbuffers/include/flatbuffers/vector_downward.h
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_VECTOR_DOWNWARD_H_
-#define FLATBUFFERS_VECTOR_DOWNWARD_H_
-
-#include <algorithm>
-#include <cstdint>
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/default_allocator.h"
-#include "flatbuffers/detached_buffer.h"
-
-namespace flatbuffers {
-
-// This is a minimal replication of std::vector<uint8_t> functionality,
-// except growing from higher to lower addresses. i.e. push_back() inserts data
-// in the lowest address in the vector.
-// Since this vector leaves the lower part unused, we support a "scratch-pad"
-// that can be stored there for temporary data, to share the allocated space.
-// Essentially, this supports 2 std::vectors in a single buffer.
-template <typename SizeT = uoffset_t>
-class vector_downward {
- public:
-  explicit vector_downward(size_t initial_size, Allocator* allocator,
-                           bool own_allocator, size_t buffer_minalign,
-                           const SizeT max_size = FLATBUFFERS_MAX_BUFFER_SIZE)
-      : allocator_(allocator),
-        own_allocator_(own_allocator),
-        initial_size_(initial_size),
-        max_size_(max_size),
-        buffer_minalign_(buffer_minalign),
-        reserved_(0),
-        size_(0),
-        buf_(nullptr),
-        cur_(nullptr),
-        scratch_(nullptr) {}
-
-  vector_downward(vector_downward&& other) noexcept
-      // clang-format on
-      : allocator_(other.allocator_),
-        own_allocator_(other.own_allocator_),
-        initial_size_(other.initial_size_),
-        max_size_(other.max_size_),
-        buffer_minalign_(other.buffer_minalign_),
-        reserved_(other.reserved_),
-        size_(other.size_),
-        buf_(other.buf_),
-        cur_(other.cur_),
-        scratch_(other.scratch_) {
-    // No change in other.allocator_
-    // No change in other.initial_size_
-    // No change in other.buffer_minalign_
-    other.own_allocator_ = false;
-    other.reserved_ = 0;
-    other.buf_ = nullptr;
-    other.cur_ = nullptr;
-    other.scratch_ = nullptr;
-  }
-
-  vector_downward& operator=(vector_downward&& other) noexcept {
-    // Move construct a temporary and swap idiom
-    vector_downward temp(std::move(other));
-    swap(temp);
-    return *this;
-  }
-
-  ~vector_downward() {
-    clear_buffer();
-    clear_allocator();
-  }
-
-  void reset() {
-    clear_buffer();
-    clear();
-  }
-
-  void clear() {
-    if (buf_) {
-      cur_ = buf_ + reserved_;
-    } else {
-      reserved_ = 0;
-      cur_ = nullptr;
-    }
-    size_ = 0;
-    clear_scratch();
-  }
-
-  void clear_scratch() { scratch_ = buf_; }
-
-  void clear_allocator() {
-    if (own_allocator_ && allocator_) {
-      delete allocator_;
-    }
-    allocator_ = nullptr;
-    own_allocator_ = false;
-  }
-
-  void clear_buffer() {
-    if (buf_) Deallocate(allocator_, buf_, reserved_);
-    buf_ = nullptr;
-  }
-
-  // Relinquish the pointer to the caller.
-  uint8_t* release_raw(size_t& allocated_bytes, size_t& offset) {
-    auto* buf = buf_;
-    allocated_bytes = reserved_;
-    offset = vector_downward::offset();
-
-    // release_raw only relinquishes the buffer ownership.
-    // Does not deallocate or reset the allocator. Destructor will do that.
-    buf_ = nullptr;
-    clear();
-    return buf;
-  }
-
-  // Relinquish the pointer to the caller.
-  DetachedBuffer release() {
-    // allocator ownership (if any) is transferred to DetachedBuffer.
-    DetachedBuffer fb(allocator_, own_allocator_, buf_, reserved_, cur_,
-                      size());
-    if (own_allocator_) {
-      allocator_ = nullptr;
-      own_allocator_ = false;
-    }
-    buf_ = nullptr;
-    clear();
-    return fb;
-  }
-
-  size_t ensure_space(size_t len) {
-    FLATBUFFERS_ASSERT(cur_ >= scratch_ && scratch_ >= buf_);
-    // If the length is larger than the unused part of the buffer, we need to
-    // grow.
-    if (len > unused_buffer_size()) {
-      reallocate(len);
-    }
-    FLATBUFFERS_ASSERT(size() < max_size_);
-    return len;
-  }
-
-  inline uint8_t* make_space(size_t len) {
-    if (len) {
-      ensure_space(len);
-      cur_ -= len;
-      size_ += static_cast<SizeT>(len);
-    }
-    return cur_;
-  }
-
-  // Returns nullptr if using the DefaultAllocator.
-  Allocator* get_custom_allocator() { return allocator_; }
-
-  // The current offset into the buffer.
-  size_t offset() const { return cur_ - buf_; }
-
-  // The total size of the vector (both the buffer and scratch parts).
-  inline SizeT size() const { return size_; }
-
-  // The size of the buffer part of the vector that is currently unused.
-  SizeT unused_buffer_size() const {
-    return static_cast<SizeT>(cur_ - scratch_);
-  }
-
-  // The size of the scratch part of the vector.
-  SizeT scratch_size() const { return static_cast<SizeT>(scratch_ - buf_); }
-
-  size_t capacity() const { return reserved_; }
-
-  uint8_t* data() const {
-    FLATBUFFERS_ASSERT(cur_);
-    return cur_;
-  }
-
-  uint8_t* scratch_data() const {
-    FLATBUFFERS_ASSERT(buf_);
-    return buf_;
-  }
-
-  uint8_t* scratch_end() const {
-    FLATBUFFERS_ASSERT(scratch_);
-    return scratch_;
-  }
-
-  uint8_t* data_at(size_t offset) const { return buf_ + reserved_ - offset; }
-
-  void push(const uint8_t* bytes, size_t num) {
-    if (num > 0) {
-      memcpy(make_space(num), bytes, num);
-    }
-  }
-
-  // Specialized version of push() that avoids memcpy call for small data.
-  template <typename T>
-  void push_small(const T& little_endian_t) {
-    make_space(sizeof(T));
-    *reinterpret_cast<T*>(cur_) = little_endian_t;
-  }
-
-  template <typename T>
-  void scratch_push_small(const T& t) {
-    ensure_space(sizeof(T));
-    *reinterpret_cast<T*>(scratch_) = t;
-    scratch_ += sizeof(T);
-  }
-
-  // fill() is most frequently called with small byte counts (<= 4),
-  // which is why we're using loops rather than calling memset.
-  void fill(size_t zero_pad_bytes) {
-    make_space(zero_pad_bytes);
-    for (size_t i = 0; i < zero_pad_bytes; i++) cur_[i] = 0;
-  }
-
-  // Version for when we know the size is larger.
-  // Precondition: zero_pad_bytes > 0
-  void fill_big(size_t zero_pad_bytes) {
-    memset(make_space(zero_pad_bytes), 0, zero_pad_bytes);
-  }
-
-  void pop(size_t bytes_to_remove) {
-    cur_ += bytes_to_remove;
-    size_ -= static_cast<SizeT>(bytes_to_remove);
-  }
-
-  void scratch_pop(size_t bytes_to_remove) { scratch_ -= bytes_to_remove; }
-
-  void swap(vector_downward& other) {
-    using std::swap;
-    swap(allocator_, other.allocator_);
-    swap(own_allocator_, other.own_allocator_);
-    swap(initial_size_, other.initial_size_);
-    swap(buffer_minalign_, other.buffer_minalign_);
-    swap(reserved_, other.reserved_);
-    swap(size_, other.size_);
-    swap(max_size_, other.max_size_);
-    swap(buf_, other.buf_);
-    swap(cur_, other.cur_);
-    swap(scratch_, other.scratch_);
-  }
-
-  void swap_allocator(vector_downward& other) {
-    using std::swap;
-    swap(allocator_, other.allocator_);
-    swap(own_allocator_, other.own_allocator_);
-  }
-
- private:
-  // You shouldn't really be copying instances of this class.
-  FLATBUFFERS_DELETE_FUNC(vector_downward(const vector_downward&));
-  FLATBUFFERS_DELETE_FUNC(vector_downward& operator=(const vector_downward&));
-
-  Allocator* allocator_;
-  bool own_allocator_;
-  size_t initial_size_;
-
-  // The maximum size the vector can be.
-  SizeT max_size_;
-  size_t buffer_minalign_;
-  size_t reserved_;
-  SizeT size_;
-  uint8_t* buf_;
-  uint8_t* cur_;  // Points at location between empty (below) and used (above).
-  uint8_t* scratch_;  // Points to the end of the scratchpad in use.
-
-  void reallocate(size_t len) {
-    auto old_reserved = reserved_;
-    auto old_size = size();
-    auto old_scratch_size = scratch_size();
-    reserved_ +=
-        (std::max)(len, old_reserved ? old_reserved / 2 : initial_size_);
-    reserved_ = (reserved_ + buffer_minalign_ - 1) & ~(buffer_minalign_ - 1);
-    if (buf_) {
-      buf_ = ReallocateDownward(allocator_, buf_, old_reserved, reserved_,
-                                old_size, old_scratch_size);
-    } else {
-      buf_ = Allocate(allocator_, reserved_);
-    }
-    cur_ = buf_ + reserved_ - old_size;
-    scratch_ = buf_ + old_scratch_size;
-  }
-};
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_VECTOR_DOWNWARD_H_
diff --git a/external/flatbuffers/include/flatbuffers/verifier.h b/external/flatbuffers/include/flatbuffers/verifier.h
deleted file mode 100644
index a0b79359..00000000
--- a/external/flatbuffers/include/flatbuffers/verifier.h
+++ /dev/null
@@ -1,370 +0,0 @@
-/*
- * Copyright 2021 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef FLATBUFFERS_VERIFIER_H_
-#define FLATBUFFERS_VERIFIER_H_
-
-#include "flatbuffers/base.h"
-#include "flatbuffers/vector.h"
-
-namespace flatbuffers {
-
-// Helper class to verify the integrity of a FlatBuffer
-template <bool TrackVerifierBufferSize>
-class VerifierTemplate FLATBUFFERS_FINAL_CLASS {
- public:
-  struct Options {
-    // The maximum nesting of tables and vectors before we call it invalid.
-    uoffset_t max_depth = 64;
-    // The maximum number of tables we will verify before we call it invalid.
-    uoffset_t max_tables = 1000000;
-    // If true, verify all data is aligned.
-    bool check_alignment = true;
-    // If true, run verifier on nested flatbuffers
-    bool check_nested_flatbuffers = true;
-    // The maximum size of a buffer.
-    size_t max_size = FLATBUFFERS_MAX_BUFFER_SIZE;
-    // Use assertions to check for errors.
-    bool assert = false;
-  };
-
-  explicit VerifierTemplate(const uint8_t* const buf, const size_t buf_len,
-                            const Options& opts)
-      : buf_(buf), size_(buf_len), opts_(opts) {
-    FLATBUFFERS_ASSERT(size_ < opts.max_size);
-  }
-
-  // Deprecated API, please construct with VerifierTemplate::Options.
-  VerifierTemplate(const uint8_t* const buf, const size_t buf_len,
-                   const uoffset_t max_depth = 64,
-                   const uoffset_t max_tables = 1000000,
-                   const bool check_alignment = true)
-      : VerifierTemplate(buf, buf_len, [&] {
-          Options opts;
-          opts.max_depth = max_depth;
-          opts.max_tables = max_tables;
-          opts.check_alignment = check_alignment;
-          return opts;
-        }()) {}
-
-  // Central location where any verification failures register.
-  bool Check(const bool ok) const {
-    // clang-format off
-    #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
-      if (opts_.assert) { FLATBUFFERS_ASSERT(ok); }
-    #endif
-    // clang-format on
-    if (TrackVerifierBufferSize) {
-      if (!ok) {
-        upper_bound_ = 0;
-      }
-    }
-    return ok;
-  }
-
-  // Verify any range within the buffer.
-  bool Verify(const size_t elem, const size_t elem_len) const {
-    if (TrackVerifierBufferSize) {
-      auto upper_bound = elem + elem_len;
-      if (upper_bound_ < upper_bound) {
-        upper_bound_ = upper_bound;
-      }
-    }
-    return Check(elem_len < size_ && elem <= size_ - elem_len);
-  }
-
-  bool VerifyAlignment(const size_t elem, const size_t align) const {
-    return Check((elem & (align - 1)) == 0 || !opts_.check_alignment);
-  }
-
-  // Verify a range indicated by sizeof(T).
-  template <typename T>
-  bool Verify(const size_t elem) const {
-    return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
-  }
-
-  bool VerifyFromPointer(const uint8_t* const p, const size_t len) {
-    return Verify(static_cast<size_t>(p - buf_), len);
-  }
-
-  // Verify relative to a known-good base pointer.
-  bool VerifyFieldStruct(const uint8_t* const base, const voffset_t elem_off,
-                         const size_t elem_len, const size_t align) const {
-    const auto f = static_cast<size_t>(base - buf_) + elem_off;
-    return VerifyAlignment(f, align) && Verify(f, elem_len);
-  }
-
-  template <typename T>
-  bool VerifyField(const uint8_t* const base, const voffset_t elem_off,
-                   const size_t align) const {
-    const auto f = static_cast<size_t>(base - buf_) + elem_off;
-    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
-  }
-
-  // Verify a pointer (may be NULL) of a table type.
-  template <typename T>
-  bool VerifyTable(const T* const table) {
-    return !table || table->Verify(*this);
-  }
-
-  // Verify a pointer (may be NULL) of any vector type.
-  template <int&..., typename T, typename LenT>
-  bool VerifyVector(const Vector<T, LenT>* const vec) const {
-    return !vec || VerifyVectorOrString<LenT>(
-                       reinterpret_cast<const uint8_t*>(vec), sizeof(T));
-  }
-
-  // Verify a pointer (may be NULL) of a vector to struct.
-  template <int&..., typename T, typename LenT>
-  bool VerifyVector(const Vector<const T*, LenT>* const vec) const {
-    return VerifyVector(reinterpret_cast<const Vector<T, LenT>*>(vec));
-  }
-
-  // Verify a pointer (may be NULL) to string.
-  bool VerifyString(const String* const str) const {
-    size_t end;
-    return !str || (VerifyVectorOrString<uoffset_t>(
-                        reinterpret_cast<const uint8_t*>(str), 1, &end) &&
-                    Verify(end, 1) &&           // Must have terminator
-                    Check(buf_[end] == '\0'));  // Terminating byte must be 0.
-  }
-
-  // Common code between vectors and strings.
-  template <typename LenT = uoffset_t>
-  bool VerifyVectorOrString(const uint8_t* const vec, const size_t elem_size,
-                            size_t* const end = nullptr) const {
-    const auto vec_offset = static_cast<size_t>(vec - buf_);
-    // Check we can read the size field.
-    if (!Verify<LenT>(vec_offset)) return false;
-    // Check the whole array. If this is a string, the byte past the array must
-    // be 0.
-    const LenT size = ReadScalar<LenT>(vec);
-    const auto max_elems = opts_.max_size / elem_size;
-    if (!Check(size < max_elems))
-      return false;  // Protect against byte_size overflowing.
-    const auto byte_size = sizeof(LenT) + elem_size * size;
-    if (end) *end = vec_offset + byte_size;
-    return Verify(vec_offset, byte_size);
-  }
-
-  // Special case for string contents, after the above has been called.
-  bool VerifyVectorOfStrings(const Vector<Offset<String>>* const vec) const {
-    if (vec) {
-      for (uoffset_t i = 0; i < vec->size(); i++) {
-        if (!VerifyString(vec->Get(i))) return false;
-      }
-    }
-    return true;
-  }
-
-  // Special case for table contents, after the above has been called.
-  template <typename T>
-  bool VerifyVectorOfTables(const Vector<Offset<T>>* const vec) {
-    if (vec) {
-      for (uoffset_t i = 0; i < vec->size(); i++) {
-        if (!vec->Get(i)->Verify(*this)) return false;
-      }
-    }
-    return true;
-  }
-
-  FLATBUFFERS_SUPPRESS_UBSAN("unsigned-integer-overflow")
-  bool VerifyTableStart(const uint8_t* const table) {
-    // Check the vtable offset.
-    const auto tableo = static_cast<size_t>(table - buf_);
-    if (!Verify<soffset_t>(tableo)) return false;
-    // This offset may be signed, but doing the subtraction unsigned always
-    // gives the result we want.
-    const auto vtableo =
-        tableo - static_cast<size_t>(ReadScalar<soffset_t>(table));
-    // Check the vtable size field, then check vtable fits in its entirety.
-    if (!(VerifyComplexity() && Verify<voffset_t>(vtableo) &&
-          VerifyAlignment(ReadScalar<voffset_t>(buf_ + vtableo),
-                          sizeof(voffset_t))))
-      return false;
-    const auto vsize = ReadScalar<voffset_t>(buf_ + vtableo);
-    return Check((vsize & 1) == 0) && Verify(vtableo, vsize);
-  }
-
-  template <typename T>
-  bool VerifyBufferFromStart(const char* const identifier, const size_t start) {
-    // Buffers have to be of some size to be valid. The reason it is a runtime
-    // check instead of static_assert, is that nested flatbuffers go through
-    // this call and their size is determined at runtime.
-    if (!Check(size_ >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
-
-    // If an identifier is provided, check that we have a buffer
-    if (identifier && !Check((size_ >= 2 * sizeof(flatbuffers::uoffset_t) &&
-                              BufferHasIdentifier(buf_ + start, identifier)))) {
-      return false;
-    }
-
-    // Call T::Verify, which must be in the generated code for this type.
-    const auto o = VerifyOffset<uoffset_t>(start);
-    if (!Check(o != 0)) return false;
-    if (!(reinterpret_cast<const T*>(buf_ + start + o)->Verify(*this))) {
-      return false;
-    }
-    if (TrackVerifierBufferSize) {
-      if (GetComputedSize() == 0) return false;
-    }
-    return true;
-  }
-
-  template <typename T, int&..., typename SizeT>
-  bool VerifyNestedFlatBuffer(const Vector<uint8_t, SizeT>* const buf,
-                              const char* const identifier) {
-    // Caller opted out of this.
-    if (!opts_.check_nested_flatbuffers) return true;
-
-    // An empty buffer is OK as it indicates not present.
-    if (!buf) return true;
-
-    // If there is a nested buffer, it must be greater than the min size.
-    if (!Check(buf->size() >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
-
-    VerifierTemplate<TrackVerifierBufferSize> nested_verifier(
-        buf->data(), buf->size(), opts_);
-    return nested_verifier.VerifyBuffer<T>(identifier);
-  }
-
-  // Verify this whole buffer, starting with root type T.
-  template <typename T>
-  bool VerifyBuffer() {
-    return VerifyBuffer<T>(nullptr);
-  }
-
-  template <typename T>
-  bool VerifyBuffer(const char* const identifier) {
-    return VerifyBufferFromStart<T>(identifier, 0);
-  }
-
-  template <typename T, typename SizeT = uoffset_t>
-  bool VerifySizePrefixedBuffer(const char* const identifier) {
-    return Verify<SizeT>(0U) &&
-           // Ensure the prefixed size is within the bounds of the provided
-           // length.
-           Check(ReadScalar<SizeT>(buf_) + sizeof(SizeT) <= size_) &&
-           VerifyBufferFromStart<T>(identifier, sizeof(SizeT));
-  }
-
-  template <typename OffsetT = uoffset_t, typename SOffsetT = soffset_t>
-  size_t VerifyOffset(const size_t start) const {
-    if (!Verify<OffsetT>(start)) return 0;
-    const auto o = ReadScalar<OffsetT>(buf_ + start);
-    // May not point to itself.
-    if (!Check(o != 0)) return 0;
-    // Can't wrap around larger than the max size.
-    if (!Check(static_cast<SOffsetT>(o) >= 0)) return 0;
-    // Must be inside the buffer to create a pointer from it (pointer outside
-    // buffer is UB).
-    if (!Verify(start + o, 1)) return 0;
-    return o;
-  }
-
-  template <typename OffsetT = uoffset_t>
-  size_t VerifyOffset(const uint8_t* const base, const voffset_t start) const {
-    return VerifyOffset<OffsetT>(static_cast<size_t>(base - buf_) + start);
-  }
-
-  // Called at the start of a table to increase counters measuring data
-  // structure depth and amount, and possibly bails out with false if limits set
-  // by the constructor have been hit. Needs to be balanced with EndTable().
-  bool VerifyComplexity() {
-    depth_++;
-    num_tables_++;
-    return Check(depth_ <= opts_.max_depth && num_tables_ <= opts_.max_tables);
-  }
-
-  // Called at the end of a table to pop the depth count.
-  bool EndTable() {
-    depth_--;
-    return true;
-  }
-
-  // Returns the message size in bytes.
-  //
-  // This should only be called after first calling VerifyBuffer or
-  // VerifySizePrefixedBuffer.
-  //
-  // This method should only be called for VerifierTemplate instances
-  // where the TrackVerifierBufferSize template parameter is true,
-  // i.e. for SizeVerifier.  For instances where TrackVerifierBufferSize
-  // is false, this fails at runtime or returns zero.
-  size_t GetComputedSize() const {
-    if (TrackVerifierBufferSize) {
-      uintptr_t size = upper_bound_;
-      // Align the size to uoffset_t
-      size = (size - 1 + sizeof(uoffset_t)) & ~(sizeof(uoffset_t) - 1);
-      return (size > size_) ? 0 : size;
-    }
-    // Must use SizeVerifier, or (deprecated) turn on
-    // FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE, for this to work.
-    (void)upper_bound_;
-    FLATBUFFERS_ASSERT(false);
-    return 0;
-  }
-
-  std::vector<uint8_t>* GetFlexReuseTracker() { return flex_reuse_tracker_; }
-
-  void SetFlexReuseTracker(std::vector<uint8_t>* const rt) {
-    flex_reuse_tracker_ = rt;
-  }
-
- private:
-  const uint8_t* buf_;
-  const size_t size_;
-  const Options opts_;
-
-  mutable size_t upper_bound_ = 0;
-
-  uoffset_t depth_ = 0;
-  uoffset_t num_tables_ = 0;
-  std::vector<uint8_t>* flex_reuse_tracker_ = nullptr;
-};
-
-// Specialization for 64-bit offsets.
-template <>
-template <>
-inline size_t VerifierTemplate<false>::VerifyOffset<uoffset64_t>(
-    const size_t start) const {
-  return VerifyOffset<uoffset64_t, soffset64_t>(start);
-}
-template <>
-template <>
-inline size_t VerifierTemplate<true>::VerifyOffset<uoffset64_t>(
-    const size_t start) const {
-  return VerifyOffset<uoffset64_t, soffset64_t>(start);
-}
-
-// Instance of VerifierTemplate that supports GetComputedSize().
-using SizeVerifier = VerifierTemplate</*TrackVerifierBufferSize = */ true>;
-
-// The FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE build configuration macro is
-// deprecated, and should not be defined, since it is easy to misuse in ways
-// that result in ODR violations. Rather than using Verifier and defining
-// FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE, please use SizeVerifier instead.
-#ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE  // Deprecated, see above.
-using Verifier = SizeVerifier;
-#else
-// Instance of VerifierTemplate that is slightly faster, but does not
-// support GetComputedSize().
-using Verifier = VerifierTemplate</*TrackVerifierBufferSize = */ false>;
-#endif
-
-}  // namespace flatbuffers
-
-#endif  // FLATBUFFERS_VERIFIER_H_
diff --git a/source/LottieFlatbuffer/README.md b/source/LottieFlatbuffer/README.md
index 33221b7a..49f07db9 100644
--- a/source/LottieFlatbuffer/README.md
+++ b/source/LottieFlatbuffer/README.md
@@ -57,16 +57,18 @@ a buffer may carry meaning in fields the reader does not look at.
 installed. After changing the schema:
 
 ```powershell
-./build/RegenerateFlatbuffers.ps1 `
+msbuild .\source\LottieRuntime\LottieRuntimeTool.vcxproj /t:RestoreFlatBuffers /p:Platform=x64
+.\build\RegenerateFlatbuffers.ps1 `
     -CSharpFlatc <path to 25.2.10 flatc> `
-    -CppFlatc <path to 25.12.19 flatc.exe> `
-    -CppSource <path to extracted pinned FlatBuffers source>
+    -CppFlatc .\vcpkg_installed\x64-windows\tools\flatbuffers\flatc.exe
 ```
 
 The C# `flatc` version **must** match the `Google.FlatBuffers` NuGet package
-version. The C++ `flatc` and headers must match each other. The script validates
-both versions and, when `-CppSource` is supplied, refreshes the vendored C++
-headers and license.
+version. The C++ `flatc` and headers must match the FlatBuffers override in
+`vcpkg.json`. The script validates both compiler versions before regenerating.
+For an ARM64 host or a custom install root, pass the host's restored `flatc.exe`
+as `-CppFlatc`. Updating the C++ dependency requires updating the manifest and
+regenerating the C++ binding together.
 
 ## Consumers
 
diff --git a/source/LottieRuntime/LottieRuntimeTool.vcxproj b/source/LottieRuntime/LottieRuntimeTool.vcxproj
index ac309879..bc407905 100644
--- a/source/LottieRuntime/LottieRuntimeTool.vcxproj
+++ b/source/LottieRuntime/LottieRuntimeTool.vcxproj
@@ -28,13 +28,12 @@
     <CharacterSet>Unicode</CharacterSet>
     <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
     <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
-    <FlatBuffersIncludeDirectory
-        Condition="'$(FlatBuffersIncludeDirectory)'=='' and Exists('$(MSBuildThisFileDirectory)..\..\external\flatbuffers\include')">$(MSBuildThisFileDirectory)..\..\external\flatbuffers\include</FlatBuffersIncludeDirectory>
-    <FlatBuffersIncludeDirectory
-        Condition="'$(FlatBuffersIncludeDirectory)'==''">$(MSBuildThisFileDirectory)flatbuffers\include</FlatBuffersIncludeDirectory>
+    <VcpkgEnabled>false</VcpkgEnabled>
+    <FlatBuffersRestoreBeforeTargets>PrepareForBuild</FlatBuffersRestoreBeforeTargets>
   </PropertyGroup>
 
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="..\..\build\FlatBuffers.targets" />
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 
   <PropertyGroup>
diff --git a/source/LottieRuntime/README.md b/source/LottieRuntime/README.md
index b19aa14f..4b81175f 100644
--- a/source/LottieRuntime/README.md
+++ b/source/LottieRuntime/README.md
@@ -38,8 +38,9 @@ WinUI 3 builder when that projection provides the APIs required by the variant.
 ## Incorporating the reader
 
 Add `LottieRuntime.cpp` to the native project, define the matching projection
-flag, and add `LottieRuntime/` and `LottieRuntime/flatbuffers/include/` to its
-include paths. Build as C++20 and link:
+flag, and add `source\LottieRuntime` and the include directory from the vcpkg
+`flatbuffers` port to its include paths. The checked-in C++ binding requires
+FlatBuffers **25.12.19**. Build as C++20 and link:
 
 ```text
 d2d1.lib
@@ -246,6 +247,55 @@ throws `winrt::hresult_not_implemented`.
 `LottieRuntimeTool.vcxproj` builds `LottieRuntime.exe`, a WinUI 2 validation and
 inspection harness that compiles the reader directly.
 
+MSBuild restores the `flatbuffers` port from the root `vcpkg.json` before native
+compilation. The manifest pins the registry baseline and FlatBuffers version.
+Headers, tools, and the upstream license are restored under `vcpkg_installed`;
+the repository does not carry a copy of the FlatBuffers headers.
+
+The build selects vcpkg in this order: `FlatBuffersVcpkgRoot`, `VcpkgRoot`,
+`VCPKG_ROOT`, Visual Studio's bundled `VC\vcpkg`, then a repo-local `.vcpkg`
+checkout. If none is installed, the first native build fetches and bootstraps
+the repo-local copy at the manifest's baseline. Git, PowerShell, the MSVC C++
+tools, and network access are required for that first restore. Subsequent
+builds reuse installed packages and vcpkg's binary cache.
+
+The restore runs vcpkg explicitly; `vcpkg integrate install` is unnecessary.
+User-wide vcpkg auto-linking is disabled for this header-only consumer. Managed
+builds do not restore vcpkg dependencies. Packing `LottieGen` also restores the
+port to include the native headers and license. IDE design-time builds skip restore.
+
+Defaults are `x64-windows` for x64 and `arm64-windows` for ARM64, with native-host
+`flatc` installed through the port's host dependency. Override
+`FlatBuffersVcpkgTriplet`, `FlatBuffersVcpkgHostTriplet`, or
+`FlatBuffersVcpkgInstalledDir` when using a different layout.
+
+An explicit `/p:FlatBuffersIncludeDirectory=C:\deps\flatbuffers\include`
+skips vcpkg discovery and restore. That directory must contain FlatBuffers
+25.12.19 headers; the generated binding checks the version at compile time.
+An explicitly selected vcpkg root without `vcpkg.exe` is an error.
+
+### Package layout and private FlatBuffers versions
+
+The `LottieGen` NuGet package contains `LottieRuntime\lottie_comp.fbs`, the native
+`.cpp` files under `LottieRuntime`, and all headers under `inc\lottiecomp`:
+`LottieRuntime.h`, `LottieVisualSource.h`, `Generated\lottie_comp_generated.h`,
+and `flatbuffers\*.h`. The port's upstream license is included as
+`LottieRuntime\flatbuffers.LICENSE.txt`. Add `inc\lottiecomp` to the compiler's
+include paths when using the packaged reader.
+
+To use a private FlatBuffers version, regenerate the binding with that version's
+`flatc.exe` and compile against its matching headers. From the extracted package
+root:
+
+```powershell
+& C:\deps\flatbuffers\flatc.exe --cpp --scoped-enums -o .\inc\lottiecomp\Generated .\LottieRuntime\lottie_comp.fbs
+```
+
+Put the private FlatBuffers include directory before `inc\lottiecomp` in the
+compiler's include search order, or replace `inc\lottiecomp\flatbuffers` with
+that version's headers. The generated binding's version assertion remains in
+force. Keep the schema and generator options unchanged to preserve the format.
+
 ```powershell
 & "C:\Program Files\Microsoft Visual Studio\18\Professional\Common7\Tools\Launch-VsDevShell.ps1" -SkipAutomaticLocation
 msbuild .\source\LottieRuntime\LottieRuntimeTool.vcxproj /p:Platform=x64 /p:Configuration=Release
@@ -273,15 +323,16 @@ metadata, buffer verification, the legacy no-metadata contract, and theme-cache
 identity, including a child's expression referencing its not-yet-initialized
 parent's owned properties, image/brush cache identity, image reuse across new
 trees, and invalid image-cache descriptors. It uses the existing generated schema
-and vendored FlatBuffers, without an additional test framework. The harness initializes XAML
+and vcpkg's FlatBuffers headers, without an additional test framework. The harness initializes XAML
 on its dispatcher thread and uses its host visual's compositor to exercise image
 assets through `LoadedImageSurface`; its manifest declares the Windows version
 required for desktop XAML hosting.
 From an x64 Visual Studio Developer Command Prompt at the repository root:
 
 ```cmd
+msbuild source\LottieRuntime\LottieRuntimeTool.vcxproj /t:RestoreFlatBuffers /p:Platform=x64
 mkdir tests\LottieRuntime.Tests\bin
-cl /nologo /std:c++20 /EHsc /W4 /WX /DWIN32_LEAN_AND_MEAN /DNOMINMAX /DLOTTIE_RUNTIME_WINUI2 /Iexternal\flatbuffers\include tests\LottieRuntime.Tests\MetadataTests.cpp /Fotests\LottieRuntime.Tests\bin\MetadataTests.obj /Fetests\LottieRuntime.Tests\bin\MetadataTests.exe /link /MANIFEST:EMBED /MANIFESTINPUT:tests\LottieRuntime.Tests\MetadataTests.manifest CoreMessaging.lib d2d1.lib dxguid.lib ole32.lib shcore.lib shlwapi.lib windowsapp.lib
+cl /nologo /std:c++20 /EHsc /W4 /WX /DWIN32_LEAN_AND_MEAN /DNOMINMAX /DLOTTIE_RUNTIME_WINUI2 /Ivcpkg_installed\x64-windows\include tests\LottieRuntime.Tests\MetadataTests.cpp /Fotests\LottieRuntime.Tests\bin\MetadataTests.obj /Fetests\LottieRuntime.Tests\bin\MetadataTests.exe /link /MANIFEST:EMBED /MANIFESTINPUT:tests\LottieRuntime.Tests\MetadataTests.manifest CoreMessaging.lib d2d1.lib dxguid.lib ole32.lib shcore.lib shlwapi.lib windowsapp.lib
 tests\LottieRuntime.Tests\bin\MetadataTests.exe
 ```
 
@@ -313,8 +364,9 @@ with cppwinrt from the `Microsoft.UI.Xaml` 2.8 and `Microsoft.Web.WebView2`
 NuGet packages (substitute their local paths):
 
 ```cmd
+msbuild source\LottieRuntime\LottieRuntimeTool.vcxproj /t:RestoreFlatBuffers /p:Platform=x64
 cppwinrt.exe -base -in sdk+ -in <Microsoft.UI.Xaml>\lib\uap10.0\Microsoft.UI.Xaml.winmd -in <Microsoft.Web.WebView2>\lib\Microsoft.Web.WebView2.Core.winmd -out tests\LottieRuntime.Tests\bin\mux
 mkdir tests\LottieRuntime.Tests\bin\vst
-cl /nologo /std:c++20 /EHsc /W4 /WX /bigobj /DWIN32_LEAN_AND_MEAN /DNOMINMAX /DLOTTIE_RUNTIME_WINUI2 /Itests\LottieRuntime.Tests\bin\mux /Iexternal\flatbuffers\include /Isource\LottieRuntime tests\LottieRuntime.Tests\VisualSourceTests.cpp source\LottieRuntime\LottieRuntime.cpp /Fotests\LottieRuntime.Tests\bin\vst\ /Fetests\LottieRuntime.Tests\bin\VisualSourceTests.exe /link /MANIFEST:EMBED /MANIFESTINPUT:tests\LottieRuntime.Tests\MetadataTests.manifest CoreMessaging.lib d2d1.lib dxguid.lib ole32.lib shcore.lib shlwapi.lib windowsapp.lib
+cl /nologo /std:c++20 /EHsc /W4 /WX /bigobj /DWIN32_LEAN_AND_MEAN /DNOMINMAX /DLOTTIE_RUNTIME_WINUI2 /Itests\LottieRuntime.Tests\bin\mux /Ivcpkg_installed\x64-windows\include /Isource\LottieRuntime tests\LottieRuntime.Tests\VisualSourceTests.cpp source\LottieRuntime\LottieRuntime.cpp /Fotests\LottieRuntime.Tests\bin\vst\ /Fetests\LottieRuntime.Tests\bin\VisualSourceTests.exe /link /MANIFEST:EMBED /MANIFESTINPUT:tests\LottieRuntime.Tests\MetadataTests.manifest CoreMessaging.lib d2d1.lib dxguid.lib ole32.lib shcore.lib shlwapi.lib windowsapp.lib
 tests\LottieRuntime.Tests\bin\VisualSourceTests.exe Animation.lcomp
 ```
diff --git a/tests/LottieRuntime.Tests/PackageTests.ps1 b/tests/LottieRuntime.Tests/PackageTests.ps1
new file mode 100644
index 00000000..a8af683e
--- /dev/null
+++ b/tests/LottieRuntime.Tests/PackageTests.ps1
@@ -0,0 +1,71 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)]
+    [string]$PackagePath,
+
+    [string]$FlatBuffersIncludeDirectory = (Join-Path $PSScriptRoot "..\..\vcpkg_installed\x64-windows\include")
+)
+
+$ErrorActionPreference = "Stop"
+Add-Type -AssemblyName System.IO.Compression.FileSystem
+$archive = [IO.Compression.ZipFile]::OpenRead((Resolve-Path $PackagePath))
+try {
+    $required = @(
+        "LottieRuntime/lottie_comp.fbs",
+        "LottieRuntime/LottieRuntime.cpp",
+        "LottieRuntime/LottieVisualSource.cpp",
+        "LottieRuntime/flatbuffers.LICENSE.txt",
+        "inc/lottiecomp/LottieRuntime.h",
+        "inc/lottiecomp/LottieVisualSource.h",
+        "inc/lottiecomp/Generated/lottie_comp_generated.h",
+        "inc/lottiecomp/flatbuffers/flatbuffers.h",
+        "inc/lottiecomp/flatbuffers/base.h"
+    )
+    foreach ($path in $required) {
+        $entry = $archive.GetEntry($path)
+        if (!$entry -or $entry.Length -eq 0) {
+            throw "Missing or empty package entry: $path"
+        }
+    }
+
+    $headers = @($archive.Entries | Where-Object FullName -like "*.h")
+    foreach ($header in $headers) {
+        if (!$header.FullName.StartsWith("inc/lottiecomp/") -or $header.Length -eq 0) {
+            throw "Invalid package header: $($header.FullName)"
+        }
+    }
+
+    $flatBuffersRoot = (Resolve-Path (Join-Path $FlatBuffersIncludeDirectory "flatbuffers")).Path
+    $flatBuffersHeaders = Get-ChildItem -LiteralPath $flatBuffersRoot -Recurse -File -Filter "*.h"
+    foreach ($header in $flatBuffersHeaders) {
+        $relativePath = $header.FullName.Substring($flatBuffersRoot.Length + 1).Replace("\", "/")
+        $path = "inc/lottiecomp/flatbuffers/$relativePath"
+        $entry = $archive.GetEntry($path)
+        if (!$entry -or $entry.Length -ne $header.Length) {
+            throw "Missing or truncated FlatBuffers header: $path"
+        }
+    }
+
+    $repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..\..")
+    $sources = @{
+        "LottieRuntime/lottie_comp.fbs" = "source\LottieFlatbuffer\lottie_comp.fbs"
+        "inc/lottiecomp/Generated/lottie_comp_generated.h" = "source\LottieRuntime\Generated\lottie_comp_generated.h"
+    }
+    foreach ($path in $sources.Keys) {
+        $reader = [IO.StreamReader]::new($archive.GetEntry($path).Open())
+        try {
+            $packaged = $reader.ReadToEnd()
+        }
+        finally {
+            $reader.Dispose()
+        }
+        if ($packaged -cne [IO.File]::ReadAllText((Join-Path $repoRoot $sources[$path]))) {
+            throw "Package entry differs from source: $path"
+        }
+    }
+
+    Write-Host "Package contains the schema, sources, license, and $($headers.Count) headers under inc/lottiecomp."
+}
+finally {
+    $archive.Dispose()
+}
diff --git a/vcpkg.json b/vcpkg.json
new file mode 100644
index 00000000..7a69179a
--- /dev/null
+++ b/vcpkg.json
@@ -0,0 +1,14 @@
+{
+  "name": "lottie-runtime",
+  "version-string": "1.0.0",
+  "builtin-baseline": "a2f9862da6d88040a8537fb9b8cb24deaa9a196b",
+  "dependencies": [
+    "flatbuffers"
+  ],
+  "overrides": [
+    {
+      "name": "flatbuffers",
+      "version": "25.12.19"
+    }
+  ]
+}

From a83fb5211fbbbb71414f7e260bf370f653bd5c2a Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Wed, 21 Oct 2026 11:49:44 -0700
Subject: [PATCH 38/39] Simplify FlatBuffers regeneration and align
 dependencies at 25.2.10

Remove package-content validation, restore vcpkg before invoking its compiler for both bindings, and support historical ports in repo-local vcpkg checkouts.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d33f7269-9a0c-4437-aadd-0da22dcee956
---
 .github/workflows/dotnet-build.yml            |  7 --
 build/FlatBuffers.targets                     |  2 +-
 build/RegenerateFlatbuffers.ps1               | 50 +++++------
 build/RestoreFlatBuffers.ps1                  | 14 ++-
 source/LottieFlatbuffer/README.md             | 17 ++--
 .../Generated/lottie_comp_generated.h         | 89 +++++++------------
 source/LottieRuntime/README.md                |  4 +-
 tests/LottieRuntime.Tests/PackageTests.ps1    | 71 ---------------
 vcpkg.json                                    |  2 +-
 9 files changed, 77 insertions(+), 179 deletions(-)
 delete mode 100644 tests/LottieRuntime.Tests/PackageTests.ps1

diff --git a/.github/workflows/dotnet-build.yml b/.github/workflows/dotnet-build.yml
index 190342e9..1e4e4c7d 100644
--- a/.github/workflows/dotnet-build.yml
+++ b/.github/workflows/dotnet-build.yml
@@ -65,13 +65,6 @@ jobs:
         shell: pwsh
         working-directory: .\build
 
-      - name: Validate LottieGen native package content
-        shell: pwsh
-        run: |
-          $package = Get-ChildItem .\bin\nupkg\LottieGen.*.nupkg | Where-Object Name -notlike 'LottieGen.MsBuild.*' | Where-Object Name -notlike 'LottieGen.win-x64.*'
-          if (@($package).Count -ne 1) { throw "Expected one LottieGen tool package." }
-          .\tests\LottieRuntime.Tests\PackageTests.ps1 -PackagePath $package.FullName
-
       - name: Upload Package List
         uses: actions/upload-artifact@v4
         with:
diff --git a/build/FlatBuffers.targets b/build/FlatBuffers.targets
index 87c152a1..57621c6d 100644
--- a/build/FlatBuffers.targets
+++ b/build/FlatBuffers.targets
@@ -22,6 +22,6 @@
     <Exec Condition="'$(_RestoreFlatBuffers)' == 'true'"
           Command="powershell.exe -NoProfile -ExecutionPolicy Bypass -File &quot;$(MSBuildThisFileDirectory)RestoreFlatBuffers.ps1&quot; -VcpkgRoot &quot;$(FlatBuffersVcpkgRoot)\.&quot; -InstalledDir &quot;$(FlatBuffersVcpkgInstalledDir)\.&quot; -Triplet &quot;$(FlatBuffersVcpkgTriplet)&quot; -HostTriplet &quot;$(FlatBuffersVcpkgHostTriplet)&quot;" />
     <Error Condition="!Exists('$(FlatBuffersIncludeDirectory)\flatbuffers\flatbuffers.h')"
-           Text="FlatBuffers headers were not found at '$(FlatBuffersIncludeDirectory)'. Restore vcpkg dependencies or set FlatBuffersIncludeDirectory to the include directory for FlatBuffers 25.12.19." />
+           Text="FlatBuffers headers were not found at '$(FlatBuffersIncludeDirectory)'. Restore vcpkg dependencies or set FlatBuffersIncludeDirectory to the include directory for FlatBuffers 25.2.10." />
   </Target>
 </Project>
diff --git a/build/RegenerateFlatbuffers.ps1 b/build/RegenerateFlatbuffers.ps1
index 2e7f5ec4..4909cc20 100644
--- a/build/RegenerateFlatbuffers.ps1
+++ b/build/RegenerateFlatbuffers.ps1
@@ -4,50 +4,46 @@
 # need flatc installed in order to build. Run this script after any change to
 # source/LottieFlatbuffer/lottie_comp.fbs, and check in the result.
 #
-# C# output must match the Google.FlatBuffers package available through the
-# configured Microsoft feed. C++ output must match the vcpkg manifest.
-#
-# RestoreFlatBuffers installs the matching C++ compiler under
-# vcpkg_installed/<host-triplet>/tools/flatbuffers/flatc.exe.
-
 [CmdletBinding()]
 param(
-    # C# code must match the Google.FlatBuffers package version.
-    [string]$CSharpFlatc = "flatc",
+    [string]$VcpkgRoot = $env:VCPKG_ROOT,
 
-    # C++ code must match the headers restored by vcpkg.
-    [string]$CppFlatc = (Join-Path $PSScriptRoot "..\vcpkg_installed\x64-windows\tools\flatbuffers\flatc.exe")
+    [string]$InstalledDir = (Join-Path $PSScriptRoot "..\vcpkg_installed"),
+
+    [string]$HostTriplet = $(if ($env:PROCESSOR_ARCHITECTURE -eq "ARM64" -or $env:PROCESSOR_ARCHITEW6432 -eq "ARM64") { "arm64-windows" } else { "x64-windows" })
 )
 
 $ErrorActionPreference = "Stop"
 
-$expectedCSharpVersion = "25.2.10"
-
 $repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..")
-$schema = Join-Path $repoRoot "source/LottieFlatbuffer/lottie_comp.fbs"
-$csharpOut = Join-Path $repoRoot "source/CompDataFlatbuffer/Generated"
-$cppOut = Join-Path $repoRoot "source/LottieRuntime/Generated"
-$manifest = Get-Content (Join-Path $repoRoot "vcpkg.json") -Raw | ConvertFrom-Json
-$expectedCppVersion = ($manifest.overrides | Where-Object name -eq "flatbuffers").version
-
-$actualCSharpVersion = (& $CSharpFlatc --version) -replace '^flatc version ', ''
-if ($actualCSharpVersion.Trim() -ne $expectedCSharpVersion) {
-    throw "C# flatc version $expectedCSharpVersion is required, but '$CSharpFlatc' is version $($actualCSharpVersion.Trim())."
-}
+$schema = Join-Path $repoRoot "source\LottieFlatbuffer\lottie_comp.fbs"
+$csharpOut = Join-Path $repoRoot "source\CompDataFlatbuffer\Generated"
+$cppOut = Join-Path $repoRoot "source\LottieRuntime\Generated"
 
-$actualCppVersion = (& $CppFlatc --version) -replace '^flatc version ', ''
-if ($actualCppVersion.Trim() -ne $expectedCppVersion) {
-    throw "C++ flatc version $expectedCppVersion is required, but '$CppFlatc' is version $($actualCppVersion.Trim())."
+if (!$VcpkgRoot) {
+    $VcpkgRoot = Join-Path $repoRoot ".vcpkg"
 }
 
+& (Join-Path $PSScriptRoot "RestoreFlatBuffers.ps1") -VcpkgRoot $VcpkgRoot `
+    -InstalledDir $InstalledDir -Triplet $HostTriplet -HostTriplet $HostTriplet
+$flatc = Join-Path $InstalledDir "$HostTriplet\tools\flatbuffers\flatc.exe"
+
 New-Item -ItemType Directory -Force -Path $csharpOut, $cppOut | Out-Null
 
 # --gen-onefile keeps the checked in C# to a single file rather than one file
 # per type spread over a namespace directory tree.
-& $CSharpFlatc --csharp --gen-onefile -o $csharpOut $schema
+& $flatc --csharp --gen-onefile -o $csharpOut $schema
 if ($LASTEXITCODE -ne 0) { throw "flatc failed to generate C#." }
 
-& $CppFlatc --cpp --scoped-enums -o $cppOut $schema
+& $flatc --cpp --scoped-enums -o $cppOut $schema
 if ($LASTEXITCODE -ne 0) { throw "flatc failed to generate C++." }
 
+foreach ($path in @(
+    (Join-Path $csharpOut "lottie_comp_generated.cs"),
+    (Join-Path $cppOut "lottie_comp_generated.h")
+)) {
+    $contents = [IO.File]::ReadAllText($path)
+    [IO.File]::WriteAllText($path, ($contents -replace '\r?\n', "`r`n"), [Text.UTF8Encoding]::new($false))
+}
+
 Write-Host "Generated FlatBuffers code from $schema"
diff --git a/build/RestoreFlatBuffers.ps1 b/build/RestoreFlatBuffers.ps1
index 1b21ebc7..56df898c 100644
--- a/build/RestoreFlatBuffers.ps1
+++ b/build/RestoreFlatBuffers.ps1
@@ -18,6 +18,7 @@ $VcpkgRoot = [IO.Path]::GetFullPath($VcpkgRoot)
 $InstalledDir = [IO.Path]::GetFullPath($InstalledDir)
 $localRoot = Join-Path $repoRoot ".vcpkg"
 $vcpkg = Join-Path $VcpkgRoot "vcpkg.exe"
+$baseline = (Get-Content (Join-Path $repoRoot "vcpkg.json") -Raw | ConvertFrom-Json).'builtin-baseline'
 
 function Invoke-Checked([string]$Program, [string[]]$Arguments) {
     & $Program @Arguments
@@ -31,7 +32,6 @@ if (!(Test-Path -LiteralPath $vcpkg)) {
         throw "vcpkg.exe was not found at '$VcpkgRoot'. Bootstrap that installation or omit FlatBuffersVcpkgRoot to use automatic discovery."
     }
 
-    $baseline = (Get-Content (Join-Path $repoRoot "vcpkg.json") -Raw | ConvertFrom-Json).'builtin-baseline'
     if (!(Test-Path -LiteralPath $VcpkgRoot)) {
         Invoke-Checked "git" @("init", $VcpkgRoot)
         Invoke-Checked "git" @("-C", $VcpkgRoot, "remote", "add", "origin", "https://github.com/microsoft/vcpkg.git")
@@ -42,11 +42,21 @@ if (!(Test-Path -LiteralPath $vcpkg)) {
         throw "'$VcpkgRoot' must be a checkout of https://github.com/microsoft/vcpkg.git."
     }
 
-    Invoke-Checked "git" @("-C", $VcpkgRoot, "fetch", "--depth=1", "origin", $baseline)
+    Invoke-Checked "git" @("-C", $VcpkgRoot, "fetch", "origin", $baseline)
     Invoke-Checked "git" @("-C", $VcpkgRoot, "checkout", "--detach", $baseline)
     Invoke-Checked (Join-Path $VcpkgRoot "bootstrap-vcpkg.bat") @("-disableMetrics")
 }
 
+if ($VcpkgRoot -eq $localRoot) {
+    $shallow = & git -C $VcpkgRoot rev-parse --is-shallow-repository
+    if ($LASTEXITCODE -ne 0) {
+        throw "Could not inspect the repo-local vcpkg checkout at '$VcpkgRoot'."
+    }
+    if ($shallow -eq "true") {
+        Invoke-Checked "git" @("-C", $VcpkgRoot, "fetch", "--unshallow", "origin", $baseline)
+    }
+}
+
 Invoke-Checked $vcpkg @(
     "install",
     "--triplet=$Triplet",
diff --git a/source/LottieFlatbuffer/README.md b/source/LottieFlatbuffer/README.md
index 49f07db9..5550fdc3 100644
--- a/source/LottieFlatbuffer/README.md
+++ b/source/LottieFlatbuffer/README.md
@@ -57,18 +57,15 @@ a buffer may carry meaning in fields the reader does not look at.
 installed. After changing the schema:
 
 ```powershell
-msbuild .\source\LottieRuntime\LottieRuntimeTool.vcxproj /t:RestoreFlatBuffers /p:Platform=x64
-.\build\RegenerateFlatbuffers.ps1 `
-    -CSharpFlatc <path to 25.2.10 flatc> `
-    -CppFlatc .\vcpkg_installed\x64-windows\tools\flatbuffers\flatc.exe
+.\build\RegenerateFlatbuffers.ps1
 ```
 
-The C# `flatc` version **must** match the `Google.FlatBuffers` NuGet package
-version. The C++ `flatc` and headers must match the FlatBuffers override in
-`vcpkg.json`. The script validates both compiler versions before regenerating.
-For an ARM64 host or a custom install root, pass the host's restored `flatc.exe`
-as `-CppFlatc`. Updating the C++ dependency requires updating the manifest and
-regenerating the C++ binding together.
+The script restores vcpkg dependencies, then uses the restored host
+`tools\flatbuffers\flatc.exe` to generate both bindings. It uses `VCPKG_ROOT`
+when set and otherwise bootstraps the repo-local `.vcpkg` checkout. Override
+`VcpkgRoot`, `InstalledDir`, or `HostTriplet` for a different installation.
+Updating the FlatBuffers dependency requires updating the manifest and
+the `Google.FlatBuffers` NuGet references, then regenerating the bindings.
 
 ## Consumers
 
diff --git a/source/LottieRuntime/Generated/lottie_comp_generated.h b/source/LottieRuntime/Generated/lottie_comp_generated.h
index eb3b0700..b2eba1b4 100644
--- a/source/LottieRuntime/Generated/lottie_comp_generated.h
+++ b/source/LottieRuntime/Generated/lottie_comp_generated.h
@@ -9,8 +9,8 @@
 // Ensure the included flatbuffers.h is the same version as when this file was
 // generated, otherwise it may not be compatible.
 static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
-              FLATBUFFERS_VERSION_MINOR == 12 &&
-              FLATBUFFERS_VERSION_REVISION == 19,
+              FLATBUFFERS_VERSION_MINOR == 2 &&
+              FLATBUFFERS_VERSION_REVISION == 10,
              "Non-compatible flatbuffers version included");
 
 namespace CommunityToolkit {
@@ -959,8 +959,7 @@ struct Animator FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t controller() const {
     return GetField<uint32_t>(VT_CONTROLLER, 4294967295);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_PROPERTY, 4) &&
            VerifyField<uint32_t>(verifier, VT_ANIMATION, 4) &&
@@ -1021,8 +1020,7 @@ struct CompObj FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t properties() const {
     return GetField<uint32_t>(VT_PROPERTIES, 4294967295);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_COMMENT, 4) &&
            VerifyOffset(verifier, VT_ANIMATORS) &&
@@ -1106,8 +1104,7 @@ struct PropertyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *color() const {
     return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *>(VT_COLOR);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<uint8_t>(verifier, VT_TYPE, 1) &&
@@ -1176,8 +1173,7 @@ struct ReferenceParameter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   uint32_t target() const {
     return GetField<uint32_t>(VT_TARGET, 0);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<uint32_t>(verifier, VT_TARGET, 4) &&
@@ -1228,8 +1224,7 @@ struct SourceParameter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t brush() const {
     return GetField<uint32_t>(VT_BRUSH, 0);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<uint32_t>(verifier, VT_BRUSH, 4) &&
@@ -1304,8 +1299,7 @@ struct KeyFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t path() const {
     return GetField<uint32_t>(VT_PATH, 4294967295);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<float>(verifier, VT_PROGRESS, 4) &&
            VerifyField<uint32_t>(verifier, VT_EASING, 4) &&
@@ -1456,8 +1450,7 @@ struct Visual FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t shadow() const {
     return GetField<uint32_t>(VT_SHADOW, 4294967295);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -1723,8 +1716,7 @@ struct Shape FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Optional<float> stroke_thickness() const {
     return GetOptional<float, float>(VT_STROKE_THICKNESS);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -1970,8 +1962,7 @@ struct Geometry FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *radius() const {
     return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_RADIUS);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2161,8 +2152,7 @@ struct Brush FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SourceParameter>> *source_parameters() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::SourceParameter>> *>(VT_SOURCE_PARAMETERS);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2401,8 +2391,7 @@ struct GradientStop FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   float offset() const {
     return GetField<float>(VT_OFFSET, 0.0f);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2460,8 +2449,7 @@ struct ViewBox FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *size() const {
     return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Vec2 *>(VT_SIZE);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2541,8 +2529,7 @@ struct Clip FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t geometry() const {
     return GetField<uint32_t>(VT_GEOMETRY, 4294967295);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2660,8 +2647,7 @@ struct Shadow FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Optional<uint8_t> source_policy() const {
     return GetOptional<uint8_t, uint8_t>(VT_SOURCE_POLICY);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2769,8 +2755,7 @@ struct Surface FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<uint8_t> *bytes() const {
     return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_BYTES);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -2886,8 +2871,7 @@ struct Effect FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   float blur_amount() const {
     return GetField<float>(VT_BLUR_AMOUNT, 0.0f);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -3003,8 +2987,7 @@ struct Easing FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Optional<bool> is_final_step_single_frame() const {
     return GetOptional<uint8_t, bool>(VT_IS_FINAL_STEP_SINGLE_FRAME);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -3122,8 +3105,7 @@ struct Animation FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Optional<uint8_t> interpolation_color_space() const {
     return GetOptional<uint8_t, uint8_t>(VT_INTERPOLATION_COLOR_SPACE);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -3243,8 +3225,7 @@ struct PropertySet FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValue>> *values() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::PropertyValue>> *>(VT_VALUES);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -3329,8 +3310,7 @@ struct Controller FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool is_custom() const {
     return GetField<uint8_t>(VT_IS_CUSTOM, 0) != 0;
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_BASE) &&
            verifier.VerifyTable(base()) &&
@@ -3420,8 +3400,7 @@ struct PropertyBinding FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *default_color() const {
     return GetStruct<const CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::Color *>(VT_DEFAULT_COLOR);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<uint32_t>(verifier, VT_DISPLAY_NAME, 4) &&
@@ -3506,8 +3485,7 @@ struct Marker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   float duration_progress() const {
     return GetField<float>(VT_DURATION_PROGRESS, 0.0f);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<float>(verifier, VT_PROGRESS, 4) &&
@@ -3588,8 +3566,7 @@ struct Metadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t theming_property_set() const {
     return GetField<uint32_t>(VT_THEMING_PROPERTY_SET, 4294967295);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_NAME, 4) &&
            VerifyField<float>(verifier, VT_WIDTH, 4) &&
@@ -3780,8 +3757,7 @@ struct LottieComposition FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   const ::flatbuffers::Vector<uint32_t> *custom_controllers() const {
     return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_CUSTOM_CONTROLLERS);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint16_t>(verifier, VT_SCHEMA_VERSION, 2) &&
            VerifyField<uint16_t>(verifier, VT_REQUIRED_UAP_VERSION, 2) &&
@@ -4101,8 +4077,7 @@ struct CanvasGeometry FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   float radius_y() const {
     return GetField<float>(VT_RADIUS_Y, 0.0f);
   }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
            VerifyField<uint32_t>(verifier, VT_A, 4) &&
@@ -4291,16 +4266,14 @@ inline bool SizePrefixedLottieCompositionBufferHasIdentifier(const void *buf) {
       buf, LottieCompositionIdentifier(), true);
 }
 
-template <bool B = false>
 inline bool VerifyLottieCompositionBuffer(
-    ::flatbuffers::VerifierTemplate<B> &verifier) {
-  return verifier.template VerifyBuffer<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(LottieCompositionIdentifier());
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(LottieCompositionIdentifier());
 }
 
-template <bool B = false>
 inline bool VerifySizePrefixedLottieCompositionBuffer(
-    ::flatbuffers::VerifierTemplate<B> &verifier) {
-  return verifier.template VerifySizePrefixedBuffer<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(LottieCompositionIdentifier());
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<CommunityToolkit::WinUI::Lottie::CompDataFlatbuffer::Schema::LottieComposition>(LottieCompositionIdentifier());
 }
 
 inline const char *LottieCompositionExtension() {
diff --git a/source/LottieRuntime/README.md b/source/LottieRuntime/README.md
index 4b81175f..8231945b 100644
--- a/source/LottieRuntime/README.md
+++ b/source/LottieRuntime/README.md
@@ -40,7 +40,7 @@ WinUI 3 builder when that projection provides the APIs required by the variant.
 Add `LottieRuntime.cpp` to the native project, define the matching projection
 flag, and add `source\LottieRuntime` and the include directory from the vcpkg
 `flatbuffers` port to its include paths. The checked-in C++ binding requires
-FlatBuffers **25.12.19**. Build as C++20 and link:
+FlatBuffers **25.2.10**. Build as C++20 and link:
 
 ```text
 d2d1.lib
@@ -271,7 +271,7 @@ Defaults are `x64-windows` for x64 and `arm64-windows` for ARM64, with native-ho
 
 An explicit `/p:FlatBuffersIncludeDirectory=C:\deps\flatbuffers\include`
 skips vcpkg discovery and restore. That directory must contain FlatBuffers
-25.12.19 headers; the generated binding checks the version at compile time.
+25.2.10 headers; the generated binding checks the version at compile time.
 An explicitly selected vcpkg root without `vcpkg.exe` is an error.
 
 ### Package layout and private FlatBuffers versions
diff --git a/tests/LottieRuntime.Tests/PackageTests.ps1 b/tests/LottieRuntime.Tests/PackageTests.ps1
deleted file mode 100644
index a8af683e..00000000
--- a/tests/LottieRuntime.Tests/PackageTests.ps1
+++ /dev/null
@@ -1,71 +0,0 @@
-[CmdletBinding()]
-param(
-    [Parameter(Mandatory)]
-    [string]$PackagePath,
-
-    [string]$FlatBuffersIncludeDirectory = (Join-Path $PSScriptRoot "..\..\vcpkg_installed\x64-windows\include")
-)
-
-$ErrorActionPreference = "Stop"
-Add-Type -AssemblyName System.IO.Compression.FileSystem
-$archive = [IO.Compression.ZipFile]::OpenRead((Resolve-Path $PackagePath))
-try {
-    $required = @(
-        "LottieRuntime/lottie_comp.fbs",
-        "LottieRuntime/LottieRuntime.cpp",
-        "LottieRuntime/LottieVisualSource.cpp",
-        "LottieRuntime/flatbuffers.LICENSE.txt",
-        "inc/lottiecomp/LottieRuntime.h",
-        "inc/lottiecomp/LottieVisualSource.h",
-        "inc/lottiecomp/Generated/lottie_comp_generated.h",
-        "inc/lottiecomp/flatbuffers/flatbuffers.h",
-        "inc/lottiecomp/flatbuffers/base.h"
-    )
-    foreach ($path in $required) {
-        $entry = $archive.GetEntry($path)
-        if (!$entry -or $entry.Length -eq 0) {
-            throw "Missing or empty package entry: $path"
-        }
-    }
-
-    $headers = @($archive.Entries | Where-Object FullName -like "*.h")
-    foreach ($header in $headers) {
-        if (!$header.FullName.StartsWith("inc/lottiecomp/") -or $header.Length -eq 0) {
-            throw "Invalid package header: $($header.FullName)"
-        }
-    }
-
-    $flatBuffersRoot = (Resolve-Path (Join-Path $FlatBuffersIncludeDirectory "flatbuffers")).Path
-    $flatBuffersHeaders = Get-ChildItem -LiteralPath $flatBuffersRoot -Recurse -File -Filter "*.h"
-    foreach ($header in $flatBuffersHeaders) {
-        $relativePath = $header.FullName.Substring($flatBuffersRoot.Length + 1).Replace("\", "/")
-        $path = "inc/lottiecomp/flatbuffers/$relativePath"
-        $entry = $archive.GetEntry($path)
-        if (!$entry -or $entry.Length -ne $header.Length) {
-            throw "Missing or truncated FlatBuffers header: $path"
-        }
-    }
-
-    $repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..\..")
-    $sources = @{
-        "LottieRuntime/lottie_comp.fbs" = "source\LottieFlatbuffer\lottie_comp.fbs"
-        "inc/lottiecomp/Generated/lottie_comp_generated.h" = "source\LottieRuntime\Generated\lottie_comp_generated.h"
-    }
-    foreach ($path in $sources.Keys) {
-        $reader = [IO.StreamReader]::new($archive.GetEntry($path).Open())
-        try {
-            $packaged = $reader.ReadToEnd()
-        }
-        finally {
-            $reader.Dispose()
-        }
-        if ($packaged -cne [IO.File]::ReadAllText((Join-Path $repoRoot $sources[$path]))) {
-            throw "Package entry differs from source: $path"
-        }
-    }
-
-    Write-Host "Package contains the schema, sources, license, and $($headers.Count) headers under inc/lottiecomp."
-}
-finally {
-    $archive.Dispose()
-}
diff --git a/vcpkg.json b/vcpkg.json
index 7a69179a..3891e8ed 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -8,7 +8,7 @@
   "overrides": [
     {
       "name": "flatbuffers",
-      "version": "25.12.19"
+      "version": "25.2.10"
     }
   ]
 }

From a14704f45c52575d4a00c55480657f3afb893b03 Mon Sep 17 00:00:00 2001
From: Jon Wiswall <jonwis@microsoft.com>
Date: Wed, 21 Oct 2026 13:01:30 -0700
Subject: [PATCH 39/39] Keep managed package references out of native runtime
 builds

Scope managed analyzers and GitVersioning to C# projects and remove stale loader cleanup from the native validation tool.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d33f7269-9a0c-4437-aadd-0da22dcee956
---
 Directory.Build.props                      | 4 ++--
 source/LottieRuntime/LottieRuntimeTool.cpp | 1 -
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/Directory.Build.props b/Directory.Build.props
index 9615baed..63077b78 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -125,7 +125,7 @@
   </Choose>
 
   <Choose>
-    <When Condition="'$(IsTestProject)' != 'true' and '$(IsSampleProject)' != 'true' and '$(IsDesignProject)' != 'true'">
+    <When Condition="'$(MSBuildProjectExtension)' == '.csproj' and '$(IsTestProject)' != 'true' and '$(IsSampleProject)' != 'true' and '$(IsDesignProject)' != 'true'">
       <ItemGroup>
         <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.5.22" PrivateAssets="all" />
         <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="all" />
@@ -144,7 +144,7 @@
     <NoWarn>$(NoWarn);8002</NoWarn>
   </PropertyGroup>
 
-  <ItemGroup>
+  <ItemGroup Condition="'$(MSBuildProjectExtension)' == '.csproj'">
     <PackageReference Include="Nerdbank.GitVersioning" Version="3.5.119" PrivateAssets="all" />
   </ItemGroup>
   
diff --git a/source/LottieRuntime/LottieRuntimeTool.cpp b/source/LottieRuntime/LottieRuntimeTool.cpp
index cd63a9bf..da80b7c8 100644
--- a/source/LottieRuntime/LottieRuntimeTool.cpp
+++ b/source/LottieRuntime/LottieRuntimeTool.cpp
@@ -305,7 +305,6 @@ int wmain(int argc, wchar_t* argv[])
         }
 
         root = nullptr;
-        loader = nullptr;
         dispatcherQueueController.ShutdownQueueAsync();
     }
     catch (winrt::hresult_error const& e)