From 724b020e93e569ed3c3172ecbf9970d0a990edda Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 15:56:53 +1000
Subject: [PATCH 01/12] Document what it takes to run VR and Quest APKs in
 Lepton

Verified on the headset: hello_xr and Open Brush's Quest build run
immersively unmodified; Wolvic's Quest build needs a LAUNCHER category
and fails on SteamVR's Android runtime being OpenXR 1.0 only.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 docs/vr-apks.md | 89 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 docs/vr-apks.md

diff --git a/docs/vr-apks.md b/docs/vr-apks.md
new file mode 100644
index 0000000..7b913ff
--- /dev/null
+++ b/docs/vr-apks.md
@@ -0,0 +1,89 @@
+# VR APKs and Quest games in Lepton
+
+What it takes to run an immersive (OpenXR) Android app, including Meta Quest
+builds, on the Frame. Checked on SteamOS BUILD_ID 20260925.6191901, Lepton
+v2.8.14 (rootfs v2.8.11), SteamVR 2.18.1, on 2026-09-28, unless marked
+**inferred**.
+
+## How a VR APK reaches SteamVR (verified)
+
+- Lepton ships a standard Khronos system runtime manifest,
+  `/vendor/etc/openxr/1/active_runtime.json`, pointing at SteamVR's Android
+  client, `/data/steamvr/runtime/bin/androidarm64/vrclient.so`. That is the
+  host's `/opt/steamvr/bin/androidarm64/`, bind-mounted in.
+- An APK's own Khronos-style `libopenxr_loader.so` tries the runtime brokers
+  (`org.khronos.openxr.runtime_broker`, `…system_runtime_broker`), finds
+  neither, then falls back to that manifest. Nothing in the APK has to change
+  for discovery.
+- Install the APK without the flatscreen marker
+  (`python3 ui/frame_android.py install app.apk --vr`). The marker only
+  controls Lepton's 2D Android surface; the app itself has to start an
+  OpenXR session.
+- Lepton also loads Valve's `XR_APILAYER_VALVE_fdm_injection` layer from
+  `/vendor/etc/openxr/1/api_layers/implicit.d/`. Only layers in Valve's own
+  directories are picked up (`liblepton/vulkan_layers.sh`), so a third-party
+  layer has to ship inside the APK.
+
+**Open Brush 2.32.29, the Quest APK from its GitHub release (Unity OpenXR,
+Vulkan), works unmodified.** Its manifest already has `LAUNCHER` next to
+`com.oculus.intent.category.VR`. Unity asked for OpenXR 1.1, got
+`XR_ERROR_API_VERSION_UNSUPPORTED`, retried with 1.0 and succeeded. SteamVR
+took it as the scene app, created Touch, simple-controller and Frame-controller
+bindings, and the session reached `XR_SESSION_STATE_FOCUSED`. A headset capture
+(`ui/frame_vrshot.py`, after waking the compositor and closing the dashboard)
+showed a dark sky over a mountain horizon; nobody wore the headset to confirm
+it was Open Brush's scene or to try drawing.
+
+**Khronos `hello_xr` (Vulkan, 1.1.63 release APK) works unmodified:**
+`Instance RuntimeName=SteamVR/OpenXR RuntimeVersion=2.18.1`, 1728×1728
+swapchains per eye, session `IDLE → READY → SYNCHRONIZED` (the headset was
+not being worn, so it did not reach `FOCUSED`).
+
+## What SteamVR's Android runtime supports (verified, from `vrclient.so`)
+
+- **OpenXR 1.0 only.** An app requesting `XR_API_VERSION_1_0` works; one
+  requesting 1.1 (`XR_CURRENT_API_VERSION` in a 1.1 SDK) gets
+  `XR_ERROR_API_VERSION_UNSUPPORTED` from the runtime.
+- Extensions include `XR_KHR_opengl_es_enable`, `XR_KHR_vulkan_enable{,2}`,
+  `XR_KHR_composition_layer_depth`, `XR_KHR_locate_spaces`,
+  `XR_EXT_local_floor`, `XR_EXT_uuid`, `XR_EXT_palm_pose`,
+  `XR_EXT_hand_tracking`, `XR_EXT_eye_gaze_interaction`, and these Meta ones:
+  `XR_FB_display_refresh_rate`, `XR_FB_foveation{,_configuration,_vulkan}`,
+  `XR_FB_space_warp`, `XR_FB_swapchain_update_state`,
+  `XR_META_foveation_eye_tracked`, `XR_META_recommended_layer_resolution`,
+  `XR_META_vulkan_swapchain_create_info`, `XR_META_performance_metrics`.
+- Not present: `XR_FB_passthrough`, `XR_FB_hand_tracking_*`,
+  `XR_FB_spatial_entity*`, `XR_FB_color_space`,
+  `XR_KHR_android_thread_settings`, `XR_OCULUS_*`.
+- Interaction profiles include `oculus/touch_controller`, `khr/simple_controller`,
+  `valve/frame_controller` and the usual PC controllers. Valve documents Touch
+  bindings as a working fallback on the Frame controllers.
+
+## What stops a Quest APK (verified with Wolvic 1.9, `oculusvr` build)
+
+1. **Lepton won't start it.** Lepton's `apk-info-extractor` only accepts an
+   activity whose intent filter has `android.intent.action.MAIN` and
+   `android.intent.category.LAUNCHER`. Quest apps use
+   `com.oculus.intent.category.VR` instead, so Lepton logs `APP_ACTIVITY is
+   empty` and exits. There is no override. **Fix:** add the `LAUNCHER`
+   category to that intent filter and re-sign. After that, Wolvic started.
+2. **OpenXR 1.1.** Wolvic's Quest build then requested OpenXR 1.1 and aborted
+   on `XR_ERROR_API_VERSION_UNSUPPORTED`. Unity's OpenXR plugin retries with
+   1.0 (Open Brush, above), so this mostly bites native and non-Unity apps. **Fix (inferred):** an API layer
+   inside the APK that asks the runtime for 1.0 and maps the 1.1 core
+   functions to the extensions the runtime does have (`XR_KHR_locate_spaces`,
+   `XR_EXT_local_floor`, `XR_EXT_uuid`, `XR_EXT_palm_pose`).
+3. **Not yet reached:** required Meta-only extensions (each app differs),
+   swapchain formats (the Lynx Wolvic build needed `GL_SRGB8_ALPHA8`), and
+   Meta platform services.
+
+The loader was never the problem: Wolvic's Quest `libopenxr_loader.so` is a
+Khronos-style loader and found SteamVR through `/vendor`.
+
+## Out of scope
+
+- **Meta entitlement.** Apps that call the Oculus Platform SDK
+  (`libovrplatformloader.so`) to check the Quest store licence need Meta's
+  services. Frame Control won't work around that.
+- **VrApi-era apps** (`libvrapi.so`, before OpenXR) need an API translator,
+  not a patch.

From a1bc6522c3e77dc41c8900f826ce8a0a2a5239f7 Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 16:16:56 +1000
Subject: [PATCH 02/12] Detect VR APKs and repair launchers with pure Python v2
 signing

---
 docs/vr-apks.md            |  28 +++
 tests/test_frame_apk_vr.py | 187 +++++++++++++++++++
 ui/frame_android.py        |  60 ++++++-
 ui/frame_apk.py            |   8 +-
 ui/frame_apk_sign.py       | 356 +++++++++++++++++++++++++++++++++++++
 ui/frame_apk_vr.py         | 113 ++++++++++++
 ui/index.html              |   7 +
 ui/server.py               |  10 +-
 8 files changed, 761 insertions(+), 8 deletions(-)
 create mode 100644 tests/test_frame_apk_vr.py
 create mode 100644 ui/frame_apk_sign.py
 create mode 100644 ui/frame_apk_vr.py

diff --git a/docs/vr-apks.md b/docs/vr-apks.md
index 7b913ff..45ecd56 100644
--- a/docs/vr-apks.md
+++ b/docs/vr-apks.md
@@ -87,3 +87,31 @@ Khronos-style loader and found SteamVR through `/vendor`.
   services. Frame Control won't work around that.
 - **VrApi-era apps** (`libvrapi.so`, before OpenXR) need an API translator,
   not a patch.
+
+## Frame Control does this for you
+
+APK uploads and `python3 ui/frame_android.py install app.apk` detect VR
+manifest categories, Samsung's `vr_only` flag and the arm64 OpenXR loader.
+VR apps default to immersive mode without the flatscreen marker. The upload
+selector or CLI `--flat` / `--vr` overrides that choice. Compatibility notes
+identify legacy VrApi, Meta platform SDK and OpenXR libraries.
+
+If a VR MAIN intent filter lacks LAUNCHER, Frame Control inserts it, repacks
+and v2-signs the APK locally before copying it; `meta.json` records
+`"patched": ["launcher"]`. Unchanged ZIP members retain their compressed
+bytes; stored libraries are aligned to 16 KiB. The RSA signing identity lives
+in Frame Control's per-user app-data directory as `apk-signing-key.json`
+(mode 0600). Keep this key to preserve the signer on subsequent patched
+updates. A re-signed APK cannot update an installation signed by its original
+publisher; Android also treats it as a different signer for signature checks.
+
+Inspect or prepare an APK without contacting the headset:
+
+```sh
+python3 ui/frame_android.py info app.apk
+python3 ui/frame_android.py patch app.apk patched.apk
+python3 ui/frame_android.py patch app.apk patched.apk --add assets/openxr/1/api_layers/implicit.d/X.json=X.json --add lib/arm64-v8a/libX.so=libX.so
+```
+
+The patch fixes Lepton's launch-category requirement. It does not supply an
+OpenXR 1.1 translation layer, Meta services or a VrApi implementation.
diff --git a/tests/test_frame_apk_vr.py b/tests/test_frame_apk_vr.py
new file mode 100644
index 0000000..c13e856
--- /dev/null
+++ b/tests/test_frame_apk_vr.py
@@ -0,0 +1,187 @@
+"""Local-only VR manifest, raw ZIP and independent signature checks."""
+import io
+import os
+from pathlib import Path
+import struct
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+import zipfile
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'ui'))
+import frame_apk
+import frame_apk_vr as vr
+import frame_apk_sign as signing
+import frame_android
+from test_frame_apk import pool
+
+
+def manifest(utf8=False, launcher=False, category=None, samsung=False, split=False):
+    strings = ['manifest', 'package', 'org.test.vr', 'application', 'activity', 'intent-filter',
+               'action', 'category', 'name', vr.MAIN, category or next(iter(sorted(vr.VR))),
+               vr.LAUNCHER, 'http://schemas.android.com/apk/res/android', 'meta-data', 'value',
+               'com.samsung.android.vr.application.mode', 'vr_only']
+    def start(tag, attrs=()):
+        body = struct.pack('<IIHHHHHH', 0xffffffff, strings.index(tag), 20, 20, len(attrs), 0, 0, 0)
+        for name, value in attrs:
+            ns = 0xffffffff if name == 'package' else 12
+            body += struct.pack('<IIIHBBI', ns, strings.index(name), strings.index(value), 8, 0, 3, strings.index(value))
+        return struct.pack('<HHIII', 0x102, 16, 16 + len(body), 1, 0xffffffff) + body
+    def end(tag):
+        return struct.pack('<HHIIIII', 0x103, 16, 24, 1, 0xffffffff, 0xffffffff, strings.index(tag))
+    def leaf(tag, attrs):
+        return start(tag, attrs) + end(tag)
+    b = pool(strings, utf8) + start('manifest', [('package', 'org.test.vr')]) + start('application')
+    if samsung:
+        b += leaf('meta-data', [('name', strings[15]), ('value', 'vr_only')])
+    b += start('activity') + start('intent-filter') + leaf('action', [('name', vr.MAIN)])
+    b += leaf('category', [('name', strings[10])])
+    if split:
+        b += end('intent-filter') + start('intent-filter')
+    if launcher:
+        b += leaf('category', [('name', vr.LAUNCHER)])
+    b += end('intent-filter') + end('activity') + end('application') + end('manifest')
+    return struct.pack('<HHI', 3, 8, len(b) + 8) + b
+
+
+class VRTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.tmp = tempfile.TemporaryDirectory()
+        cls.keypath = Path(cls.tmp.name) / 'key.json'
+        cls.key = signing.signing_key(cls.keypath)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.tmp.cleanup()
+
+    def test_manifest_patch(self):
+        for utf8 in (False, True):
+            for category in vr.VR:
+                original = manifest(utf8, category=category)
+                result = vr.add_launcher_category(original)
+                info, filters = vr.inspect(result)
+                self.assertTrue(info['launchable'])
+                self.assertTrue(info['vr'])
+                self.assertIn(vr.LAUNCHER, filters[0]['categories'])
+                self.assertEqual(struct.unpack_from('<I', result, 4)[0], len(result))
+                self.assertEqual(vr.add_launcher_category(result), result)
+                self.assertEqual(vr.add_launcher_category(manifest(utf8, True)), manifest(utf8, True))
+
+    def test_filter_boundaries(self):
+        self.assertFalse(vr.inspect(manifest(launcher=True, split=True))[0]['launchable'])
+        self.assertTrue(vr.inspect(vr.add_launcher_category(manifest(launcher=True, split=True)))[0]['launchable'])
+
+    def test_styled_pool(self):
+        for utf8 in (False, True):
+            p = bytearray(pool(['styled'], utf8))
+            old_start = struct.unpack_from('<I', p, 20)[0]
+            p[old_start:old_start] = struct.pack('<I', 0)
+            style_start = len(p)
+            p += struct.pack('<III', 0, 0, 2) + b'\xff' * 12
+            struct.pack_into('<I', p, 4, len(p))
+            struct.pack_into('<I', p, 16, (0x100 if utf8 else 0) | 1)
+            struct.pack_into('<I', p, 12, 1)
+            struct.pack_into('<II', p, 20, old_start + 4, style_start)
+            result, idx = vr._append_string(bytes(p), vr.LAUNCHER)
+            self.assertEqual(frame_apk._string_pool(result, 0), ['styled', vr.LAUNCHER])
+            new_style = struct.unpack_from('<I', result, 24)[0]
+            self.assertEqual(result[new_style:], p[style_start:])
+            self.assertEqual(len(result) % 4, 0)
+
+    def test_detection(self):
+        names = {'lib/arm64-v8a/' + n for n in ('libvrapi.so', 'libopenxr_loader.so', 'libovrplatformloader.so')}
+        info = vr.detection(manifest(category='android.intent.category.LAUNCHER'), names)
+        self.assertTrue(info['vr'])
+        self.assertTrue(info['launchable'])
+        self.assertEqual(len(info['vr_issues']), 3)
+        self.assertFalse(vr.detection(manifest(category=vr.LAUNCHER), set())['vr'])
+        self.assertTrue(vr.detection(manifest(category=vr.LAUNCHER, samsung=True), set())['vr'])
+
+    def test_key_cache(self):
+        with patch.object(signing, '_prime', side_effect=AssertionError('regenerated')):
+            self.assertEqual(signing.signing_key(self.keypath), self.key)
+        if os.name != 'nt':
+            self.assertEqual(self.keypath.stat().st_mode & 0o777, 0o600)
+
+    def test_repack_sign_tamper(self):
+        with tempfile.TemporaryDirectory() as d:
+            src, dst = Path(d) / 'in.apk', Path(d) / 'out.apk'
+            with zipfile.ZipFile(src, 'w') as z:
+                z.writestr('AndroidManifest.xml', manifest(), compress_type=8)
+                z.writestr('classes.dex', b'compress me' * 10000, compress_type=8)
+                z.writestr('resources.arsc', b'1234')
+                z.writestr('lib/arm64-v8a/libx.so', b'ELF' * 500000)
+                z.writestr('META-INF/OLD.RSA', b'old')
+                z.writestr('META-INF/MANIFEST.MF', b'old')
+            with patch.object(signing, 'signing_key', return_value=self.key):
+                result = frame_android.patch(src, dst, {'assets/layer.json': b'{}', 'lib/arm64-v8a/liblayer.so': b'layer'})
+            self.assertEqual(result['patched'], ['launcher'])
+            self.assertTrue(frame_apk.apk_info(dst)['launchable'])
+            self.assertTrue(signing.verify(dst))
+            def compressed(path, info):
+                data = path.read_bytes()
+                nl, el = struct.unpack_from('<HH', data, info.header_offset + 26)
+                start = info.header_offset + 30 + nl + el
+                return data[start:start + info.compress_size], start
+            with zipfile.ZipFile(src) as a, zipfile.ZipFile(dst) as b:
+                self.assertNotIn('META-INF/OLD.RSA', b.namelist())
+                self.assertNotIn('META-INF/MANIFEST.MF', b.namelist())
+                for i in b.infolist():
+                    raw, start = compressed(dst, i)
+                    if i.compress_type == 0:
+                        self.assertEqual(start % (16384 if i.filename.endswith('.so') else 4), 0)
+                    if i.filename in ('classes.dex', 'resources.arsc', 'lib/arm64-v8a/libx.so'):
+                        self.assertEqual(raw, compressed(src, a.getinfo(i.filename))[0])
+                _, off = compressed(dst, b.getinfo('resources.arsc'))
+            original = dst.read_bytes()
+            data = bytearray(original)
+            eo, cd = signing._eocd(data)
+            size = struct.unpack_from('<Q', data, cd - 24)[0]
+            block_start = cd - size - 8
+            value = data[block_start + 20:cd - 24]
+            signer = signing._parts(signing._parts(value)[0])[0]
+            signed, signatures, pub = signing._parts(signer)
+            signature = signing._parts(signing._parts(signatures)[0][4:])[0]
+            sig_offset = data.index(signature, block_start)
+            data[sig_offset] ^= 1
+            dst.write_bytes(data)
+            with self.assertRaisesRegex(ValueError, 'RSA signature'):
+                signing.verify(dst)
+            data = bytearray(original)
+            data[off] ^= 1
+            dst.write_bytes(data)
+            with self.assertRaisesRegex(ValueError, 'digest'):
+                signing.verify(dst)
+
+    @unittest.skipUnless(Path('/usr/bin/openssl').exists(), 'openssl absent')
+    def test_openssl(self):
+        with tempfile.TemporaryDirectory() as d:
+            d = Path(d)
+            (d / 'cert.der').write_bytes(signing.certificate(self.key))
+            (d / 'message').write_bytes(b'independent signature check')
+            (d / 'signature').write_bytes(signing.rsa_sign(b'independent signature check', self.key))
+            def run(*args):
+                return subprocess.run(['/usr/bin/openssl', *args], check=True, capture_output=True).stdout
+            run('x509', '-inform', 'DER', '-in', str(d / 'cert.der'), '-out', str(d / 'cert.pem'))
+            run('verify', '-check_ss_sig', '-CAfile', str(d / 'cert.pem'), str(d / 'cert.pem'))
+            (d / 'pub.pem').write_bytes(run('x509', '-in', str(d / 'cert.pem'), '-pubkey', '-noout'))
+            output = run('dgst', '-sha256', '-verify', str(d / 'pub.pem'), '-signature', str(d / 'signature'), str(d / 'message'))
+            self.assertIn(b'Verified OK', output)
+
+    def test_install_auto_and_override(self):
+        base = {'package': 'org.test.vr', 'label': 'VR', 'abis': [], 'min_sdk': None,
+                'vr': True, 'vr_activity': True, 'launchable': False}
+        with patch.object(frame_android, 'apk_info', return_value=base), patch.object(frame_android, 'patch') as repair, patch.object(frame_android, '_install', return_value={}) as install:
+            frame_android.install('original.apk')
+            repair.assert_called_once()
+            self.assertFalse(install.call_args.args[3])
+            self.assertEqual(install.call_args.args[1]['patched'], ['launcher'])
+            frame_android.install('original.apk', flatscreen=True)
+            self.assertTrue(install.call_args.args[3])
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/ui/frame_android.py b/ui/frame_android.py
index 3bff853..39e9161 100644
--- a/ui/frame_android.py
+++ b/ui/frame_android.py
@@ -6,12 +6,18 @@ apps, the lepton-show-flatscreen marker; plus a non-Steam shortcut, so it shows
 in the Steam library and gets its own SteamVR panel. Nothing goes through
 Lepton Development, which wipes its apps on exit. See docs/apks.md.
 
-Python stdlib only. CLI: python3 ui/frame_android.py {install APK|list|launch PKG|stop PKG|remove PKG|probe PKG}
+Python stdlib only. CLI: python3 ui/frame_android.py
+  install APK [--vr|--flat] | info APK | patch SRC DST [--add NAME=PATH ...]
+  list | launch PKG | stop PKG | remove PKG | probe PKG
 """
 import json, os, re, shlex, shutil, subprocess, sys, threading, time, zlib
 
 import frame_apk
 import frame_host
+import tempfile
+import zipfile
+from frame_apk_vr import add_launcher_category
+from frame_apk_sign import repack
 
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 FRAME = os.environ.get('FRAME_ALIAS', 'frame')
@@ -106,7 +112,7 @@ def _write_meta(d, meta):
     ssh(f'cat > {d}/meta.json.tmp && mv {d}/meta.json.tmp {d}/meta.json', input=json.dumps(meta, indent=1))
 
 
-def install(apk_path, flatscreen=True, name=None, source=None, icon_png=None):
+def install(apk_path, flatscreen=None, name=None, source=None, icon_png=None):
     info = apk_info(apk_path)
     if icon_png:
         info['icon_png'] = icon_png
@@ -114,7 +120,16 @@ def install(apk_path, flatscreen=True, name=None, source=None, icon_png=None):
     pkg = info['package']
     if not PKG_RE.match(pkg):
         raise FrameError(f'unexpected package name {pkg!r}')
+    if flatscreen is None:
+        flatscreen = not info['vr']
     with _install_lock:
+        if not info['launchable'] and info['vr_activity']:
+            with tempfile.TemporaryDirectory(prefix='frame-vr-') as tmp:
+                patched = os.path.join(tmp, 'app.apk')
+                patch(apk_path, patched)
+                info['patched'] = ['launcher']
+                info['launchable'] = True
+                return _install(patched, info, pkg, flatscreen, name, source or os.path.basename(apk_path))
         return _install(apk_path, info, pkg, flatscreen, name, source)
 
 
@@ -143,6 +158,8 @@ def _install(apk_path, info, pkg, flatscreen, name, source):
                 raise FrameError(f'Steam did not return a shortcut id (got {reply[:80]!r})')
         meta = {'package': pkg, 'label': name or info['label'], 'version': info['version'],
                 'instance': iid, 'shortcut': shortcut, 'game_id': game_id(shortcut),
+                'vr': info.get('vr', False), 'vr_issues': info.get('vr_issues', []),
+                'launchable': info.get('launchable', False), 'patched': info.get('patched', []),
                 'flatscreen': flatscreen, 'installed': time.strftime('%Y-%m-%dT%H:%M:%S'),
                 'source': source or os.path.basename(apk_path)}
         _write_meta(d, meta)
@@ -273,11 +290,46 @@ def probe(pkg, wait=20):
             'container_up': ctr in running_instances()}
 
 
+def patch(src, dst, add=None):
+    try:
+        info = apk_info(src)
+        with zipfile.ZipFile(src) as z:
+            original = frame_apk._read(z, 'AndroidManifest.xml', frame_apk.MAX_MANIFEST)
+        manifest = add_launcher_category(original) if info['vr_activity'] else original
+        if not info['launchable'] and not info['vr_activity']:
+            raise FrameError('APK has no MAIN/LAUNCHER or patchable VR activity')
+        repack(src, dst, replace={'AndroidManifest.xml': manifest}, add=add)
+        result = apk_info(dst)
+        result.pop('icon_png', None)
+        result['patched'] = ['launcher'] if manifest != original else []
+        return result
+    except (OSError, ValueError, zipfile.BadZipFile, frame_apk.ApkError) as e:
+        raise FrameError(str(e)) from e
+
+
 def main():
     cmd, *args = sys.argv[1:] or ['help']
     try:
         if cmd == 'install':
-            r = install(args[0], flatscreen='--vr' not in args)
+            r = install(args[0], flatscreen=False if '--vr' in args else True if '--flat' in args else None)
+        elif cmd in ('info', 'describe'):
+            r = apk_info(args[0])
+            r.pop('icon_png', None)
+        elif cmd == 'patch':
+            import argparse
+            parser = argparse.ArgumentParser(description='Patch and v2-sign an APK locally')
+            parser.add_argument('src')
+            parser.add_argument('dst')
+            parser.add_argument('--add', action='append', default=[], metavar='NAME=PATH')
+            opts = parser.parse_args(args)
+            additions = {}
+            for item in opts.add:
+                if '=' not in item:
+                    raise FrameError('--add requires NAME=PATH')
+                entry, path = item.split('=', 1)
+                with open(path, 'rb') as f:
+                    additions[entry] = f.read()
+            r = patch(opts.src, opts.dst, additions)
         elif cmd == 'list':
             r = list_apps()
         elif cmd in ('launch', 'stop', 'probe'):
@@ -286,7 +338,7 @@ def main():
             r = remove(args[0], keep_data='--keep-data' in args)
         else:
             sys.exit(__doc__)
-    except FrameError as e:
+    except (FrameError, OSError) as e:
         sys.exit(f'error: {e}')
     print(json.dumps(r, indent=1))
 
diff --git a/ui/frame_apk.py b/ui/frame_apk.py
index 943af2a..541b321 100644
--- a/ui/frame_apk.py
+++ b/ui/frame_apk.py
@@ -10,7 +10,7 @@ import zipfile
 
 # android: attribute resource ids; names can be stripped by shrinkers, ids can't.
 ATTR = {0x01010001: 'label', 0x01010002: 'icon', 0x01010003: 'name',
-        0x0101021b: 'versionCode', 0x0101021c: 'versionName', 0x0101020c: 'minSdkVersion'}
+        0x01010024: 'value', 0x0101021b: 'versionCode', 0x0101021c: 'versionName', 0x0101020c: 'minSdkVersion'}
 T_REF, T_STRING, T_INT_DEC, T_INT_HEX = 0x01, 0x03, 0x10, 0x11
 # APKs can come from websites (install links), so nothing read from one may be
 # unbounded. zipfile stops at a member's declared size, so checking it is enough.
@@ -215,8 +215,11 @@ def apk_info(path):
         if 'AndroidManifest.xml' not in names:
             raise ApkError('not an APK: no AndroidManifest.xml')
         try:
-            elements = manifest_elements(_read(z, 'AndroidManifest.xml', MAX_MANIFEST))
+            manifest_data = _read(z, 'AndroidManifest.xml', MAX_MANIFEST)
+            elements = manifest_elements(manifest_data)
             res = Resources(_read(z, 'resources.arsc', MAX_ARSC) if 'resources.arsc' in names else b'')
+            from frame_apk_vr import detection
+            vr_info = detection(manifest_data, names)
         except (struct.error, IndexError, zipfile.BadZipFile) as e:
             raise ApkError(f'could not read the APK manifest: {e}')
         tags = {}
@@ -235,6 +238,7 @@ def apk_info(path):
             'min_sdk': min_sdk[1] if min_sdk and min_sdk[0] in (T_INT_DEC, T_INT_HEX) else None,
             'icon_png': None,
         }
+        info.update(vr_info)
         try:
             info['icon_png'] = _icon_png(z, names, _icons(app.get('icon'), res))
         except Exception:  # noqa: BLE001 - any unreadable icon just means no icon
diff --git a/ui/frame_apk_sign.py b/ui/frame_apk_sign.py
new file mode 100644
index 0000000..091820d
--- /dev/null
+++ b/ui/frame_apk_sign.py
@@ -0,0 +1,356 @@
+"""Lossless ZIP repacking and APK v2 RSA/SHA-256 signing, Python 3.9 stdlib.
+
+Spec: https://source.android.com/docs/security/features/apksigning/v2
+Sections: APK Signing Block; APK Signature Scheme v2 Block; Integrity-protected
+contents; Verification. No verity algorithm is used, so no verity padding.
+"""
+import hashlib
+import io
+import json
+import math
+import os
+from pathlib import Path
+import re
+import secrets
+import struct
+import tempfile
+import zipfile
+import zlib
+
+import frame_host
+
+MAGIC = b'APK Sig Block 42'
+V2 = 0x7109871a
+ALG = 0x0103
+SHA256_DER = bytes.fromhex('3031300d060960864801650304020105000420')
+
+
+def u32(n):
+    return struct.pack('<I', n)
+
+
+def lp(b):
+    return u32(len(b)) + b
+
+
+def der(tag, b):
+    n = len(b)
+    length = bytes([n]) if n < 128 else bytes([128 + (n.bit_length() + 7) // 8]) + n.to_bytes((n.bit_length() + 7) // 8, 'big')
+    return bytes([tag]) + length + b
+
+
+def integer(n):
+    b = n.to_bytes((n.bit_length() + 7) // 8 or 1, 'big')
+    return der(2, (b'\0' if b[0] & 128 else b'') + b)
+
+
+def sequence(*items):
+    return der(0x30, b''.join(items))
+
+
+RSA_ALG = bytes.fromhex('300d06092a864886f70d0101010500')
+CERT_ALG = bytes.fromhex('300d06092a864886f70d01010b0500')
+
+
+def public_key(key):
+    return sequence(RSA_ALG, der(3, b'\0' + sequence(integer(key['n']), integer(key['e']))))
+
+
+def encoded_hash(data, size):
+    digest = SHA256_DER + hashlib.sha256(data).digest()
+    return b'\0\1' + b'\xff' * (size - len(digest) - 3) + b'\0' + digest
+
+
+def rsa_sign(data, key):
+    size = (key['n'].bit_length() + 7) // 8
+    return pow(int.from_bytes(encoded_hash(data, size), 'big'), key['d'], key['n']).to_bytes(size, 'big')
+
+
+def rsa_verify(data, sig, n, e):
+    size = (n.bit_length() + 7) // 8
+    if len(sig) != size or int.from_bytes(sig, 'big') >= n:
+        raise ValueError('invalid RSA signature size/value')
+    actual = pow(int.from_bytes(sig, 'big'), e, n).to_bytes(size, 'big')
+    if actual != encoded_hash(data, size):
+        raise ValueError('RSA signature mismatch')
+
+
+def certificate(key):
+    name = sequence(der(0x31, sequence(bytes.fromhex('0603550403'), der(12, b'Frame Control APK signer'))))
+    validity = sequence(der(0x17, b'200101000000Z'), der(0x18, b'21200101000000Z'))
+    tbs = sequence(der(0xa0, integer(2)), integer(1), CERT_ALG, name, validity, name, public_key(key))
+    return sequence(tbs, CERT_ALG, der(3, b'\0' + rsa_sign(tbs, key)))
+
+
+def _prime(bits):
+    small = (3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47)
+    while True:
+        n = secrets.randbits(bits) | (3 << (bits - 2)) | 1
+        if any(n % p == 0 for p in small) or (n - 1) % 65537 == 0:
+            continue
+        d, s = n - 1, 0
+        while d % 2 == 0:
+            d //= 2
+            s += 1
+        for _ in range(40):  # Miller-Rabin error bound <= 2^-80
+            x = pow(secrets.randbelow(n - 3) + 2, d, n)
+            if x in (1, n - 1):
+                continue
+            for _ in range(s - 1):
+                x = pow(x, 2, n)
+                if x == n - 1:
+                    break
+            else:
+                break
+        else:
+            return n
+
+
+def signing_key(path=None):
+    """Persistent identity in app data, never an evictable cache. Atomic publication.
+
+    Hard-linking a fully written private temp file prevents concurrent first-use
+    callers from selecting different identities or reading a partial key.
+    """
+    path = Path(path) if path is not None else frame_host.data_dir('apk-signing-key.json')
+    if not path.exists():
+        p, q = _prime(1024), _prime(1024)
+        while q == p:
+            q = _prime(1024)
+        key = {'n': p * q, 'e': 65537, 'd': pow(65537, -1, math.lcm(p - 1, q - 1))}
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(prefix='.apk-key-', dir=str(path.parent))
+        try:
+            with os.fdopen(fd, 'w') as f:
+                json.dump(key, f)
+                f.flush()
+                os.fsync(f.fileno())
+            try:
+                os.link(tmp, path)
+            except FileExistsError:
+                pass
+        finally:
+            os.unlink(tmp)
+    os.chmod(path, 0o600)
+    key = json.loads(path.read_text())
+    if key['n'].bit_length() != 2048 or key['e'] != 65537:
+        raise ValueError('invalid cached APK signing key')
+    rsa_verify(b'key check', rsa_sign(b'key check', key), key['n'], key['e'])
+    return key
+
+
+def _eocd(data):
+    # ZIP comments can contain the EOCD signature; accept only an exact EOF fit.
+    for at in range(len(data) - 22, max(-1, len(data) - 65558), -1):
+        if data[at:at + 4] == b'PK\5\6' and at + 22 + struct.unpack_from('<H', data, at + 20)[0] == len(data):
+            disk, cd_disk, count_disk, count, size, cd = struct.unpack_from('<HHHHII', data, at + 4)
+            if disk or cd_disk or count_disk != count or count == 65535 or cd + size != at:
+                raise ValueError('multi-disk/ZIP64 or invalid APK directory')
+            return at, cd
+    raise ValueError('missing ZIP end record')
+
+
+def content_digest(sections):
+    chunks = []
+    for section in sections:
+        for off in range(0, len(section), 1024 * 1024):
+            part = section[off:off + 1024 * 1024]
+            chunks.append(hashlib.sha256(b'\xa5' + u32(len(part)) + part).digest())
+    return hashlib.sha256(b'\x5a' + u32(len(chunks)) + b''.join(chunks)).digest()
+
+
+def sign_apk(data, key):
+    eo, cd = _eocd(data)
+    digest = content_digest((memoryview(data)[:cd], memoryview(data)[cd:eo], data[eo:]))
+    signed = lp(lp(u32(ALG) + lp(digest))) + lp(lp(certificate(key))) + lp(b'')
+    signer = lp(signed) + lp(lp(u32(ALG) + lp(rsa_sign(signed, key)))) + lp(public_key(key))
+    value = lp(lp(signer))
+    pair = struct.pack('<Q', 4 + len(value)) + u32(V2) + value
+    size = len(pair) + 24
+    block = struct.pack('<Q', size) + pair + struct.pack('<Q', size) + MAGIC
+    end = bytearray(data[eo:])
+    struct.pack_into('<I', end, 16, cd + len(block))
+    return data[:cd] + block + data[cd:eo] + end
+
+
+def _parts(data):
+    result, off = [], 0
+    while off < len(data):
+        if off + 4 > len(data):
+            raise ValueError('truncated length prefix')
+        size = struct.unpack_from('<I', data, off)[0]
+        off += 4
+        if off + size > len(data):
+            raise ValueError('length prefix outside block')
+        result.append(data[off:off + size])
+        off += size
+    return result
+
+
+def _der_parts(data):
+    result, off = [], 0
+    while off < len(data):
+        start = off
+        tag, size = data[off:off + 2]
+        off += 2
+        if size & 128:
+            count = size & 127
+            if not count or count > 4:
+                raise ValueError('invalid DER length')
+            size = int.from_bytes(data[off:off + count], 'big')
+            off += count
+        if off + size > len(data):
+            raise ValueError('truncated DER')
+        result.append((tag, data[off:off + size], data[start:off + size]))
+        off += size
+    return result
+
+
+def _cert_key(cert):
+    outer = _der_parts(cert)
+    if len(outer) != 1 or outer[0][0] != 0x30:
+        raise ValueError('invalid certificate')
+    fields = _der_parts(outer[0][1])
+    tbs = _der_parts(fields[0][1])
+    spki = tbs[6 if tbs[0][0] == 0xa0 else 5][2]
+    pub = _der_parts(_der_parts(spki)[0][1])
+    if pub[0][2] != RSA_ALG or pub[1][1][:1] != b'\0':
+        raise ValueError('certificate is not RSA')
+    numbers = _der_parts(_der_parts(pub[1][1][1:])[0][1])
+    n, e = [int.from_bytes(item[1], 'big') for item in numbers]
+    return n, e, spki
+
+
+def verify(path):
+    """Verify this v2-only format; return True or raise ValueError on corruption.
+
+    A valid signature establishes integrity, not trust in the APK publisher.
+    """
+    data = Path(path).read_bytes()
+    try:
+        eo, cd = _eocd(data)
+        if data[cd - 16:cd] != MAGIC:
+            raise ValueError('no APK signing block')
+        size = struct.unpack_from('<Q', data, cd - 24)[0]
+        start = cd - size - 8
+        if start < 0 or struct.unpack_from('<Q', data, start)[0] != size:
+            raise ValueError('invalid signing block size')
+        off, values = start + 8, []
+        while off < cd - 24:
+            length = struct.unpack_from('<Q', data, off)[0]
+            if length < 4 or off + 8 + length > cd - 24:
+                raise ValueError('invalid signing pair')
+            ident = struct.unpack_from('<I', data, off + 8)[0]
+            if ident == V2:
+                values.append(data[off + 12:off + 8 + length])
+            off += 8 + length
+        if off != cd - 24 or len(values) != 1:
+            raise ValueError('missing or duplicate v2 signer block')
+        end = bytearray(data[eo:])
+        struct.pack_into('<I', end, 16, start)
+        digest = content_digest((memoryview(data)[:start], memoryview(data)[cd:eo], end))
+        wrappers = _parts(values[0])
+        if len(wrappers) != 1:
+            raise ValueError('invalid signers sequence')
+        signers = _parts(wrappers[0])
+        if not signers:
+            raise ValueError('no signers')
+        for signer in signers:
+            signed, signatures, pub = _parts(signer)
+            digests, certs, attrs = _parts(signed)
+            cert = _parts(certs)[0]
+            n, e, cert_pub = _cert_key(cert)
+            if cert_pub != pub:
+                raise ValueError('public key differs from certificate')
+            sigs, digs = _parts(signatures), _parts(digests)
+            if len(sigs) != 1 or len(digs) != 1 or sigs[0][:4] != u32(ALG) or digs[0][:4] != u32(ALG):
+                raise ValueError('unsupported signature algorithm')
+            if _parts(digs[0][4:]) != [digest]:
+                raise ValueError('APK content digest mismatch')
+            sig = _parts(sigs[0][4:])
+            if len(sig) != 1:
+                raise ValueError('invalid signature sequence')
+            rsa_verify(signed, sig[0], n, e)
+        return True
+    except (IndexError, struct.error, OverflowError) as exc:
+        raise ValueError('malformed APK signature: ' + str(exc)) from exc
+
+
+def repack(src, dst, replace=None, add=None, sign=True):
+    """Copy raw compressed members; reconstruct ZIP headers without descriptors.
+
+    Reject ZIP64/encrypted archives. Output is atomically replaced after signing.
+    """
+    replace, add = dict(replace or {}), dict(add or {})
+    central, output = [], io.BytesIO()
+    with open(src, 'rb') as raw, zipfile.ZipFile(raw) as archive:
+        names = archive.namelist()
+        if len(set(names)) != len(names):
+            raise ValueError('duplicate ZIP member names')
+        if set(replace) - set(names) or set(add) & set(names) or set(add) & set(replace):
+            raise ValueError('replace must exist and add must be new')
+        items = archive.infolist() + [zipfile.ZipInfo(name) for name in add]
+        for info in items:
+            name = info.filename
+            if re.match(r'^META-INF/(?:[^/]+\.(?:SF|RSA|EC|DSA)|MANIFEST\.MF)$', name, re.I):
+                continue
+            if info.flag_bits & 1 or info.compress_type not in (0, 8):
+                raise ValueError('unsupported ZIP encryption/compression')
+            method = info.compress_type
+            content = add.get(name) if name in add else replace.get(name)
+            if content is None:
+                raw.seek(info.header_offset)
+                header = raw.read(30)
+                if header[:4] != b'PK\3\4':
+                    raise ValueError('invalid local ZIP header')
+                nl, el = struct.unpack_from('<HH', header, 26)
+                raw.seek(nl + el, 1)
+                compressed = raw.read(info.compress_size)
+                crc, usize = info.CRC, info.file_size
+                if len(compressed) != info.compress_size:
+                    raise ValueError('truncated ZIP member')
+            else:
+                crc, usize = zlib.crc32(content), len(content)
+                if method == 8:
+                    compressor = zlib.compressobj(6, zlib.DEFLATED, -15)
+                    compressed = compressor.compress(content) + compressor.flush()
+                else:
+                    compressed = content
+            encoded = name.encode('utf-8')
+            offset = output.tell()
+            align = 16384 if name.endswith('.so') else 4
+            needs_alignment = method == 0 or name.endswith('.so')
+            padding = (-(offset + 30 + len(encoded) + 6) % align) if needs_alignment else 0
+            # Android zipalign extra: alignment (uint16), then padding bytes.
+            extra = struct.pack('<HHH', 0xd935, padding + 2, align) + bytes(padding) if needs_alignment else b''
+            dt = info.date_time
+            dos_time = (dt[3] << 11) | (dt[4] << 5) | (dt[5] // 2)
+            dos_date = ((dt[0] - 1980) << 9) | (dt[1] << 5) | dt[2]
+            csize = len(compressed)
+            if max(offset, csize, usize) >= 0xffffffff:
+                raise ValueError('ZIP64 APKs are unsupported')
+            output.write(struct.pack('<IHHHHHIIIHH', 0x04034b50, 20, 0x800, method, dos_time, dos_date,
+                                     crc, csize, usize, len(encoded), len(extra)) + encoded + extra + compressed)
+            central.append(struct.pack('<IHHHHHHIIIHHHHHII', 0x02014b50, 0x314, 20, 0x800, method,
+                                       dos_time, dos_date, crc, csize, usize, len(encoded), 0, len(info.comment),
+                                       0, info.internal_attr, info.external_attr, offset) + encoded + info.comment)
+        cd = output.tell()
+        directory = b''.join(central)
+        if len(central) >= 65535 or cd + len(directory) >= 0xffffffff:
+            raise ValueError('ZIP64 APKs are unsupported')
+        output.write(directory)
+        output.write(struct.pack('<IHHHHIIH', 0x06054b50, 0, 0, len(central), len(central), len(directory), cd, len(archive.comment)) + archive.comment)
+    data = output.getvalue()
+    if sign:
+        data = sign_apk(data, signing_key())
+    dst = Path(dst)
+    fd, tmp = tempfile.mkstemp(prefix='.apk-', dir=str(dst.parent))
+    try:
+        with os.fdopen(fd, 'wb') as f:
+            f.write(data)
+        if sign:
+            verify(tmp)
+        os.replace(tmp, dst)
+    finally:
+        if os.path.exists(tmp):
+            os.unlink(tmp)
diff --git a/ui/frame_apk_vr.py b/ui/frame_apk_vr.py
new file mode 100644
index 0000000..6d835f7
--- /dev/null
+++ b/ui/frame_apk_vr.py
@@ -0,0 +1,113 @@
+"""Binary-manifest VR inspection and minimal launcher repair (stdlib only)."""
+import struct
+import frame_apk
+
+MAIN = 'android.intent.action.MAIN'
+LAUNCHER = 'android.intent.category.LAUNCHER'
+VR = {'com.oculus.intent.category.VR', 'org.khronos.openxr.intent.category.IMMERSIVE_HMD'}
+
+
+def inspect(data):
+    elements = iter(frame_apk.manifest_elements(data))
+    stack, filters, samsung = [], [], False
+    current = None
+    for kind, hs, off, size in frame_apk._chunks(data, 8, len(data)):
+        if kind == 0x0102:
+            tag, attrs = next(elements)
+            value = attrs.get('name', (None, None, None))[2]
+            if tag == 'intent-filter' and stack and stack[-1] in ('activity', 'activity-alias'):
+                current = {'actions': set(), 'categories': set(), 'templates': []}
+            if current is not None and stack and stack[-1] == 'intent-filter':
+                if tag == 'action':
+                    current['actions'].add(value)
+                if tag == 'category':
+                    current['categories'].add(value)
+                    current['templates'].append((off, size, hs))
+            if tag == 'meta-data' and stack and stack[-1] == 'application':
+                samsung |= value == 'com.samsung.android.vr.application.mode' and attrs.get('value', (0, 0, None))[2] == 'vr_only'
+            stack.append(tag)
+        elif kind == 0x0103 and stack:
+            tag = stack.pop()
+            if tag == 'intent-filter' and current is not None:
+                current['end'] = off
+                filters.append(current)
+                current = None
+    mains = [f for f in filters if MAIN in f['actions']]
+    vr_filters = [f for f in mains if VR & f['categories']]
+    return {'launchable': any(LAUNCHER in f['categories'] for f in mains),
+            'vr_activity': bool(vr_filters), 'vr': bool(vr_filters) or samsung}, vr_filters
+
+
+def _append_string(chunk, text):
+    _, hs, size, count, styles, flags, start, style_start = struct.unpack_from('<HHIIIIII', chunk)
+    strings_end = style_start or size
+    encoded = text.encode('utf-8' if flags & 0x100 else 'utf-16-le')
+    # LAUNCHER is short enough for both single-unit length encodings.
+    new = (bytes([len(text), len(encoded)]) + encoded + b'\0' if flags & 0x100
+           else struct.pack('<H', len(text)) + encoded + b'\0\0')
+    string_data = chunk[start:strings_end] + new
+    string_data += bytes(-len(string_data) % 4)
+    header = bytearray(chunk[:hs])
+    new_start = start + 4
+    new_styles = new_start + len(string_data) if style_start else 0
+    body = (chunk[hs:hs + count * 4] + struct.pack('<I', strings_end - start)
+            + chunk[hs + count * 4:start] + string_data + (chunk[style_start:] if style_start else b''))
+    struct.pack_into('<IIIII', header, 8, count + 1, styles, flags & ~1, new_start, new_styles)
+    struct.pack_into('<I', header, 4, len(header) + len(body))
+    return bytes(header) + body, count
+
+
+def add_launcher_category(axml_bytes):
+    info, filters = inspect(axml_bytes)
+    if info['launchable']:
+        return axml_bytes
+    if not filters:
+        raise frame_apk.ApkError('no VR activity with a MAIN intent filter to patch')
+    target = filters[0]
+    chunks = list(frame_apk._chunks(axml_bytes, 8, len(axml_bytes)))
+    pool = next(c for c in chunks if c[0] == 1)
+    _, _, po, ps = pool
+    new_pool, index = _append_string(axml_bytes[po:po + ps], LAUNCHER)
+    off, size, hs = target['templates'][0]
+    start = bytearray(axml_bytes[off:off + size])
+    attr_start, attr_size, count = struct.unpack_from('<HHH', start, hs + 8)
+    strings = frame_apk._string_pool(axml_bytes, po)
+    resmap = []
+    for kind, header_size, offset, chunk_size in chunks:
+        if kind == 0x180:
+            resmap = struct.unpack_from('<%dI' % ((chunk_size - header_size) // 4),
+                                        axml_bytes, offset + header_size)
+    for i in range(count):
+        a = hs + attr_start + i * attr_size
+        name = struct.unpack_from('<I', start, a + 4)[0]
+        if (name < len(resmap) and resmap[name] == 0x01010003) or strings[name] == 'name':
+            struct.pack_into('<I', start, a + 8, index)
+            struct.pack_into('<HBBI', start, a + 12, 8, 0, 3, index)
+            break
+    else:
+        raise frame_apk.ApkError('VR category has no name attribute')
+    end = struct.pack('<HHI', 0x0103, hs, hs + 8) + start[8:hs] + start[hs:hs + 8]
+    result = bytearray(axml_bytes[:8])
+    for _, _, off, size in chunks:
+        if off == target['end']:
+            result += start + end
+        result += new_pool if off == po else axml_bytes[off:off + size]
+    struct.pack_into('<I', result, 4, len(result))
+    result = bytes(result)
+    if not inspect(result)[0]['launchable']:
+        raise frame_apk.ApkError('launcher repair failed verification')
+    return result
+
+
+def detection(data, names):
+    info, _ = inspect(data)
+    issues = []
+    if 'lib/arm64-v8a/libvrapi.so' in names:
+        issues.append("Uses Meta's legacy VrApi, which the Frame doesn't have; it won't run.")
+    if any(n.endswith('/libovrplatformloader.so') for n in names):
+        issues.append("Uses Meta's platform SDK; if it checks your Quest store licence it will quit.")
+    if 'lib/arm64-v8a/libopenxr_loader.so' in names:
+        info['vr'] = True
+        issues.append('Uses OpenXR (good).')
+    info['vr_issues'] = issues
+    return info
diff --git a/ui/index.html b/ui/index.html
index 475ea72..11ef38a 100644
--- a/ui/index.html
+++ b/ui/index.html
@@ -473,6 +473,12 @@
         a game's <code>.zip</code>, folder or <code>.exe</code> becomes a title in the Steam library.
         <input type="file" id="fileInput" multiple hidden>
       </div>
+      <label class="sub" for="apkDisplay">Android display</label>
+      <select id="apkDisplay" aria-label="Android app display mode">
+        <option value="auto">Automatic (detect VR)</option>
+        <option value="flat">Flat screen</option>
+        <option value="vr">VR app</option>
+      </select>
       <div class="progress" id="prog"><i></i></div>
       <div class="shelf-head" style="margin-top:16px"><h2>Sideloaded titles</h2><span class="count" id="titleCount"></span></div>
       <div class="list" id="titleList"><div class="sub">Loading…</div></div>
@@ -1138,6 +1144,7 @@ function upload(file, mode) {
     xhr.setRequestHeader("X-Frame-UI", "1");
     xhr.setRequestHeader("X-Filename", encodeURIComponent(file.name));
     xhr.setRequestHeader("X-Mode", mode);
+    if (mode === "apk") xhr.setRequestHeader("X-APK-Display", $("apkDisplay").value);
     const bar = $("prog").firstElementChild;
     $("prog").style.display = "block"; bar.style.width = "0";
     xhr.upload.onprogress = e => { if (e.lengthComputable) bar.style.width = (100 * e.loaded / e.total) + "%"; };
diff --git a/ui/server.py b/ui/server.py
index 05661e3..cff2ed9 100755
--- a/ui/server.py
+++ b/ui/server.py
@@ -1337,10 +1337,16 @@ class Handler(BaseHTTPRequestHandler):
             if mode == "apk":
                 ensure_master()
                 try:
-                    m = frame_android.install(str(dest), source=name)
+                    display = self.headers.get("X-APK-Display", "auto")
+                    if display not in ("auto", "flat", "vr"):
+                        raise frame_android.FrameError("invalid APK display mode")
+                    m = frame_android.install(str(dest), source=name,
+                                              flatscreen=None if display == "auto" else display == "flat")
                 except frame_android.FrameError as e:
                     raise Failure(str(e), 400)
-                return {"message": f"Installed {m['label']} as its own app in the Steam library", "app": m}
+                kind = "VR app" if not m['flatscreen'] else "app"
+                notes = " ".join(m.get("vr_issues", []))
+                return {"message": f"Installed {m['label']} as its own {kind} in the Steam library. {notes}".strip(), "app": m}
             return {"message": push_file(dest)}
         finally:
             if not keep:

From 0dbe18d824aad8f451748886c18c2f68946f9dfc Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 16:24:27 +1000
Subject: [PATCH 03/12] Add APK-local OpenXR 1.1 compatibility layer for Frame

---
 frame/openxr-compat/.gitattributes            |     2 +
 frame/openxr-compat/.gitignore                |     1 +
 frame/openxr-compat/CMakeLists.txt            |    25 +
 frame/openxr-compat/README.md                 |   254 +
 .../XrApiLayer_FRAME_compat.json              |    21 +
 frame/openxr-compat/build.sh                  |    12 +
 frame/openxr-compat/compat_logic.h            |    87 +
 .../evidence/apk-verification.txt             |    29 +
 frame/openxr-compat/evidence/ctest.txt        |     9 +
 frame/openxr-compat/evidence/readelf.txt      |   110 +
 frame/openxr-compat/layer.cpp                 |   272 +
 .../arm64-v8a/libXrApiLayer_FRAME_compat.so   |   Bin 0 -> 98248 bytes
 frame/openxr-compat/tests/compat_tests.cpp    |    70 +
 frame/openxr-compat/tests/dispatch_tests.cpp  |   134 +
 frame/openxr-compat/tests/shims/android/log.h |     9 +
 frame/openxr-compat/tests/shims/jni.h         |     3 +
 frame/openxr-compat/vendor/LICENSE            |   208 +
 .../openxr-compat/vendor/loader_interfaces.h  |   114 +
 frame/openxr-compat/vendor/openxr/openxr.h    | 14911 ++++++++++++++++
 .../vendor/openxr/openxr_platform.h           |   819 +
 .../vendor/openxr/openxr_platform_defines.h   |   114 +
 21 files changed, 17204 insertions(+)
 create mode 100644 frame/openxr-compat/.gitattributes
 create mode 100644 frame/openxr-compat/.gitignore
 create mode 100644 frame/openxr-compat/CMakeLists.txt
 create mode 100644 frame/openxr-compat/README.md
 create mode 100644 frame/openxr-compat/XrApiLayer_FRAME_compat.json
 create mode 100755 frame/openxr-compat/build.sh
 create mode 100644 frame/openxr-compat/compat_logic.h
 create mode 100644 frame/openxr-compat/evidence/apk-verification.txt
 create mode 100644 frame/openxr-compat/evidence/ctest.txt
 create mode 100644 frame/openxr-compat/evidence/readelf.txt
 create mode 100644 frame/openxr-compat/layer.cpp
 create mode 100755 frame/openxr-compat/prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so
 create mode 100644 frame/openxr-compat/tests/compat_tests.cpp
 create mode 100644 frame/openxr-compat/tests/dispatch_tests.cpp
 create mode 100644 frame/openxr-compat/tests/shims/android/log.h
 create mode 100644 frame/openxr-compat/tests/shims/jni.h
 create mode 100644 frame/openxr-compat/vendor/LICENSE
 create mode 100644 frame/openxr-compat/vendor/loader_interfaces.h
 create mode 100644 frame/openxr-compat/vendor/openxr/openxr.h
 create mode 100644 frame/openxr-compat/vendor/openxr/openxr_platform.h
 create mode 100644 frame/openxr-compat/vendor/openxr/openxr_platform_defines.h

diff --git a/frame/openxr-compat/.gitattributes b/frame/openxr-compat/.gitattributes
new file mode 100644
index 0000000..15fc64b
--- /dev/null
+++ b/frame/openxr-compat/.gitattributes
@@ -0,0 +1,2 @@
+# Preserve upstream headers byte-for-byte, including their existing whitespace.
+vendor/** -whitespace
diff --git a/frame/openxr-compat/.gitignore b/frame/openxr-compat/.gitignore
new file mode 100644
index 0000000..cebbcdf
--- /dev/null
+++ b/frame/openxr-compat/.gitignore
@@ -0,0 +1 @@
+/build-*/
diff --git a/frame/openxr-compat/CMakeLists.txt b/frame/openxr-compat/CMakeLists.txt
new file mode 100644
index 0000000..6f75b6b
--- /dev/null
+++ b/frame/openxr-compat/CMakeLists.txt
@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.22)
+project(FrameXrCompat LANGUAGES CXX)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+add_library(compat_logic INTERFACE)
+target_include_directories(compat_logic INTERFACE . vendor)
+if(ANDROID)
+  add_library(XrApiLayer_FRAME_compat SHARED layer.cpp)
+  target_link_libraries(XrApiLayer_FRAME_compat PRIVATE compat_logic log)
+  target_compile_definitions(XrApiLayer_FRAME_compat PRIVATE XR_USE_PLATFORM_ANDROID XR_NO_PROTOTYPES)
+  target_compile_options(XrApiLayer_FRAME_compat PRIVATE -O2 -fvisibility=hidden -Wall -Wextra -Werror)
+  target_link_options(XrApiLayer_FRAME_compat PRIVATE -Wl,-z,max-page-size=16384 -Wl,--no-undefined -Wl,--exclude-libs,ALL -Wl,-s)
+else()
+  enable_testing()
+  add_executable(compat_tests tests/compat_tests.cpp)
+  target_link_libraries(compat_tests PRIVATE compat_logic)
+  target_compile_options(compat_tests PRIVATE -Wall -Wextra -Werror)
+  add_test(NAME compat_logic COMMAND compat_tests)
+  add_executable(dispatch_tests tests/dispatch_tests.cpp)
+  target_link_libraries(dispatch_tests PRIVATE compat_logic)
+  target_include_directories(dispatch_tests PRIVATE tests/shims)
+  target_compile_definitions(dispatch_tests PRIVATE XR_USE_PLATFORM_ANDROID XR_NO_PROTOTYPES)
+  target_compile_options(dispatch_tests PRIVATE -Wall -Wextra -Werror)
+  add_test(NAME layer_dispatch COMMAND dispatch_tests)
+endif()
diff --git a/frame/openxr-compat/README.md b/frame/openxr-compat/README.md
new file mode 100644
index 0000000..6c366c9
--- /dev/null
+++ b/frame/openxr-compat/README.md
@@ -0,0 +1,254 @@
+# Frame OpenXR compatibility API layer
+
+`XR_APILAYER_FRAME_compat` is an APK-local implicit API layer for Steam Frame's
+OpenXR 1.0 Android runtime. It translates selected 1.1 functionality; it is not
+a conformant replacement for a complete 1.1 runtime. Device facts are in
+[../../docs/vr-apks.md](../../docs/vr-apks.md). No headset was contacted during
+implementation. Loading, Valve-layer coexistence, controller usability, and
+Wolvic startup/rendering on Lepton remain **unverified on device**.
+
+## Behavior
+
+- The negotiated `createApiLayerInstance` hook handles `xrCreateInstance`.
+  API requests >= 1.1 become `XR_API_VERSION_1_0` (1.0.63 with these headers),
+  rather than carrying an arbitrary application's patch into the 1.0 request.
+  Requests below 1.1 are unchanged. The loader may reject future API versions
+  before any layer runs.
+- Enumerate downstream extensions through the **next layer's** GIPA before
+  creation. Only advertised promoted extensions are added, with duplicates
+  removed. All other application extensions remain, except the two stubs below.
+  Log added, stubbed and missing extensions with tag `FrameXrCompat`.
+- Missing `XR_KHR_android_thread_settings` is advertised and accepted;
+  `xrSetAndroidApplicationThreadKHR` logs and returns success without changing
+  thread scheduling. Missing `XR_OCULUS_android_session_state_enable` is
+  advertised and accepted, with no commands or additional session behavior.
+  If downstream supports either extension, preserve it and its real commands.
+  Stubbing these capabilities is intentionally limited to accepting the app's
+  request; it does not provide Meta services.
+- The manifest's `instance_extensions` makes both stubs visible during the
+  loader's pre-instance enumeration and validation. The layer also exposes
+  an enumeration implementation with count/capacity handling. Before a next
+  dispatch is available it can enumerate only its own extensions; normal app
+  global enumeration is performed by the loader, merging runtime and manifest
+  entries. See [loader_core.cpp L106–145](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/loader_core.cpp#L106)
+  and [manifest parsing L549–558](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/manifest_file.cpp#L549).
+- Unknown missing extensions are never silently removed. Khronos may reject
+  them **before** entering the layer and name them in `OpenXR-Loader` logs
+  ([loader_instance.cpp L149–176](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/loader_instance.cpp#L149)).
+  If they reach this layer, it logs their names and preserves them for the
+  downstream failure.
+- `xrLocateSpaces` dispatches to `xrLocateSpacesKHR` per session/instance.
+  This is the only command added in 1.1. The three relevant structure types
+  (`SPACES_LOCATE_INFO`, `SPACE_LOCATIONS`, `SPACE_VELOCITIES`) and their KHR
+  versions are **numeric aliases**, and the structs are typedef aliases in
+  these headers. Explicit type conversion of local input/output copies is
+  therefore an identity conversion; the velocity chain passes through without
+  mutating its types or linkage. Output arrays remain shared and receive the
+  runtime's results, including on error; caller struct headers remain intact.
+- With palm pose enabled, rewrite both hand paths ending in
+  `/input/grip_surface/pose` to `/input/palm_ext/pose` in `xrStringToPath` and
+  in binding suggestions (including paths obtained before this layer rewrote
+  them). Unknown paths are left alone.
+- `xrGetInstanceProperties` and unrelated commands pass through. The real
+  runtime's identity is not spoofed. Dispatch tables and session ownership are
+  locked, and removed after successful destruction. Downstream calls occur
+  outside the lock.
+
+## Spec basis and interaction profiles
+
+The pinned [1.1 promotions appendix, versions.adoc L16–156](https://github.com/KhronosGroup/OpenXR-Docs/blob/release-1.1.63/specification/sources/chapters/versions.adoc#L16)
+includes a generated promotion list. Its source is the
+[1.1.63 XML registry](https://github.com/KhronosGroup/OpenXR-Docs/blob/release-1.1.63/specification/registry/xr.xml),
+selecting `extension[@promotedto='XR_VERSION_1_1']`. The full list implemented:
+
+| Promoted extension | Handling |
+| --- | --- |
+| `XR_KHR_locate_spaces` | Enable if advertised; core command alias |
+| `XR_EXT_local_floor` | Enable if advertised; reference-space enum is an alias |
+| `XR_EXT_uuid` | Enable if advertised; type alias, no commands |
+| `XR_EXT_palm_pose` | Enable if advertised; rewrite grip-surface paths |
+| `XR_VARJO_quad_views` | Enable if advertised; view-configuration enum alias, support remains optional |
+| `XR_EXT_samsung_odyssey_controller` | Enable if advertised |
+| `XR_EXT_hp_mixed_reality_controller` | Enable if advertised |
+| `XR_HTC_vive_cosmos_controller_interaction` | Enable if advertised |
+| `XR_HTC_vive_focus3_controller_interaction` | Enable if advertised |
+| `XR_ML_ml2_controller_interaction` | Enable if advertised |
+| `XR_FB_touch_controller_pro` | Enable if advertised; old profile still usable |
+| `XR_META_touch_controller_plus` | Enable if advertised; old profile still usable |
+| `XR_BD_controller_interaction` | Enable if advertised |
+| `XR_KHR_maintenance1` | Enable if advertised (included in the pinned registry's promotion list) |
+
+`XR_EXT_hand_interaction` is **not** promoted to 1.1. Preserve it if requested;
+it is not auto-enabled merely because the runtime advertises it. The parent
+provided its availability; the device notes list extensions non-exhaustively.
+
+The registry's `XR_VERSION_1_1` feature introduces 13 profile paths. For
+Samsung Odyssey, HP mixed reality, HTC Cosmos/Focus3, ML2 and the three
+ByteDance Pico profiles, drop a whole suggestion call with success when the
+corresponding extension is absent. Keep it when the extension is enabled.
+Drop the five new Meta paths: `touch_pro_controller`, `touch_plus_controller`,
+`touch_controller_rift_cv1`, `touch_controller_quest_1_rift_s`, and
+`touch_controller_quest_2`. The verified runtime notes do not list these;
+Pro/Plus promotion also renames several components, so the old extension's
+presence alone does not prove support for the new profile. This layer does
+not implement those component conversions. Existing old Pro/Plus profile
+paths are passed through if the app uses them.
+
+Preserve the documented `oculus/touch_controller`, `khr/simple_controller`,
+`valve/frame_controller` and original PC profile paths. The notes' "usual PC
+controllers" is not a complete enumerated list: availability of promoted PC
+profiles is inferred from the runtime's extension advertisement, not invented
+from that phrase. OpenXR has no general profile enumeration API. Dropping
+suggestions prevents an unsupported 1.1 profile from aborting initialization;
+it does not create bindings, so the app must also suggest a supported fallback.
+
+## Headers and licensing
+
+The required public headers (`openxr.h`, `openxr_platform.h`,
+`openxr_platform_defines.h`) are unmodified from
+[OpenXR-SDK release-1.1.63](https://github.com/KhronosGroup/OpenXR-SDK/tree/release-1.1.63/include/openxr),
+commit [f2448a8](https://github.com/KhronosGroup/OpenXR-SDK/commit/f2448a8797c85814aa892efc1ab8707900fbcc78).
+The requested filename `loader_interfaces.h` no longer exists in 1.1 SDK
+releases: negotiation was ratified and moved to `openxr_loader_negotiation.h`
+in 1.0.33 ([spec history L166–186](https://github.com/KhronosGroup/OpenXR-Docs/blob/release-1.1.63/specification/sources/chapters/versions.adoc#L166)).
+To retain that requested interface filename, the layer uses the unmodified,
+ABI-compatible [last legacy header from SDK-Source release-1.0.32](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.0.32/src/common/loader_interfaces.h).
+Only these four headers are vendored. They offer Apache-2.0 OR MIT; this
+vendoring uses Apache-2.0, reproduced in [vendor/LICENSE](vendor/LICENSE).
+
+## Android discovery and coexistence
+
+**Minimum asset-discovery loader release: 1.0.25 (2022-09-02).** Its
+[release commit, 15c3d8e](https://github.com/KhronosGroup/OpenXR-SDK-Source/commit/15c3d8eb99994e5365d6b6f96eefaf4c51a65a9d)
+explicitly announces APK-packaged API layers;
+[manifest_file.cpp L665–723](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.0.25/src/loader/manifest_file.cpp#L665)
+implements discovery, and [L934–940](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.0.25/src/loader/manifest_file.cpp#L934)
+adds asset manifests after filesystem manifests. This is not a 1.1-only feature.
+
+**For an app requesting API 1.1, use a 1.1 loader (first release 1.1.36) or
+newer.** A 1.0 loader rejects the request before the layer can downgrade it;
+see [loader_core.cpp L217–230](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/loader_core.cpp#L217).
+The runtime can remain 1.0.
+
+Source inspection at release-1.1.63 confirms:
+
+- [manifest_file.cpp L720–783](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/manifest_file.cpp#L720)
+  uses the initialized Android asset manager and scans
+  `openxr/1/api_layers/implicit.d/` for JSON. The application must initialize
+  the loader with its Android context (`xrInitializeLoaderKHR`). In the APK,
+  the entry is `assets/openxr/1/api_layers/implicit.d/XrApiLayer_FRAME_compat.json`.
+- A bare `library_path`, as used here, is **not explicitly concatenated** with
+  `nativeLibraryDir`. [L878–900](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/manifest_file.cpp#L878)
+  leaves a bare name for normal dynamic-linker search in the application's
+  namespace (including its native library directory). Relative paths with a
+  slash use [LocateLibraryInAssets L943–952](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/manifest_file.cpp#L943),
+  which resolves against `GetAndroidNativeLibraryDir()`.
+  [loader_init_data.cpp L87–96](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/loader_init_data.cpp#L87)
+  obtains the asset manager and `ApplicationInfo.nativeLibraryDir` via JNI.
+  Wolvic's supplied manifest has `android:extractNativeLibs="true"`.
+- [android_utilities.cpp L267–322](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/android_utilities.cpp#L267)
+  handles runtime broker discovery, not APK layer discovery. Its
+  `native_lib_dir + so_filename` and `dlopen` refer to the runtime package.
+  They must not be confused with the app's layer library resolution.
+- [manifest_file.cpp L1008–1023](https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/release-1.1.63/src/loader/manifest_file.cpp#L1008)
+  retains filesystem manifests and then appends asset manifests. This leaves
+  `/vendor`'s `XR_APILAYER_VALVE_fdm_injection` discoverable. This layer advances
+  `nextInfo` exactly once, uses next-layer GIPA, preserves the rest of the
+  create-info chain and never opens `vrclient.so` directly. No environment
+  layer-list override or assumed ordering is needed.
+
+`DISABLE_FRAME_XR_COMPAT` is the manifest's disable environment variable.
+Leave it unset to activate the implicit layer. No `enable_environment` is
+required.
+
+## Rebuild and verify
+
+NDK **r30 / 30.0.16248370**, installed at
+`~/Library/Android/ndk/30.0.16248370`, was the latest stable/LTS package shown
+by the [Android download page](https://developer.android.com/ndk/downloads)
+on 2026-09-28. Downloaded
+[android-ndk-r30-darwin.dmg](https://dl.google.com/android/repository/android-ndk-r30-darwin.dmg)
+(1,072,970,961 bytes). The page publishes SHA-1, not SHA-256:
+
+```
+expected: 48591224b6657f46eebbc9d95d4af09bbed8d107
+actual:   48591224b6657f46eebbc9d95d4af09bbed8d107  (PASS)
+```
+
+Mounted read-only with `hdiutil`; copied
+`AndroidNDK16248370.app/Contents/NDK` into that version directory. Despite the
+`darwin-x86_64` toolchain directory name, clang is universal arm64/x86_64 and
+ran on this Apple Silicon Mac.
+
+```sh
+frame/openxr-compat/build.sh
+# Or set ANDROID_NDK_HOME to an installed NDK.
+cmake -S frame/openxr-compat -B frame/openxr-compat/build-host -G Ninja
+cmake --build frame/openxr-compat/build-host
+ctest --test-dir frame/openxr-compat/build-host --output-on-failure
+```
+
+The script produces arm64-v8a / android-24, C++17, `-O2`, static libc++, hidden
+internal symbols, stripped output, and `-Wl,-z,max-page-size=16384`.
+The committed prebuilt is `prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so`.
+Its SHA-256 is recorded below with the APK checks.
+
+[Host test output](evidence/ctest.txt): two tests passed, covering pure logic
+and the actual layer with a fake next layer and host-only log/JNI shims.
+[Full llvm-readelf -d -s -l output](evidence/readelf.txt) records three LOAD
+segments aligned `0x4000`, only `xrNegotiateLoaderApiLayerInterface` exported,
+and only `libc.so`, `libm.so`, `libdl.so`, `liblog.so` as NEEDED libraries.
+All 46 undefined imports are versioned `@LIBC` except `__android_log_print`.
+There is no `libc++_shared.so` dependency and no unstripped `.symtab`.
+
+No independent model review was run: the task explicitly prohibits delegation.
+No `CODING_STANDARDS.md` exists in this worktree or the primary worktree.
+
+## Wolvic injection artifact (Mac only)
+
+Copied `/tmp/vrapk/wq-dec` to `/tmp/vrapk/wq-layer-dec`; retained its existing
+LAUNCHER fix and native-library extraction setting. Added only:
+
+```
+assets/openxr/1/api_layers/implicit.d/XrApiLayer_FRAME_compat.json
+lib/arm64-v8a/libXrApiLayer_FRAME_compat.so
+```
+
+Built using `/tmp/vrapk/jdk/Contents/Home/bin/java` and
+`/tmp/vrapk/apktool_3.0.3.jar`, then signed in place using
+`/tmp/vrapk/uber-apk-signer-1.3.0.jar --overwrite` (embedded debug certificate):
+
+```sh
+/tmp/vrapk/jdk/Contents/Home/bin/java -jar /tmp/vrapk/apktool_3.0.3.jar \
+  b /tmp/vrapk/wq-layer-dec -o /tmp/vrapk/wolvic-quest-compat.apk
+/tmp/vrapk/jdk/Contents/Home/bin/java -jar /tmp/vrapk/uber-apk-signer-1.3.0.jar \
+  -a /tmp/vrapk/wolvic-quest-compat.apk --overwrite
+/tmp/vrapk/jdk/Contents/Home/bin/java -jar /tmp/vrapk/uber-apk-signer-1.3.0.jar \
+  -a /tmp/vrapk/wolvic-quest-compat.apk --onlyVerify
+```
+
+Final APK: `/tmp/vrapk/wolvic-quest-compat.apk` (not committed).
+The bundled `lib/arm64-v8a/libopenxr_loader.so` is byte-for-byte unchanged.
+Its strings include both `openxr/1/api_layers/implicit.d/` and
+`openxr/1/api_layers/explicit.d/`, `AddManifestFilesAndroid` error messages,
+and `xrLocateSpaces`. Thus it contains APK asset discovery and evidence of
+1.1 command support. Its exact upstream release number was not established
+from the binary; runtime execution of those paths remains unverified.
+
+Prebuilt library SHA-256:
+
+```
+57abbcec6fbc6df7c79e2b9a46db1a5d8613b4db3c0d7e49bf87cb3172280d10
+```
+
+APK SHA-256:
+
+```
+355a681625e38b71563dcffecb031799eff27894d6ab910a659bace057e82c1f
+```
+
+Final `--onlyVerify` exited 0: zip alignment verified, v2/v3 signatures
+verified, one APK processed and zero errors. ZIP readback confirmed that the
+injected library and manifest match the committed inputs, the loader is
+unchanged, and the binary Android manifest retains the LAUNCHER category.
+See [APK verification evidence](evidence/apk-verification.txt).
diff --git a/frame/openxr-compat/XrApiLayer_FRAME_compat.json b/frame/openxr-compat/XrApiLayer_FRAME_compat.json
new file mode 100644
index 0000000..143d8e3
--- /dev/null
+++ b/frame/openxr-compat/XrApiLayer_FRAME_compat.json
@@ -0,0 +1,21 @@
+{
+  "file_format_version": "1.0.0",
+  "api_layer": {
+    "name": "XR_APILAYER_FRAME_compat",
+    "library_path": "libXrApiLayer_FRAME_compat.so",
+    "api_version": "1.1",
+    "implementation_version": "1",
+    "description": "Steam Frame OpenXR 1.1 to 1.0 compatibility",
+    "disable_environment": "DISABLE_FRAME_XR_COMPAT",
+    "instance_extensions": [
+      {
+        "name": "XR_KHR_android_thread_settings",
+        "extension_version": "6"
+      },
+      {
+        "name": "XR_OCULUS_android_session_state_enable",
+        "extension_version": "1"
+      }
+    ]
+  }
+}
diff --git a/frame/openxr-compat/build.sh b/frame/openxr-compat/build.sh
new file mode 100755
index 0000000..3b08089
--- /dev/null
+++ b/frame/openxr-compat/build.sh
@@ -0,0 +1,12 @@
+#!/bin/sh
+set -eu
+here=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+ndk=${ANDROID_NDK_HOME:-"$HOME/Library/Android/ndk/30.0.16248370"}
+cmake -S "$here" -B "$here/build-android" -G Ninja \
+  -DCMAKE_TOOLCHAIN_FILE="$ndk/build/cmake/android.toolchain.cmake" \
+  -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-24 \
+  -DANDROID_STL=c++_static -DCMAKE_BUILD_TYPE=Release
+cmake --build "$here/build-android"
+mkdir -p "$here/prebuilt/arm64-v8a"
+cp "$here/build-android/libXrApiLayer_FRAME_compat.so" "$here/prebuilt/arm64-v8a/"
+shasum -a 256 "$here/prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so"
diff --git a/frame/openxr-compat/compat_logic.h b/frame/openxr-compat/compat_logic.h
new file mode 100644
index 0000000..a5c6e57
--- /dev/null
+++ b/frame/openxr-compat/compat_logic.h
@@ -0,0 +1,87 @@
+#pragma once
+#include <openxr/openxr.h>
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace frame {
+using Names = std::vector<std::string>;
+inline constexpr const char* layerName = "XR_APILAYER_FRAME_compat";
+inline constexpr const char* stubs[] = {"XR_KHR_android_thread_settings", "XR_OCULUS_android_session_state_enable"};
+// OpenXR-Docs release-1.1.63 registry: promotedto="XR_VERSION_1_1".
+inline constexpr const char* promotions[] = {
+    "XR_KHR_locate_spaces", "XR_EXT_local_floor", "XR_EXT_uuid", "XR_EXT_palm_pose",
+    "XR_VARJO_quad_views", "XR_EXT_samsung_odyssey_controller", "XR_EXT_hp_mixed_reality_controller",
+    "XR_HTC_vive_cosmos_controller_interaction", "XR_HTC_vive_focus3_controller_interaction",
+    "XR_ML_ml2_controller_interaction", "XR_FB_touch_controller_pro", "XR_META_touch_controller_plus",
+    "XR_BD_controller_interaction", "XR_KHR_maintenance1"};
+inline bool has(const Names& names, const std::string& n) {
+    return std::find(names.begin(), names.end(), n) != names.end();
+}
+inline bool downgrade(XrVersion v) { return v >= XR_MAKE_VERSION(1, 1, 0); }
+inline XrVersion runtimeVersion(XrVersion v) { return downgrade(v) ? XR_API_VERSION_1_0 : v; }
+struct ExtensionPlan { Names downstream, stubbed, missing, added; };
+inline ExtensionPlan extensions(const Names& requested, const Names& available, bool promote) {
+    ExtensionPlan p;
+    for (const auto& n : requested) {
+        if (!has(available, n) && (n == stubs[0] || n == stubs[1])) p.stubbed.push_back(n);
+        else {
+            if (!has(p.downstream, n)) p.downstream.push_back(n);
+            if (!has(available, n)) p.missing.push_back(n);
+        }
+    }
+    if (promote) for (auto n : promotions) if (has(available, n) && !has(p.downstream, n)) {
+        p.downstream.push_back(n); p.added.push_back(n);
+    }
+    return p;
+}
+inline std::string rewritePath(std::string p, bool palm) {
+    const std::string suffix = "/input/grip_surface/pose";
+    if (palm && (p == "/user/hand/left" + suffix || p == "/user/hand/right" + suffix))
+        p.replace(p.size() - suffix.size(), suffix.size(), "/input/palm_ext/pose");
+    return p;
+}
+// Profiles added to 1.1. The three legacy Meta splits have no 1.0 extension.
+// The renamed Pro/Plus profiles have different component semantics; do not
+// claim the old extension implements the new profile merely because it exists.
+inline bool dropProfile(const std::string& p, const Names& enabled) {
+    for (auto name : {"touch_pro_controller", "touch_plus_controller", "touch_controller_rift_cv1",
+                      "touch_controller_quest_1_rift_s", "touch_controller_quest_2"})
+        if (p == std::string("/interaction_profiles/meta/") + name) return true;
+    const char* profiles[][2] = {
+        {"samsung/odyssey_controller", "XR_EXT_samsung_odyssey_controller"},
+        {"hp/mixed_reality_controller", "XR_EXT_hp_mixed_reality_controller"},
+        {"htc/vive_cosmos_controller", "XR_HTC_vive_cosmos_controller_interaction"},
+        {"htc/vive_focus3_controller", "XR_HTC_vive_focus3_controller_interaction"},
+        {"ml/ml2_controller", "XR_ML_ml2_controller_interaction"},
+        {"bytedance/pico_neo3_controller", "XR_BD_controller_interaction"},
+        {"bytedance/pico4_controller", "XR_BD_controller_interaction"},
+        {"bytedance/pico_g3_controller", "XR_BD_controller_interaction"}};
+    for (auto& entry : profiles) if (p == std::string("/interaction_profiles/") + entry[0])
+        return !has(enabled, entry[1]);
+    return false;
+}
+inline XrStructureType extensionType(XrStructureType t) {
+    switch (t) {
+    case XR_TYPE_SPACES_LOCATE_INFO: return XR_TYPE_SPACES_LOCATE_INFO_KHR;
+    case XR_TYPE_SPACE_LOCATIONS: return XR_TYPE_SPACE_LOCATIONS_KHR;
+    case XR_TYPE_SPACE_VELOCITIES: return XR_TYPE_SPACE_VELOCITIES_KHR;
+    default: return t;
+    }
+}
+inline XrResult locate(PFN_xrLocateSpacesKHR next, XrSession session,
+                       const XrSpacesLocateInfo* info, XrSpaceLocations* locations) {
+    if (!info || !locations) return XR_ERROR_VALIDATION_FAILURE;
+    static_assert(XR_TYPE_SPACE_VELOCITIES == XR_TYPE_SPACE_VELOCITIES_KHR);
+    static_assert(XR_TYPE_SPACE_LOCATIONS == XR_TYPE_SPACE_LOCATIONS_KHR);
+    static_assert(XR_TYPE_SPACES_LOCATE_INFO == XR_TYPE_SPACES_LOCATE_INFO_KHR);
+    auto in = *info;
+    auto out = *locations;
+    in.type = extensionType(in.type); out.type = extensionType(out.type);
+    // The enums and typedefs are exact aliases. All chained velocities,
+    // including unknown next structures, can be forwarded without mutation.
+    const auto result = next(session, &in, &out);
+    locations->locationCount = out.locationCount;
+    return result;
+}
+}
diff --git a/frame/openxr-compat/evidence/apk-verification.txt b/frame/openxr-compat/evidence/apk-verification.txt
new file mode 100644
index 0000000..bfed1f5
--- /dev/null
+++ b/frame/openxr-compat/evidence/apk-verification.txt
@@ -0,0 +1,29 @@
+2026-09-28, Mac only; no device connection.
+APK: /tmp/vrapk/wolvic-quest-compat.apk
+SHA-256: 355a681625e38b71563dcffecb031799eff27894d6ab910a659bace057e82c1f
+
+Command:
+/tmp/vrapk/jdk/Contents/Home/bin/java -jar /tmp/vrapk/uber-apk-signer-1.3.0.jar -a /tmp/vrapk/wolvic-quest-compat.apk --onlyVerify
+Exit status: 0
+Relevant output:
+- zipalign verified
+- signature verified [v2, v3]
+Successfully processed 1 APKs and 0 errors in 0.63 seconds.
+
+ZIP readback checks: PASS
+- Injected JSON identical to frame/openxr-compat/XrApiLayer_FRAME_compat.json.
+- Injected SO identical to prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so.
+- Existing libopenxr_loader.so identical to /tmp/vrapk/wq-dec version.
+- Binary AndroidManifest.xml contains android.intent.category.LAUNCHER.
+
+Loader strings present:
+openxr/1/api_layers/implicit.d/
+openxr/1/api_layers/explicit.d/
+ApiLayerManifestFile::AddManifestFilesAndroid unable to open asset
+xrLocateSpaces
+
+NDK: 30.0.16248370 (r30)
+DMG size: 1072970961 bytes
+Download-page SHA-1: 48591224b6657f46eebbc9d95d4af09bbed8d107
+Measured SHA-1:      48591224b6657f46eebbc9d95d4af09bbed8d107
+SHA check: PASS
diff --git a/frame/openxr-compat/evidence/ctest.txt b/frame/openxr-compat/evidence/ctest.txt
new file mode 100644
index 0000000..3e3686d
--- /dev/null
+++ b/frame/openxr-compat/evidence/ctest.txt
@@ -0,0 +1,9 @@
+Test project /Users/saphid/projects/steam-frame-xrlayer/frame/openxr-compat/build-host
+    Start 1: compat_logic
+1/2 Test #1: compat_logic .....................   Passed    0.01 sec
+    Start 2: layer_dispatch
+2/2 Test #2: layer_dispatch ...................   Passed    0.42 sec
+
+100% tests passed out of 2
+
+Total Test time (real) =   0.43 sec
diff --git a/frame/openxr-compat/evidence/readelf.txt b/frame/openxr-compat/evidence/readelf.txt
new file mode 100644
index 0000000..67a0dbe
--- /dev/null
+++ b/frame/openxr-compat/evidence/readelf.txt
@@ -0,0 +1,110 @@
+
+Elf file type is DYN (Shared object file)
+Entry point 0x0
+There are 9 program headers, starting at offset 64
+
+Program Headers:
+  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+  PHDR           0x000040 0x0000000000000040 0x0000000000000040 0x0001f8 0x0001f8 R   0x8
+  LOAD           0x000000 0x0000000000000000 0x0000000000000000 0x0169e0 0x0169e0 R E 0x4000
+  LOAD           0x0169e0 0x000000000001a9e0 0x000000000001a9e0 0x000a90 0x001620 RW  0x4000
+  LOAD           0x017470 0x000000000001f470 0x000000000001f470 0x000068 0x000bc0 RW  0x4000
+  DYNAMIC        0x017048 0x000000000001b048 0x000000000001b048 0x0001c0 0x0001c0 RW  0x8
+  GNU_RELRO      0x0169e0 0x000000000001a9e0 0x000000000001a9e0 0x000a90 0x001620 R   0x1
+  GNU_EH_FRAME   0x004fb4 0x0000000000004fb4 0x0000000000004fb4 0x00070c 0x00070c R   0x4
+  GNU_STACK      0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0x0
+  NOTE           0x000238 0x0000000000000238 0x0000000000000238 0x0000bc 0x0000bc R   0x4
+
+ Section to Segment mapping:
+  Segment Sections...
+   00
+   01     .note.android.ident .note.gnu.build-id .dynsym .gnu.version .gnu.version_r .gnu.hash .dynstr .rela.dyn .rela.plt .gcc_except_table .rodata .eh_frame_hdr .eh_frame .text __lcxx_override .plt
+   02     .data.rel.ro .fini_array .init_array .dynamic .got .got.plt .relro_padding
+   03     .data .bss
+   04     .dynamic
+   05     .data.rel.ro .fini_array .init_array .dynamic .got .got.plt .relro_padding
+   06     .eh_frame_hdr
+   07
+   08     .note.android.ident .note.gnu.build-id
+   None   .comment .shstrtab
+Dynamic section at offset 0x17048 contains 28 entries:
+  Tag                Type           Name/Value
+  0x0000000000000001 (NEEDED)       Shared library: [liblog.so]
+  0x0000000000000001 (NEEDED)       Shared library: [libm.so]
+  0x0000000000000001 (NEEDED)       Shared library: [libdl.so]
+  0x0000000000000001 (NEEDED)       Shared library: [libc.so]
+  0x000000000000000e (SONAME)       Library soname: [libXrApiLayer_FRAME_compat.so]
+  0x000000000000001e (FLAGS)        BIND_NOW
+  0x000000006ffffffb (FLAGS_1)      NOW
+  0x0000000000000007 (RELA)         0xae8
+  0x0000000000000008 (RELASZ)       5424 (bytes)
+  0x0000000000000009 (RELAENT)      24 (bytes)
+  0x000000006ffffff9 (RELACOUNT)    225
+  0x0000000000000017 (JMPREL)       0x2018
+  0x0000000000000002 (PLTRELSZ)     1080 (bytes)
+  0x0000000000000003 (PLTGOT)       0x1b2f0
+  0x0000000000000014 (PLTREL)       RELA
+  0x0000000000000006 (SYMTAB)       0x2f8
+  0x000000000000000b (SYMENT)       24 (bytes)
+  0x0000000000000005 (STRTAB)       0x838
+  0x000000000000000a (STRSZ)        681 (bytes)
+  0x000000006ffffef5 (GNU_HASH)     0x818
+  0x0000000000000019 (INIT_ARRAY)   0x1b030
+  0x000000000000001b (INIT_ARRAYSZ) 24 (bytes)
+  0x000000000000001a (FINI_ARRAY)   0x1b020
+  0x000000000000001c (FINI_ARRAYSZ) 16 (bytes)
+  0x000000006ffffff0 (VERSYM)       0x778
+  0x000000006ffffffe (VERNEED)      0x7d8
+  0x000000006fffffff (VERNEEDNUM)   2
+  0x0000000000000000 (NULL)         0x0
+
+Symbol table '.dynsym' contains 48 entries:
+   Num:    Value          Size Type    Bind   Vis       Ndx Name
+     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND
+     1: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND __cxa_finalize@LIBC
+     2: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND __cxa_atexit@LIBC
+     3: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND strcmp@LIBC
+     4: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND __android_log_print
+     5: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND __stack_chk_fail@LIBC
+     6: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND memmove@LIBC
+     7: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND strlen@LIBC
+     8: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND memcpy@LIBC
+     9: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND __strcpy_chk@LIBC
+    10: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND memset@LIBC
+    11: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND memcmp@LIBC
+    12: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_mutex_lock@LIBC
+    13: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_mutex_unlock@LIBC
+    14: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND __errno@LIBC
+    15: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND snprintf@LIBC
+    16: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_mutex_destroy@LIBC
+    17: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND strerror_r@LIBC
+    18: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND abort@LIBC
+    19: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_getspecific@LIBC
+    20: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_setspecific@LIBC
+    21: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_key_create@LIBC
+    22: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND syscall@LIBC
+    23: 0000000000000000     0 OBJECT  GLOBAL DEFAULT   UND __sF@LIBC
+    24: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND fwrite@LIBC
+    25: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND vfprintf@LIBC
+    26: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND fputc@LIBC
+    27: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND vasprintf@LIBC
+    28: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND android_set_abort_message@LIBC
+    29: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND openlog@LIBC
+    30: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND syslog@LIBC
+    31: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND closelog@LIBC
+    32: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND malloc@LIBC
+    33: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND free@LIBC
+    34: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND posix_memalign@LIBC
+    35: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND realloc@LIBC
+    36: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_once@LIBC
+    37: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_key_delete@LIBC
+    38: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND getauxval@LIBC
+    39: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND __system_property_get@LIBC
+    40: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND strncmp@LIBC
+    41: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND fprintf@LIBC
+    42: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND fflush@LIBC
+    43: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_rwlock_wrlock@LIBC
+    44: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_rwlock_unlock@LIBC
+    45: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND dl_iterate_phdr@LIBC
+    46: 0000000000000000     0 FUNC    GLOBAL DEFAULT   UND pthread_rwlock_rdlock@LIBC
+    47: 00000000000081a0   284 FUNC    GLOBAL DEFAULT    14 xrNegotiateLoaderApiLayerInterface
diff --git a/frame/openxr-compat/layer.cpp b/frame/openxr-compat/layer.cpp
new file mode 100644
index 0000000..3d6f9df
--- /dev/null
+++ b/frame/openxr-compat/layer.cpp
@@ -0,0 +1,272 @@
+#include "compat_logic.h"
+#include <loader_interfaces.h>
+#include <jni.h>
+#include <openxr/openxr_platform.h>
+#include <android/log.h>
+#include <cstring>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+#define LOG(...) __android_log_print(ANDROID_LOG_INFO, "FrameXrCompat", __VA_ARGS__)
+#define GUARD_END catch (const std::bad_alloc&) { return XR_ERROR_OUT_OF_MEMORY; } catch (...) { return XR_ERROR_RUNTIME_FAILURE; }
+namespace {
+struct Dispatch {
+    PFN_xrGetInstanceProcAddr gipa{};
+    PFN_xrDestroyInstance destroy{};
+    PFN_xrCreateSession createSession{};
+    PFN_xrDestroySession destroySession{};
+    PFN_xrLocateSpacesKHR locate{};
+    PFN_xrStringToPath stringToPath{};
+    PFN_xrPathToString pathToString{};
+    PFN_xrSuggestInteractionProfileBindings suggest{};
+    PFN_xrSetAndroidApplicationThreadKHR thread{};
+    frame::Names enabled, stubbed;
+    XrInstance instance{};
+    bool promote{}, palm{};
+};
+std::mutex mutex;
+std::unordered_map<XrInstance, std::shared_ptr<Dispatch>> instances;
+std::unordered_map<XrSession, std::shared_ptr<Dispatch>> sessions;
+// No runtime library is opened here: every call goes through the next layer.
+PFN_xrEnumerateInstanceExtensionProperties enumerateNext{};
+template<class T> T proc(PFN_xrGetInstanceProcAddr gipa, XrInstance i, const char* name) {
+    PFN_xrVoidFunction f{};
+    if (XR_FAILED(gipa(i, name, &f))) return nullptr;
+    return reinterpret_cast<T>(f);
+}
+std::shared_ptr<Dispatch> get(XrInstance i) {
+    std::lock_guard<std::mutex> lock(mutex);
+    auto it = instances.find(i); return it == instances.end() ? nullptr : it->second;
+}
+std::shared_ptr<Dispatch> get(XrSession s) {
+    std::lock_guard<std::mutex> lock(mutex);
+    auto it = sessions.find(s); return it == sessions.end() ? nullptr : it->second;
+}
+XrResult properties(PFN_xrEnumerateInstanceExtensionProperties fn,
+                    std::vector<XrExtensionProperties>& out) {
+    if (!fn) return XR_ERROR_FUNCTION_UNSUPPORTED;
+    for (int attempt = 0; attempt < 4; ++attempt) {
+        uint32_t n{};
+        auto r = fn(nullptr, 0, &n, nullptr);
+        if (XR_FAILED(r)) return r;
+        out.assign(n, {XR_TYPE_EXTENSION_PROPERTIES, nullptr, {}, 0});
+        if (!n) return XR_SUCCESS;
+        r = fn(nullptr, n, &n, out.data());
+        if (r == XR_ERROR_SIZE_INSUFFICIENT) continue;
+        if (XR_FAILED(r)) return r;
+        out.resize(n); return XR_SUCCESS;
+    }
+    return XR_ERROR_RUNTIME_FAILURE;
+}
+XrResult XRAPI_CALL enumerate(const char* layer, uint32_t capacity, uint32_t* count,
+                              XrExtensionProperties* output) try {
+    if (!count || (capacity && !output)) return XR_ERROR_VALIDATION_FAILURE;
+    const bool own = layer && std::strcmp(layer, frame::layerName) == 0;
+    PFN_xrEnumerateInstanceExtensionProperties next;
+    { std::lock_guard<std::mutex> lock(mutex); next = enumerateNext; }
+    if (layer && *layer && !own) return next ? next(layer, capacity, count, output) : XR_ERROR_API_LAYER_NOT_PRESENT;
+    std::vector<XrExtensionProperties> all;
+    if (!own && next) {
+        auto r = properties(next, all); if (XR_FAILED(r)) return r;
+    }
+    for (unsigned i = 0; i < 2; ++i) {
+        bool found = false;
+        for (auto& e : all) if (!std::strcmp(e.extensionName, frame::stubs[i])) found = true;
+        if (!found) {
+            XrExtensionProperties p{XR_TYPE_EXTENSION_PROPERTIES, nullptr, {}, i == 0 ? XR_KHR_android_thread_settings_SPEC_VERSION : 1u};
+            std::strcpy(p.extensionName, frame::stubs[i]); all.push_back(p);
+        }
+    }
+    *count = static_cast<uint32_t>(all.size());
+    LOG("enumerate extensions: %u (includes stubs)", *count);
+    if (!capacity) return XR_SUCCESS;
+    if (capacity < all.size()) return XR_ERROR_SIZE_INSUFFICIENT;
+    for (size_t i = 0; i < all.size(); ++i) {
+        if (output[i].type != XR_TYPE_EXTENSION_PROPERTIES) return XR_ERROR_VALIDATION_FAILURE;
+        std::strcpy(output[i].extensionName, all[i].extensionName);
+        output[i].extensionVersion = all[i].extensionVersion;
+    }
+    return XR_SUCCESS;
+} GUARD_END
+XrResult XRAPI_CALL destroyInstance(XrInstance i) try {
+    auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
+    auto r = d->destroy(i);
+    if (XR_SUCCEEDED(r)) {
+        std::lock_guard<std::mutex> lock(mutex);
+        for (auto it = sessions.begin(); it != sessions.end();) {
+            if (it->second == d) it = sessions.erase(it); else ++it;
+        }
+        instances.erase(i);
+        if (instances.empty()) enumerateNext = nullptr;
+    }
+    return r;
+} GUARD_END
+XrResult XRAPI_CALL createSession(XrInstance i, const XrSessionCreateInfo* info, XrSession* s) try {
+    auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
+    auto r = d->createSession(i, info, s);
+    if (XR_SUCCEEDED(r)) {
+        try { std::lock_guard<std::mutex> lock(mutex); sessions.emplace(*s, d); }
+        catch (...) { d->destroySession(*s); *s = XR_NULL_HANDLE; throw; }
+    }
+    return r;
+} GUARD_END
+XrResult XRAPI_CALL destroySession(XrSession s) try {
+    auto d = get(s); if (!d) return XR_ERROR_HANDLE_INVALID;
+    auto r = d->destroySession(s);
+    if (XR_SUCCEEDED(r)) { std::lock_guard<std::mutex> lock(mutex); sessions.erase(s); }
+    return r;
+} GUARD_END
+XrResult XRAPI_CALL locateSpaces(XrSession s, const XrSpacesLocateInfo* in, XrSpaceLocations* out) try {
+    auto d = get(s); if (!d) return XR_ERROR_HANDLE_INVALID;
+    if (!d->locate) return XR_ERROR_FUNCTION_UNSUPPORTED;
+    LOG("xrLocateSpaces -> xrLocateSpacesKHR (core/KHR type aliases)");
+    return frame::locate(d->locate, s, in, out);
+} GUARD_END
+XrResult XRAPI_CALL threadSettings(XrSession s, XrAndroidThreadTypeKHR type, uint32_t tid) try {
+    auto d = get(s); if (!d) return XR_ERROR_HANDLE_INVALID;
+    if (frame::has(d->stubbed, frame::stubs[0])) {
+        LOG("stub xrSetAndroidApplicationThreadKHR type=%d tid=%u -> XR_SUCCESS (no scheduling change)", type, tid);
+        return XR_SUCCESS;
+    }
+    return d->thread ? d->thread(s, type, tid) : XR_ERROR_FUNCTION_UNSUPPORTED;
+} GUARD_END
+XrResult XRAPI_CALL stringToPath(XrInstance i, const char* path, XrPath* out) try {
+    auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
+    if (!path) return XR_ERROR_VALIDATION_FAILURE;
+    auto rewritten = frame::rewritePath(path, d->palm);
+    if (rewritten != path) LOG("path %s -> %s", path, rewritten.c_str());
+    return d->stringToPath(i, rewritten.c_str(), out);
+} GUARD_END
+XrResult pathString(const Dispatch& d, XrPath path, std::string& out) {
+    uint32_t n{};
+    auto r = d.pathToString(d.instance, path, 0, &n, nullptr);
+    if (XR_FAILED(r)) return r;
+    std::vector<char> text(n);
+    r = d.pathToString(d.instance, path, n, &n, text.data());
+    if (XR_SUCCEEDED(r)) out.assign(text.data());
+    return r;
+}
+XrResult XRAPI_CALL suggest(XrInstance i, const XrInteractionProfileSuggestedBinding* info) try {
+    auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
+    if (!info || (info->countSuggestedBindings && !info->suggestedBindings)) return XR_ERROR_VALIDATION_FAILURE;
+    std::string profile;
+    auto r = pathString(*d, info->interactionProfile, profile);
+    if (XR_FAILED(r)) return r;
+    if (d->promote && frame::dropProfile(profile, d->enabled)) {
+        LOG("drop unsupported 1.1 interaction profile %s (%u suggestions)", profile.c_str(), info->countSuggestedBindings);
+        return XR_SUCCESS;
+    }
+    auto copy = *info;
+    std::vector<XrActionSuggestedBinding> bindings;
+    for (uint32_t index = 0; index < info->countSuggestedBindings; ++index) {
+        auto b = info->suggestedBindings[index];
+        std::string path;
+        r = pathString(*d, b.binding, path); if (XR_FAILED(r)) return r;
+        auto rewritten = frame::rewritePath(path, d->palm);
+        if (rewritten != path) {
+            LOG("binding %s -> %s", path.c_str(), rewritten.c_str());
+            r = d->stringToPath(i, rewritten.c_str(), &b.binding); if (XR_FAILED(r)) return r;
+        }
+        bindings.push_back(b);
+    }
+    copy.suggestedBindings = bindings.data();
+    return d->suggest(i, &copy);
+} GUARD_END
+XrResult XRAPI_CALL gipa(XrInstance, const char*, PFN_xrVoidFunction*);
+XrResult XRAPI_CALL createLayer(const XrInstanceCreateInfo* info, const XrApiLayerCreateInfo* layer,
+                               XrInstance* instance) try {
+    if (!info || !instance || !layer || layer->structType != XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO ||
+        layer->structVersion != XR_API_LAYER_CREATE_INFO_STRUCT_VERSION || layer->structSize != sizeof(*layer) ||
+        !layer->nextInfo || layer->nextInfo->structType != XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO ||
+        layer->nextInfo->structVersion != XR_API_LAYER_NEXT_INFO_STRUCT_VERSION ||
+        layer->nextInfo->structSize != sizeof(XrApiLayerNextInfo) ||
+        !layer->nextInfo->nextGetInstanceProcAddr || !layer->nextInfo->nextCreateApiLayerInstance ||
+        (info->enabledExtensionCount && !info->enabledExtensionNames)) return XR_ERROR_INITIALIZATION_FAILED;
+    *instance = XR_NULL_HANDLE;
+    auto next = layer->nextInfo->nextGetInstanceProcAddr;
+    auto enumFn = proc<PFN_xrEnumerateInstanceExtensionProperties>(next, XR_NULL_HANDLE, "xrEnumerateInstanceExtensionProperties");
+    std::vector<XrExtensionProperties> available;
+    auto r = properties(enumFn, available); if (XR_FAILED(r)) { LOG("runtime extension enumeration failed: %d", r); return r; }
+    frame::Names requested, supported;
+    for (auto& p : available) supported.emplace_back(p.extensionName);
+    for (uint32_t n = 0; n < info->enabledExtensionCount; ++n) {
+        if (!info->enabledExtensionNames[n]) return XR_ERROR_VALIDATION_FAILURE;
+        requested.emplace_back(info->enabledExtensionNames[n]);
+    }
+    auto d = std::make_shared<Dispatch>();
+    d->promote = frame::downgrade(info->applicationInfo.apiVersion);
+    auto plan = frame::extensions(requested, supported, d->promote);
+    for (auto& n : plan.added) LOG("enable promoted extension %s", n.c_str());
+    for (auto& n : plan.stubbed) LOG("emulate missing extension %s; remove downstream", n.c_str());
+    for (auto& n : plan.missing) LOG("unsupported extension %s retained; runtime must reject", n.c_str());
+    auto copy = *info;
+    copy.applicationInfo.apiVersion = frame::runtimeVersion(info->applicationInfo.apiVersion);
+    if (d->promote) LOG("API %u.%u.%u -> 1.0.%u", unsigned(XR_VERSION_MAJOR(info->applicationInfo.apiVersion)),
+        unsigned(XR_VERSION_MINOR(info->applicationInfo.apiVersion)), unsigned(XR_VERSION_PATCH(info->applicationInfo.apiVersion)),
+        unsigned(XR_VERSION_PATCH(copy.applicationInfo.apiVersion)));
+    std::vector<const char*> names;
+    for (auto& n : plan.downstream) names.push_back(n.c_str());
+    copy.enabledExtensionCount = static_cast<uint32_t>(names.size()); copy.enabledExtensionNames = names.data();
+    auto chain = *layer; chain.nextInfo = layer->nextInfo->next;
+    r = layer->nextInfo->nextCreateApiLayerInstance(&copy, &chain, instance);
+    if (XR_FAILED(r)) { LOG("downstream xrCreateInstance -> %d", r); return r; }
+    d->gipa = next; d->instance = *instance;
+    d->destroy = proc<PFN_xrDestroyInstance>(next, *instance, "xrDestroyInstance");
+    // A successful runtime instance must expose xrDestroyInstance.
+    if (!d->destroy) { LOG("invalid downstream: missing xrDestroyInstance"); return XR_ERROR_INITIALIZATION_FAILED; }
+    try {
+        d->enabled = std::move(plan.downstream); d->stubbed = std::move(plan.stubbed);
+        d->palm = frame::has(d->enabled, "XR_EXT_palm_pose");
+#define LOAD(field, name) d->field = proc<PFN_##name>(next, *instance, #name)
+        LOAD(createSession, xrCreateSession); LOAD(destroySession, xrDestroySession);
+        LOAD(stringToPath, xrStringToPath); LOAD(pathToString, xrPathToString);
+        LOAD(suggest, xrSuggestInteractionProfileBindings);
+        if (frame::has(d->enabled, "XR_KHR_locate_spaces")) LOAD(locate, xrLocateSpacesKHR);
+        if (frame::has(d->enabled, frame::stubs[0])) LOAD(thread, xrSetAndroidApplicationThreadKHR);
+#undef LOAD
+        if (!d->createSession || !d->destroySession || !d->stringToPath || !d->pathToString || !d->suggest) {
+            d->destroy(*instance); *instance = XR_NULL_HANDLE; return XR_ERROR_INITIALIZATION_FAILED;
+        }
+        std::lock_guard<std::mutex> lock(mutex);
+        instances.emplace(*instance, d); enumerateNext = enumFn;
+    } catch (...) { d->destroy(*instance); *instance = XR_NULL_HANDLE; throw; }
+    LOG("created instance; next-layer dispatch retained (Valve layer coexists)");
+    return r;
+} GUARD_END
+XrResult XRAPI_CALL gipa(XrInstance i, const char* name, PFN_xrVoidFunction* out) try {
+    if (!name || !out) return XR_ERROR_VALIDATION_FAILURE;
+    *out = nullptr;
+#define RETURN_PROC(n, fn) if (!std::strcmp(name, n)) { *out = reinterpret_cast<PFN_xrVoidFunction>(fn); return XR_SUCCESS; }
+    RETURN_PROC("xrGetInstanceProcAddr", gipa)
+    RETURN_PROC("xrCreateApiLayerInstance", createLayer)
+    RETURN_PROC("xrEnumerateInstanceExtensionProperties", enumerate)
+    auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
+    RETURN_PROC("xrDestroyInstance", destroyInstance)
+    RETURN_PROC("xrCreateSession", createSession)
+    RETURN_PROC("xrDestroySession", destroySession)
+    RETURN_PROC("xrStringToPath", stringToPath)
+    RETURN_PROC("xrSuggestInteractionProfileBindings", suggest)
+    if (d->locate && d->promote) { RETURN_PROC("xrLocateSpaces", locateSpaces) }
+    if (frame::has(d->stubbed, frame::stubs[0])) { RETURN_PROC("xrSetAndroidApplicationThreadKHR", threadSettings) }
+#undef RETURN_PROC
+    // Includes xrGetInstanceProperties: report the actual runtime's identity.
+    return d->gipa(i, name, out);
+} GUARD_END
+} // namespace
+extern "C" __attribute__((visibility("default"))) XrResult XRAPI_CALL xrNegotiateLoaderApiLayerInterface(
+    const XrNegotiateLoaderInfo* loader, const char* name, XrNegotiateApiLayerRequest* request) {
+    if (!loader || !name || !request || std::strcmp(name, frame::layerName) ||
+        loader->structType != XR_LOADER_INTERFACE_STRUCT_LOADER_INFO ||
+        loader->structVersion != XR_LOADER_INFO_STRUCT_VERSION || loader->structSize != sizeof(*loader) ||
+        request->structType != XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST ||
+        request->structVersion != XR_API_LAYER_INFO_STRUCT_VERSION || request->structSize != sizeof(*request) ||
+        loader->minInterfaceVersion > 1 || loader->maxInterfaceVersion < 1 ||
+        loader->minApiVersion > XR_CURRENT_API_VERSION || loader->maxApiVersion < XR_MAKE_VERSION(1, 1, 0))
+        return XR_ERROR_INITIALIZATION_FAILED;
+    request->layerInterfaceVersion = 1;
+    request->layerApiVersion = std::min<XrVersion>(XR_CURRENT_API_VERSION, loader->maxApiVersion);
+    request->getInstanceProcAddr = gipa; request->createApiLayerInstance = createLayer;
+    LOG("negotiated interface 1, API 1.1");
+    return XR_SUCCESS;
+}
diff --git a/frame/openxr-compat/prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so b/frame/openxr-compat/prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so
new file mode 100755
index 0000000000000000000000000000000000000000..e58d223fe68c2b5c12c44da3652ca3ab908612a9
GIT binary patch
literal 98248
zcmc${4_p=3ng4(0&Q%Av>QzC}kZ_HrL1Q8sqnK)QQA{zVl~uB}ZMJ}bLPVi}5fjr~
zqisoIwvy1sDmB>JU7*_923zgA4QcEyUEQv!HnCmXV&ZNw*w!Q@fvo0!-_QKH3?rEA
z?(em~+m6r7XU=)fbDr~@=RD`nkVlr}-0jme<@|K@W7YqpRM>veQQMD(RfdY=O^Uis
z4d=a|%Sq>@y>>Q-8l;t<z{AYD!T;$jvobo=DL_yu)4@Ai>~uEW5pVGejko!RE$ZZ}
ztg+Hp_6($@cJlUwf%$wqN_p9pR{HFN18KYUs2u9lZ~1@J6pLOyteiF*m22l~TV~1O
zrGXI^?ocU1et$(ik@LU%ll*dJNJR&sM=e-6)G1Huxs6NY&RkzyRZ&)~lDV(CJ)M95
z=f7EVXV1yFecu0=iO848rE`7!Q}?Qwj~+kslXof}IP$qWMkVg~?#S*Ref^rer9NZ1
zyuTp8V0d^4{NqF5pBn-%9|Er#0)J=-{LvxsuMUBKeF*%UL*NI8z<)jj{;xyeFAsrV
z90GrL2>i+r_!t^;u=cuX2s~p5JPbaDGQ7VfL!{3c0>5_%{BuL#B}3qk41s@T2>fq{
zz@Hfc-!laM?IG|V4uSt<2>hRiz<)agetro2y&-TPer&LIj~@abGX#F~5ct9&@J|kb
zUytF8RijkX7R!QCklXtCl>ARK|F!P_zxh`;xoU7OLZ%RfiSLr<FWApge$hx7eRWk1
zCO_-h7kd^lXL1Rh#AW_6E$sV02{ozw{G!^z{MBXa3(LzMEU_O8Yf5U%YE*62r%KjT
z)Rgg<Q&Cu4Qk7X*mQ%Q?q-yE<nv$y3g+(Q*x~8gVT_xEHt-&L|ykbp$WmVbw8nEh`
z!lJeLMWt)=R~MF*t92#o)>S-U<|!{(FONl)o6KZY+(<gXs!M9jS8%PYDXl6gEY4rI
z0eRqDwAKS{SZ{*)`6X3V>nl|Cdb8x!o>avpNLjH-WF=iiReqH!Tvbt36HB(Hq^7#E
zq^N9lSy2o_jH|G<B}j=xHPm5Kbx~n?xk!JvTD`HV4D5l`cJZq#H`ElV2MVk0XGb^i
z%r{HUUsqCHUAU%1RaBNxg*C!XNKtu3b&1@pgLg%dT3uCAqADw@%WBC1R<>rnqI~n6
zqnwKMG=uXX5*C+~mmm$5D%?=}K%pt)rs|rKb+ilRRn=_D=bdO{y)<1+=+)&Ls!L;>
zsy2#h^EXxvP`i!VdM_@|r`}cQBfqk=xXPQis@Tk1Ubd>Z{I==}m9uowV#QODJV2?a
zeYei0D`OUxfA{jtPcF$Xs#sT9SR-%kpA#qQb^zl%ciC~HgV!vyGF<ZDi^3M(>%nii
z+rm|=^b~rO&A<7h7H)X(NsBE!=)v>uwD4pP{t$gmejyM3XFGkG2VZW>pYFj&WLbPN
zJorW%4}0(hORV(S9{k>U7M|<DKQh<CS9<VYFS76g4<2`ig_nBp6E<Gy!T)6AwI2MW
z1X}ze9{lAD3$OFwPWl}lJZ!h)P7m&+Z}#A4?B|0XyzAFixraS?uZ_2R@EH;a@$2y5
zX@9ivlO8<r6$^LDckHeGdzSrmdeU#ow$gWb@XGI6=`VTkR@;7hJ^1bg79VBjbISdx
zW9J_H+jm*%gC2aI-CoHa+_Bq`2Y2i<&4W93nC`(Hd&}_Pj$MU4`1kC3Wqa@`AG74o
z_27;@tn}bNu=`7a2d}i-rPPCe@*a!7(+-Y4)4p%DORXn;nVr7QgFEFldGL(=7N2Gh
zzVaQb+=CuG`)vz9?7{DQ!@}D=c!ABQ!-Ln@_(>0b*v8Lz@N%1fmj^d&`7e3!x*kiO
zUJt&*#+9AV(dXs&tn>~)2Y32Q(3AeFww{wc_?ZKiK0_Yd;gjaUTWmh*9z556cG|})
zPuP?GMVn8y2Y2Lf_&IzWdt2#A|GLem)PtX~pDR6hTA!u2S`VIW;}H*DYvVgSc)R_)
z(}O$wn>=`v&8OLepS1CV9^9$#VGlm$6Sm!YaHqXGJopWE`jZ~q(T_tNJv)3lJ?ZD!
ze7ZciBX_R{58HO7Z0hjuwCihl@C@6YgC4xp#zP+5vD-8cUSp?E_uwaNJi~)K{m7Bm
zk<-ybwkQ1(TMxM&+|fgU2anj#r5@bTL!}2d{>!#c5ANu};pdgJ&XfLLTh1LG+^J`i
z2XD8Zn?1NA=RpsiVas{ggFA9M{Je5@c+#(S?9+ogaysqo<<sd&ztOQz5AL)}uLn=I
z$1i15hreS#h6gXT>l^goj{P|N96pZyggogVv*k?l;7&c$J-EXs!-Ma!`Gh@q#2#m}
zJ-EXs*MmQA^I7S^9XU!pxWl*7gEwBb?bd_0*?7c*@3Zkb55C{VcX;ruD;EEq9=vX(
zHGVaD@JogrCwTDf=FDHI!ya7OdUN#Tw4+n64o~{?wwxzDxKpn)9^9!{rw4cH)#b$l
zmi(7I_<|7@-s`~=oxKjb9*+D@eGCtN&TjXh2Y1>x<iShrXD5zx_&fSZ_oPp>+bhF^
zJNgNGa7RDc9^BDSt_M$!xAd^mgGY1=FYw^awtk#?IPyFCsq~~Do@3jy2Y2)n@!(E>
zsPo{r+I*Tk_|e&xoXsBmn2jIw;3sVSum=y`Zt-dN;Jr59;lVrRSm{rC@Uu34#)Dt9
z@lFqZ*~Ys(c=B9}|0NGzVB@_Wyxhi>z5nF2ORbF?9(<pT2R(R~EOhfr_TW7>9`fJ?
z5i_|;^WeEQp6<afPqz4Hc<|<_79RHC{@+^s4OvL$=hQ1=k3&HZ?u@g^9(<*pKIFlj
z_%qFeJMm|_2Y1Hf3=i&<8}{Hk?Q*j{c++33dgXd>Cyrd{!JYB9z=J2-{;Sl3JL7Mq
z2ft*?Q|ra;xHICxlkN0%9=y|@U+wVV&ireq2RCf~O&)wlkJYZt9=y)R4|?!|x2^Pt
zy|~T4-Ge*r*x|wJ?DS_mc)G36P7m(*t1b^-UTn$Z>=!%s>9k|5T@MGJGu}!c@!-xp
z+^M&dJ|Y`i{2V<wczdsf@AUB5dZ&fAd+>C7gS}%2{G=CWmq30e?fPo0TTZZ8oBtZm
zS@rONTX)vWpbNLR4$K$HE?o9ronOd>!z%VmbK$ZR;r!BFxO+c4!-bD<5<|l-+}V4V
z*V!&S&Xqpbg~z+_l`cHNg%`N+fD12m;Uismr3)YB!fRdlXcr!F;j&NT{OVk|d;f8V
z3wQ5x?R4Se9462v7oO<Cn_YO43qR<>$Gh;uE?oBconN~PpXh+l4i`Sjg`afc*SYXB
zE<DABce?QFU3ixZzrlrHa^a~iyw`<?T)1lMxAVy^+;HJHy6~V2pW?!kUHDWN9&+I~
zx$ra>{t*|R?!s?&;TbMG&4q_u_%s)u?ZT(K@LU&uiwj@r!e_Yf0vCR(3omuyx4H0W
z;~m=dn*&FO>5aZ%^DuqCFR*Qxe#sY%4AUceCoY2>&xe)j{WrH)Q7YOP@o9h5+O@=^
zWA!dA5E-ZUXw9T))QzTb`e8k=f1KW>2b#y}b$+95tbWlSY#ysO4+~x*<*?wzaeDjk
zVAnYPq(r2RBa-)x)sGqeedF{FgC+1CaZ};g7PnHV?ePl^kJWqQgH2<#x`aSvtadcv
zpw=-~yBr8!9;0m^8R#9OwT}#fbdC)6jL|NQ3|tzc?HeV?#ZiHaW3=8;fiq*Y#?fII
zb&d9e_l!>Fe*YN%VdNN-+%Zl+Go}vdJIAJMAE#d)OP6UF=WiUR?HnhHvvkn&ORo-=
zXt&h_E*g4=7U(qe(|-SDLqFqhAlb!X$z6t2@vNaAHBusR`Wd6tX0-n*KC`q*X~vG>
z`T}Fya6Kmw8Ln^kHxAb$+G%{PS$OSLdDdxp8OGswJtw$7UM~*x#%cR~#`!p{%_kw-
zc|HAfoYvq!O$&An_j7-7_<8P6#>xHZxC~Kj%CUI8IUe&r5%2Gb*G|S`sa92$aaDP<
zwCkoC&AOgpH0XMEV27^P`HWtlzQcFa*3jvH_3G!7+MGGY4s1&^&iM6x8kTxe3mo<9
zCw<}betn0&og9sRKQ9mZ{fGTpn?GVR!$!AV#qTp(<{aa2oL*e8Elxk`3v|TkmwiS<
zoL;8~8sqdPe=k+jcMg}PY#I^hG4%Z-#3)Z2DLdozOU9)b^R%mYPt$_w#$lhHox9Jc
z@6?XPlB&xmxOe@cjkjv!=NM;nJ<B+zWBmo~y58Z78OjN7`luG*@SRFA7O1JHAR5)K
zQy4>O;#oiXNIdFS$MoP~zdEhAOG&)<rVlDHss=6XvZjt|m1dd=HWug_p$_WC`4Q@{
zeo4k`@=sK?O4S+&64A2p?wX(56PjVxg7+IwYerL0oz<GLiEVzPYqZ+##}E$s1D8ju
zhGE9V(W-G6K>M&jB&d3a8D~bT$nf(Bael-}eP2)=O)yT3R+j?C+0km-D5HI}+Bqr!
z-ZRSI98}v!`+G;LeWU$7qt(&T{!61(`)H|w$acNjNyM>JpK;Kj-X{^DVR)mDhl2+8
zXQfF|RFum&p{s4CLAU9C?hoq=OdcsJLcWO4IH{{T^ZjAn&;3#R{TOA6su>YoUDU)t
zg>Pe$W~3P_wR9T6f-GG09a1V}gjJffPvaQPAM}Tur3WkTAXrq3%Q7(798}DYx)~Wp
zjSBO~{k7f=EHA3vXv>>ir>jPvzt^V@`a;}a^7(sws>esIO`a(<nc_-r_o)V-|DaDb
z`wZ?6`smP<d86v&eW#Xu(WiF${AYb|ll#*?{~4b;6XWyY(^+~<z9gLdoj%p%llwC!
z@3Ss`wp?ANT$Hubm(2Z1pLn3t|ATaAsK*&C8K1So<k8@h`x8Dt26HmT@8-(j4jmgW
z$Kz_r-0t)FY4XFq5cj=4|7D-LY$irGlPiNAKGGIr!&)-8ROqm%&fxyADA3aJ%{4)E
zzD?3~Y02C+`TP{U&nNe1O(k?XJpWs1YlF0Fo$y6gZjlugHT&eg(=6k>!}lYV0kpii
z)D-mtbpPK>i#2RUgb%in@e2~0bhSCKPe%iRMqTaqHPI-ho$(H!Hb8<#Ux5DH?0T1x
z*r2N#L3jEXC#YwmlkYlJpj1KP3979vpd~MA0hHgX(TPmH_It2>+5%D$SscUuWA7)a
z`;@vb5sPoq7Vzdgqlr&l(l*<21yr6=dH$7ZC9cHm#{qxJRsA^NpE?LOSh^33dH7A#
z0*U@yEyc*u!hzg@WlhvZsv4zg{6{sd7EfWSM#Q)LQ=&gln`2y+$K;nbIKQFGn#MpQ
zZPujWDztqX%IVdDby%TqpbMnziCTQf*rsU(cr>@fBG>g=FwtMD%`j@TY@<>u4%E6+
z(6`2^T%~e@Olk`P^xSe8J;fi5Hpig=&S9Ij!^S4iwu&o=@wb`n->!Aq??$PWO05hW
z)>QF!frQ66(`JI(eX25WQB#{cVti!8ZPS8u@?%;6Uw2XyZzXwbK1bnW7AsglQRf-K
zJhi~_@q^pOhimhc^qc`Y5dBpapV2f%R(GRX@&ptfe1U(n3eyCZT^eZv@-ud12g}t;
zQ??{6Zl%9N)9z!WH`O4ju<A8OsW}0L(r`>aLHd&7k|o815@N;be;*2J6U4+Avq^VU
zGiaP+n)DCR6Rx1Rz(MSEJ*4Z=jLRA$ur;m(%=R_tSBYjCBiXo5g-W?^yh$5ho_N+r
z7sUjK?zlaxZG!{<@BdL&TzVj)sRiXGILLFr?Au1MDi+xq7izQ2AjzP48@0eTygDLD
zBL`RvKPy4d311?&mwW->%f57Xks{XwzI#v^fqj~m#m(kKZgyzN?o^ii6BJp~13NWs
z0otuh<YwE|=@|bL)3XM&nZyZ3+Jb=?eLoOP(Ng?Mg#t6KeuqB_26^ZIKX^yHlZekq
zp<1riF#CF<pK2yw-A;qXKGez7rBR?|`HKhEiT1YxQRBR(5$Shnc$(}1C5oPfhZwJs
zr-l712lBw)EuYxwc0Fdi7W8k{60w;9^5c&%b;4E6-{{lYWca`8eORfmQLg3qE4AFI
zp7*p{z^i`~n>tXgSp-z);e1{TnGrys%cmXlg&0CHx^234*%uhV*{WxP?Q;W{-L;W-
zpV977;*WM{OcJ$An!m#@LF_R<BW!lNA0wW6kb4~?C7$K>s2(ER(-XNRJ}1QqzyG3N
zJLv~@)!6J(v44=s{`u8p`wouw&oHTz*?I3?+d*+wT1=SkZvH|xwMfKyG911RANvKt
zx%tzawH_?q{5flut~D=8F@L5=&YH-LHaN3vJ%?;(uBj@k%&*>Ho<*L?LD>?uu6*XY
z^4T05UC)`{^74`@wPAhrhRRCL`<4`kN@{CL)>oHRtPkB(9jfAlY}xvf;*W-^Hmt8H
zTUQcVx1qWQ`2Lcj8dW@du3A;LzPN1t8cBTX$M{#>RDI`7#dpdb=T|qZ-^hD;3f;;-
z@ha=n`Af3%bC=|=-mso?!sVgL3JyY-RE0{`7gd;y)>qVoV$!HuiYT5nhjZ3B6-At)
zT~W!A>T0!edHyGJ@(0!;-(*x+RD<kl)h6mv$hqH{m1RX0`Rhw6Zg*Fh)4eMSA1Eol
zyS$>XW_ih)G7kS%soGf?s<ftP<^yF9l;p3jDB4gxAQK9eqr7GTa!`16S$RqIOm{Uo
zf4sV)Y8_gno{R6!<e>5D{G!!`JZ3JxJ7j5N2I^ZAs;Q_5ttwj+PYvgx$UCUvlJy(b
znMZ|}uIE@dvM+I(BG)>VTt>}ZO1-KyPBQ0LtX|C->Ol%jyQzG`v{1!{noz~+P*vgj
zH6`)!s<MbmQ@kq9K+SSDM-|^bOD$fyB=kT@m1zcL)gft<S)q!m(Cvu1qK32UYw{{`
z3u{WHA+qxp=bIWUs;FL9QSDOmz!u?@dSO*n;U*emV?L+b*N`1?W|o&fu<lmWDJC^j
z&OX=H7OpCrSzT2$lf&T;$kFMVO_e2O>sMFYR#eGB`g={I%3oemjlR;Rg^CK--z+v+
zv!QDJHT7e+Mt=3`LG%-Aki{lD?7FaOQ>eP6u&SsuL~nSYu&S(ZRe4Fs65TRbTDrKf
zrtmhji1PR#Y`ya}Kyk>l7Wo1oG;2mEGk0ld)@`$-r&-77$+@OveMwbWQNGyqnhFXt
zkKU`Qirb`2Ih}rQ&XPs5W@m5!T@}w$c89JkEMJ#TFSR=JKtrG7(!MHLx1k)?p><`|
z)zU@XJ(~_)B3~MWiYqo^ZJd~2r}}S0wN;DFL;Q{<nti)iT~oW3<%wh^>x<1UFtp9z
zuI|oS5-KgM4n0^>Rbi`C(Yw~6b{f2t?*VX3^q7)b^hIAT-(<INNwGp<MWs@s!cb9p
zVRdzAV_8k9Sa#w1P{k^-qq|fM4oehU9NJJ`vI-?q{mLr7DG=}A>O^kWcUwtm{_3j2
zb(CLR<=8*YYeT58CUjGIEuD21Jz&;+`bj$1d{tAip{UfQ^ZYMt;7f}9S@~6Et84PB
z=`GSr@+z!8L+ck6Zdg-Vqe^Nwt*@w_pD`<4EF$K63#-=6og?nS@<;Ahh+b1sh4qOW
z6z`0q=}(ER<cV=E!KH6nAz!If7p|+`uzt<VisDVx)$&nBzqhZhDZca0Rni^JuO#|4
zReiOl@MFtz^DE0rFk|roW$P--OV*X(2#ZxMdbk}m%%hr?xva4D%SV!xv|WG2Fny~(
zSl%;adruh`(ok>phBa%bAJwX!X6v+)Pc7U+<7k$w%*)@ffv+zeI}sBo-cW)s6-Fhs
zMJ1J{YH)DkF#uHwK5+wPu%y57Yv)Q&8pM;YW3Zb^d&rQ**BXV@C9~x#6WgN?Vn*&7
z4%$AeWq9dtrP|r3OFVs+^|_7HyTpr1<)m%P^T||ECD7fA@~^Tl6sM?`%YgeOw8tFB
ze6IF!v-?LK(puxN`Na&q<O9ZGXTXe&mBrM>7TY$p{6S2O6radm9{cji{#c0ts)n|!
zR^k<J+Hjlse{nIhZcFDu_)0F*)JyWKtsx%?VujZd5fsx6#fdOHncw?t!W%Gbp<Q>R
zAY2C`a1Nyv(UoS(ooOfNfX2r3DEO00@-hceJJvXa*<l_fe00=re!_){<z#+l32o^5
zMo00TPN`U`6)4TzP+d|rQ#{?w@{-l~g!Sg|LJO~}5WnSi*UJ39OFIABkbEdc?{hlA
z5YAFmy-^%utXp8&jx)Wc{q+0Et1YPCfQs>i*Rn#-Xz&4JZg~}cB*QT%bA&TP)endd
zR^!1|$p>_F0(4`B2OHL}UC)?yl|jpRy22h$Ew9GcdW2`ycuR8t3E>h$@}#O6ZfDQx
z@28GiqhXgVzBlLI6)}UxYGgo>&-fU%tQJ(o8zevqnI2?Th|kHYE9BF`noS`IdQA^i
zU06ndP!rl%v7wwoYjBsPNHZg}ict*lah6v8*^;W5#AaCRq;qTD?SuvnVAh~@XJ~y1
z*2F`3Ng=WOoREYJ)e;3t=wg;wv7X_T&lp2DJy<LeDe)lT%&fVn;NvAVj+@G@swm1V
z<|8)xZ>%d8&zeoD6(u#9*4K@hm6hdX))19vews)xvt4@s5M&RNv)%O=#E+RH-iHb(
zV(yHuAPHtZa9Ux-;}w<6IR+Wm7|^8djPb5MT2&?k_r11tnW0+frs8YXK;rQa*PCil
zBC$a2EJg=H@LKvpF)nUCs<lSe{?AISseyWcD90KmV)6G?GnN7Icdf9eVI|_QdWbVn
zT-`io^iuSIbOE<BHJj3o(LQ+WHRph_h7ntnhQVEztw%AKv_x$<ZTrn4T(B5rdQ8Vw
zBgH0$67bmJc#U{Uf^Ku#w89D=mi7<n7^=+87Fko%YPG7cnlPIv7ok;Y<;-<uwI#**
zGHTE%-9g5+92$ROftkx1f-feA9`AN7M~TyrvAwi1f5>9<VO(1y-vl$kCMd5W1lV{@
z%W|6TS_NOLGR{os!|*A_9mHnESIzPGNOr@j&<A+{bDUjxQ*o%Ktau>-A0r@oS#j^;
z#Y<MK2&JvB2vrxAmK1L&7qcp2Ok7i9j>cFVzFnfV^)exz<(d3lQ%4(^h49ffzV8~d
z@8Y@UTz6@f7^e7GnUB~Vf|1y590O-s`D+HO4cr+r`OrD5@YfaiS7EkJCMwEVI_V$K
zOYE7x8ONK$Ii1DyB}KQ~!sJ)g;sbC6GAU12cgvJyWz}NyLtnxKdzGL+K&Uq7C~0Nu
zi^@0fB{$>AhE+r}tgo08pfY<o;iHTMwKcbv%jfBgDa2JsNAP4V@r2U;y0DxHq4m0`
zg3sHlYpj^)uQQk5vkafjl;MH0l8t8gX$eZTuVrT90PU`F?KwAN^AcGADk;uY*5JH)
z6}D+Aaln*g7K<e~$zmu5v?$BfKm)v;<74{gw0Fkl!B@xM_Dnn$Q;DCrR=tRLOY*54
zbB}A-RxL3^F-uCHT2V8XE?&HL*6egXhA+hrGQX&)$}eFu#rnX~PtBU0|M8q<i!yWa
z^FNh8D<jKpn<bxGkw4#zYzp!9OIOU!U&7B>y_AJQor`lWO3n$&Sw1<RCuitnjZoGL
z<s6xu4ZDd;)(7Prl>DuOJGef|wUBEumwc+alxrE+3a-y^6>^nut>IeBwT|lxT#s;V
z<$8?k39hekJ;U`)u5WYwJ=X!Q=eQ1WJ<s(5*U!2Bnd=mnELi?u$-9ZNyfS|kY%sZ7
zz}>R{1J7RhUjozm+jQ2PSeq7Aut>VZ)!wt_$KGu$Ddg`wSP59$*4!Ls^S2G;j}MqZ
z#en>?^Ye=<oIi!&elwd=o%JK@FE+?xhpZxDA8z5UdTADJ{<ETHe*ffPMa}GVb4|dz
zL`SOrwE}HL&8%7cQ38fjld<A?wzVMU0*Kn__W9-_qolaq_JI9K<~XCA4WW)%^bKq2
z?}1sf=r7f!W$Vm^Kl=6R3hF)}!8{Vn($A17%&u1UL5XJN=RdG+kW|!jzDy0xvX!YV
z)f=^bG{5<K-+sPqQ}25x-B5I>{HN#~KTrW}jP@gSUcI4aX%n>y^)K|bT;<aYZLOBc
zp3gIE3r|xIs_$zb_J5yOzh;Yg7yC<ZYHw<P=HJ)oi?6Hg>JRkIZ2tEf)udile^gO5
zLi1^FsZ8zP)M3@9a<nh1yS0_tC~dixs@<-QL!ysrzfe2Wm((}ZPt`_Mss2V=EuH#*
z^_!~xcmLDzhyR=Zm20DXIZF9%(%yd~8tv+eMo;xbqutO-XnuDz8ljQ5a-IECG<xN&
zX!Oh6-^6`2?`ORpjlK*`z8H-@`<G~RBln7HXJ0h>&L5-E6mUP!OWq^zo6+cB|2Z0c
zi08k1I~skA_iHKV5uU#apGwMiWcVG}|6kW{DO;nSe@3=6>baHY&m#AQccam#kn;`j
zFM~aX9(uT+PTCuh{YmQ6NWJ|$H$j(D=WnBv5IWGPdw~2m^4v?F3a*ck{ua?Ad8d-*
z4tQS%*RIn)YK-8>4R+PYR&$8^{m?nkHfT09cNPaSp%<Yip~mf;bK#(I7lT|AbWT{Q
zOVFMyn6QO6^=_rIZsv?11702U(x=!bgdWZ1TOsz(D;WS~AN}M?wi2N;J}X<VoCJiH
zLht(=e5P^M;&0&3b2Ib|bZP;Ae<%(aS1FYPO^233v!L0eZ-8#&`51IRv=@2;dXRPX
zsT|Osvl^bzW@rO6WeqYwb4rnk{GIpn_v;umd!TJRXE7*;c&>q-<++Ki+^N%%vy$?_
z!wl9DXdbi?S_-Y@{emj$3f=J_^#jj%2)S?JnL+X*&*@vJGaI2tp~c__8SKk>PTPiT
z&;>%l=X{yE@SFub1FeNh08;Q3%7&Ig^PmlN@Fo3%$7v^?bD_=9lTbNNGUEwOnM!&F
z<t}L5*Wm?z7MjS11&IU~VQ3084_X7=0gXWSk<Qr3E;F<dI`vkrZ-DdO*aZ)0?rvls
z4F<grT0@}H4BZSp3Ox+H2<_cN-GkgeOTFO}Xd*4o8PJ_PuY_{&Q#J3UJm_I)FEsQm
z+L8Bj2z~;$QI~zlFov?B8PLFY;0K)n&EtIobQ{mdpa-G*{*HP>_d_p3+o3@|c<}!{
z`hkX^dC)n~ZRD?kmhxN&ZRYtfbTiK<pgW*}7VHB$19}>o3%v}jfu@ZkEp!320h$Xv
z2Hgxj4c!5~2;B!wX{C*zGoa_8+n|YTYPUhd&~|7ZH2J%{gJweyLi3=<pxdCApl#5U
zBzQoxp<Vlt1$qfu2knJ6LM8Az2u+8cg%&^!KFrtwodZ4iJ?s#A<{<Tk7W{zrgZ4mA
zLQg!0-X_5F$Fvo6!4Y%{E&d5*Lw6jdE^NA={zvKyJ@Zp!gLXm#6OjuVf?k3~pqHTy
z&=3LOY4ltP4bCKOJN1XALz{Wu1g+uOcmZBK7eoD%kOR6Oyyj={hOT@Oy8u4{O-@Ho
zKL_JE0?p+)@=w%{=bRJN3%VKF37z^&%DoQT{WmUX_Di%6bQ`n-+79g!{8z}DLLO)y
zwC6Pa4Z8i;=ni@mdJK9IdIp;EGWSsVJ39-mr|jRr6M6~S49)s?-a~7li8oLe=mKa5
zG#7djS`1ZZDFYgW?t_M)hoR}v6VNlz%h0^vp|@17-=iC79<&i!3OxvIhMtx8ozyvm
zK3{`BGzhJQCPTMF?}Ii$v(8f=XySiRe`p%?GBg7koQyu8Q=!HGNg2@n(9O`p&>hfY
z(0$NL&=b%(7bx>a%7>;vbD-(a-anBKda{?gL;dfe7ii*T@=rmQD9_MR4#3Qqij5^`
zsurq7X{sH%V6>+EHz9XWQ@PNoV>Q(X-9AoJUC_EjO{IN=_Da%J2liONcXhqcQs^A)
zDSZN`0-?AX^QS$yTxpwc(5?%lnixq{&9wgal5Pf<j2R3|<}b{@autI$LRHqN^qj!;
z=}-F_{9haXbz@KbHv{nnfz<SzQR>v`U%&kO-(@BEa@@~W{%vGE`oG{Ia&>SePDjU@
zDMu(faD7PR*fac_M!fH6AT^XNLWl@*x=f*Vb#VcDu+oQf9l0&3eLDiF;apQ}GmDvL
z25B$-)zEeIZ5~*+Ih0XAo|Vh#^V|=rA77<A6VhQbTsz5kFpoZA<+JKz)n=t#84)Zm
zc5ml9Nxly9ZT10Vjq2256>}Oy&+r9O!TZ}JgQN!O1E0p$$xlAfN7!k{X99aheKQ!Z
zbJEXI%FC}<YBB$2Z5DY?th8+<Yg8~RaD8x(@0)(Hp#t8u^DdEl_{QFeDT|E8XJ`ZK
zovV)hRZQXCKGFqACwhU0D;@nEh;zqkD(^X^D(`di0@vrpWRKq&_{OMR!98QYnHaB^
zQiEKEd$Gn>&iv-LQi=GhA=rpaDLTIEvs@P6e%rQeM9+hpZQG_cM31@TIsG~M4)-xx
zV|JM9w!{8=l1kp~<PF^S-_I+uc91uVydTz{rEM;YtoehtO|qZ*7hJn-q&>o<t1aQ;
zp8EFd$T2q`ChB$oB$Kjh$#<B1iB`UtUC6rz-W?p|oz#<qck1MN{JNFzs`7kw?&9#1
zq&rWZ#%g@(5banwupMIze$Ut<`KJy;S2XB$Z<)5QxX+a%E5Y?Z`V6jO@-NsJ)6qcR
zgn#UJO*Q=w<P%*qk++t-UOfeQca(RfoBDn9RIrm^#bDAlG5a(922z>@{r-1Sr(V+W
zM?h7Vm9AfpcAXBps^P7Zl$|jg`5x>a3#7apumG6&Ny;9~hxjggT!_?h8~K_yUtPyE
z-Zk;AiFXn1WA(B7ldrU2T_V#7(&j#lu4!-iN&Zf-+AYKnBY3zqyWauD<E(>OqtvZg
zX5W>x0n)VBS#2h1U5>_fNVjI4!YIu8llBB@4f4rP+BwJ0zfypK`QvTvn+&oN7zCv)
zEOsWpI`W={UqJHm6MZ&<)jp2>3IM-B6zXfU^a&?%X}|wnHc3yDZ|W1oD$)+*D_9x0
zzQF4ccaLpM+%x{0$?>`$^DkIwN@Kgle?M#LB%SObDj34>^SBpY{f1(9@N&ygECH<Y
z^T-n>kBmhhqWtYcl`ndhx$v<k`}I5ntPSiinAoxKAJC!t70qC8#TVyo9${Oas|N^s
zco0p<@L+56%x_FJs4&H(#bFzNOFU(lITQ~c9cK_0rY)AkW5-vmI7;M>IlcJo0k$aR
z?Ii6%(&i2&bE74*bSQUuR?AsF;Ve9k?&$XqY4E)Sb{MQw>X8#up6MZKT~;Z&Pl=~r
zKHaZ-$)66^2$nAS2WGbiH_NC~czqvfn@Ah7)5hw{v+&x?d!yllc}ZVrCT)PUo!m>g
zSJ|N`Ud9>65J@I==p<ho`3%X&Pp}@aX0SvPv1Bm_yadY<Y+${LU1~A&%pq+%X{C<N
zPx$75A9L{)tN_gawf?dMs{xzi!a`tmHs;u<Cm=P;+E1F?uMe)zsqi>qznA*~_JzA~
zT%G8>hjcmcxmG%1A+m;WNLi$H>u(NN2AKG6`3cW#umxc00u0pO0J|{jPuehP<z9Y5
z>+Jk)o{e_855u#Av?8a&a|S%m+W80iV|(!EH+IucNF4$r=@%ce4jH5^CoM&oKPfK<
ztQhRWmbaPo+dpJ^vbMFuRi4Ou6in8&K1e^3R@T5iOj(jv*2ko*55rg1&>BeVxBb*5
zAA`++=-YBs(k|tsEq`X9Ek(czJXix*o(mJ1n!&QcK8#GKNt^Q_)2h+*sSlBM4l>Lj
zt;iL!>$;<Va%D$NM+2#VwiAlY35v<LU?=^Ad5ZLngIb<<G~UDHMEM-=Wll}95=3WB
z<W1W}J995T!P>wY!EiO^PsYIxu$0}bi`cRaj1`y!SyQ+MMmU+*IwPDZqxd`n#%+z*
z6mtTRaqyVIj2QII`c(mg47KK5H5Wc<P4K$595T{+<&bc0AO=s-J72M@y1nonl&4uU
zU+;jtREvCP$yfU=+RfJc;B~U&Ae~QN2ML36;3Mm<_wB>K3|hXUTTdu<MpWx#U>{f|
zsZS03a=&BunLLzz)nI0?33$e`{p3seyZ-(oKBpaQ>J|DG_a46+?;f~hVF7ihOQbI#
zy&>uO3Fc=V_XP5|v1G7z7iQW&*bMS^NJhl=j8XAEVy{?jP0O<Q7nAR(r_5TgQuqgi
z7eA3>J6HjjIWF-mWj29DsB<OvQsz~v5*2&K{SZmdkWbdQ@4G6W*;UQ)RMxLolEy3#
z-mZAx^fM{rsBeosAGgbPEh@PRwkj)ikhSlgR`N-?{BpR8!2<iy@h~3Xb5gtSngMy2
zKafhA{$Bc<-`Wv5b%I43{OW$-^@aAh#(OFI3~3rjBcGy5nX%X_Ua!H>op8WhZ^|Z#
zk%)}XF|OO`BiEMEcRG+tlB-3Oekbeqz3}4WV9QQ&-0p4<D@k+s&^6|QSc36w8}LlF
z5LY978V}iVzVwse)4n}^Yo@}ouGxm|q-k@~NRmDN_)=l^`>cdHr0L}SN#56SFM0@N
zS+eXgtYl1^Na-^tf^sj((z%k8kl{zf;R2AaG7H9LeMuf~rRUC^EJ!9PD~CMW$df4k
zCT~>kfMHM;p>`+YW%^g2Sn4+Gxs7}Uhwb$Rsb?iZ?(zGIO{M(a>>JIbIZYaoO@3l)
zN5L+6u#;ecBmL>b{?3D?f%Qs8(Sfx%+Gs5&+G`FphdFnMmsL!Aa%uvYdH<ssAIrYU
zN%*adjc0?}vo%-*S#3P%u@pv&5Ta~`Pv<|Nv%%y73v)G*CVUii+P2iBdE<+3m=hsA
z5v%59za24oBfs?R^YF<1N2`sb{sq+ET%gRu<D1j)-~Ue11t#DxJ|LaweGchLNteRC
z`~=Ges|0g=sPMZFtQgE}Gh6Rwxv_}&_rJqD)i%<VlTP?JKe=zT^E<fEgJ1=&w9?m)
zfr;GBlDWTqt;KIy5VPA)0^Kl4dPr~XSJ~<NeX144U;r_XDxNKCz_T?+%1B0EKc$b`
zJR(=cLQUc!oKVAN;|8qyM&NT0KB5QtNgW$JSQ=QfjfJ`IucK+f_6iyXO#QNWeVVk#
z;3;e9W_u61{$ZKt%Bx3x({2`!HDw}lwKLw?b}n=N{zY+T+}H2J!rfDFb1;y4+(-V#
zpY_{>V3lAyJlHm{ZD1n1{6bti!P>yO1n}*PwW?WTpb*zl($v04U*ul-wqKP-%9Fjr
zsmBKDx5vihz5Ik4li*1@2MdFxfTe($dnyCt6g%GCIlwZq67VH1%Mo4$@aTa@Huv%q
ztOhLY=h%;lSXiBu@4}|?t`RI5Ol(}*F*b(LZ=C@wgIC8$mqI$(hmdpwV&6tHKGYLw
zq*!e7GLDU;W?ipCKmR;XmPD`=7bdc&fhB_N_giILGnR~(RhdDT)J#3pz^mpsV>Ig!
zL)&L;eXb*J2xcL&x5JC$Rcemdy6@6eHqZuqo;1N%xNQBn;+%LQP1`$&*~XU+e2h6N
zx)yJ71n$HVdbyuh4t(^yrP17pJ#Pm-T797r2U~iEanYWWc>R>lpLuiJn<b&k0Eup-
zAD@Sh>@#=R{=i-TfibeR80r$!Y_F-;qhAc>7;9%AqP;3d4AEX$WUqvm>=~c7+v1vb
zq&Hx-SKCn-K8N9xae>%K>LlxUm4lCqvhZ9va8#6KDzjdf;gSA2{m$0QfPQ0d`uRHC
z{l?t&!zlWD5{Stw`v&F_-TgYQ95f_|*>o{2S2;-dX!2@+SA>D3)RwF1nz5)JGDrTa
zm|1aSC%hW}#QqI+mbP=Zz1MyRnz!X2LYy5~`RD$43R5zF+Jm_{=8kzn<AyJaoVX0x
zI}dXszH1-Ot&=u3W`55)$(c2(a`53Jhc>Pxj<oh9rJv=HzmzM?oIVF1VN8kfxTd-A
zX9o?-UMybDv>_K>hq)Hu_uKJb#w#&?Cz-QdYj5B*Q+?7n(m5Qh*epQ3&!FEt`loR`
z#<O5RJ?({u6Jp6uEzJ?qUN3-0*JQ@AVet5e7>^y-Y;q<LepzW5L@pT*_Q5l7GxIH|
ztFF1Rt#E7f(sMAJTx%cPlt}!1CwUsv7<;Ad{w*fYP+@1he%iD?dYG+qSKVaY!G8;5
zpw#VDj92>y=v+}Z(!@B%CV%2TBJd2R6I)2#{yoN%C8fb)6W=8Xz8$rjOA_!9J`&U9
z&9?UYjpt*0hVml%HtDdQT8f<qY5N|OE;eTTeT<LQ&Fm>@n0FbZJN+?YJJIV`W9fDb
zl-o9z%M`{NTLY#>rL4{H$jG$IS{vgrpe(5ye;`fmAf4<(8Y^Pyr0)!zlG$4*#|Cs7
zs{y4x7vWR0h_T-fpVSy1rsmh|Gux%l3}%~Qc!uHCbvL@;-uUAI$2Sagy-sN9BZd}N
z+wU4oJ#T|Y?Z;_910FBNcpUryxk8Lfq;c5w_hqT;8F+@cSt)hxj`3uUf6cn?psu93
zny1ut26mtO*Vu=&!#~7$4&et2#KN35H%(P|RKjEXO6IP@<CzcQVGb(;c!)1;gGbYS
z)>?>B9pe$XdMX(^C?aDD@B8azcWZN>*FPMYK2INnxA9S%A7hKeC!wdUS#|%msFM>r
zB7K;=#{ION<eku;cYqP|ZUI+0X-|{3PSW1qpSC{^iXF0GhbI>InCGk{|9<kPthLsO
zjp%;M)@(V`oh2FbkQR&fgXF(R{z~$j<^S6?^IuhdI_1w8fxoK4u0($QV66OD94`T-
z6UY;*NuC1o>~!+H`~45hBlT<`PfiW-x!A~cKZxb&cla?q?YBI>v#`qCmi)3`9@>D7
zNdCX{%jt1Wv0h1VZ+fTL3KnDb4EUtbA5T7Djon6SzZ_S!7imLWIizo{wZ>9o@pCb`
z&1Ej$r*T!1<_u{>H^%L*G|nL_aQWeaRU>J$cG&*$>Hf3>Y|9nmTc_b@C-TZ!^OfXn
z<ld-o<u%vKSS|ChQzI2-(aV&DSoj#}r%L+I^{4M|TOxW_+s+}~0`g3)xApVU{ydg^
zR==qoFiWuNRYShh<hv+krF!$(gG{{dU@WU$F{#%<@@{*IIe_H7xj*k<Z6Y#ul79cw
z*u2=nSNqeuWz?tQ9bA(HvB6~Gw6w2rBl({2=8MVL7|ZA=pDgZQ{#5<fsUiK>;hebO
zf%z&?o<EYN60bb;k1g+fT5IW9=4-j4tNQUqxbH1pwZ5#WLj}HY-y=TN7uHo<>F{u$
z_Qu1fdX_CBeP+v*hhA*{;uMwGsVBB-!y?Ncn!<M7`_Z-@eSGV$$A<e}Chr~5XxrW!
z6&j8_HD{V?XnH?-s2RLdPii&d!hK4+>t(s$G*LDDIU1ed=H0I6zx=<E?b9yV@;*Se
zk=KxI`H-^x6rE|N&O~2LDl+!DVXAEl*D5a2b=rSiN$=FP)^obi+N1kgKRsVH6!_I0
zrM~cy)M4rinqTFiSMz?aZr=B$?p1GOa{m}<?ut`iIOpS@G+pTVF7g!e95*c7ch?K*
z4UPM<v7`fMJwC5&eE3Ki$8ax<i2UmQQQ^L6s{PGrs`Jf!Ev~znq2Yeo<(4bzrF<=+
z`&&GV%stDbEq~T5`j&LJsL1kj(ddrJ=O@)Ko%Pr*smJ4*3jQn_y|k!da(!Hj)*{%2
z2`U&NZNeCJBrZwyO{H#~dg^pOhnWz4QG4miLwZYZz8_l|hMtDETzOH|fBNJ{fBiPP
zQk2^@KHS&5HMKW$jB0xe-T0tAqAMx;q`zM5N^CD4zD;pzj)|X+H}PR$5wI7KY4YYt
zCZ<HUU|mIu=cLxp`c*^k=y2c4IMrsRn>yP}_f7_K8g}0DTTSc@uqH6GjAN2NvGpQY
zfs-!zdK3F2Sjb7Ya<qxPD*Q(9$<4TMUmAaf)6f^qm$rQY{hH<Wj5pJr5q_jIv6FXz
zsrtW*W2<$mR)3EB&D?kC;rZ|AYC3H-m;1iX1o~XxBTwzSQ8lm>GuM=_bePHS82loB
z%9V7~_Z%|6s*h`xK6MjAmb6jFThU-CI-F%cXU8k^`BwWm?LO;y8qWn<WGu_KX1=b+
z%}+Ya`?T+<Ak#(jzV4(72Aq4g4{&LAIV#AIZr#t;By>0LjT^L}*o4UN7W#P${S@L4
zdZ;5d@YKvSsk3TD-_s5J4gG?;jC1*hajjL!VpoaN#a>#r=J%#zqvz0V&$7F*ttHr4
z7WTWi1)HlE8~!qS!DS|jF5kkQD619T1N51TK1D|7eJ3{aNAy1cL!YIj`xDnA@#+iN
z*sK~>H|h7-_mzi!(sH>%Yk6;tkMeco@MGh{OkWVy$G-GA?3{KqeM0F3>|9UneIZk|
z{fJ9!eHAoK(eKCL12R=!n&0*TVe`H(b&K&vrrZZI`;4$^i__@iN$LxG?=t(o+21p*
z`@XyO`rkPBF_o9}Sh(-d$FRRA!+oXDjyp4tl(M|k@vU%Q*Fx2HZk#fGdGsr)&$L1M
z&8t(SpQW}o`R;nT>nq_tmL$FqePnb?bgSy?d9H5PxfgZQ*4ofbXG-t9uIgniZ;$5P
z2*p=&BU@6nl<w$8?jH%XMAxdmreP}YZTL;dRP}j!WO)!B8xN(f=)*qK_#>@{37I?f
ziP-7{Y&E$xmA1NTZAQkSRjR)0MqmBAt9<ouuTg!%moX==Yi+pid7sg}2tU_Jo(ZH+
zovMC7pUdk-zp3}BH}osfJR>3e!_>b~Z|oXgx2sd1)Vh0~YRJ~ZKkOsT;YU?VGxql?
z?bfO5^tB1CUmB|##1Fj&CVJ|?XZ9es$S(SdE34_fFdkWp^m<K8e1iS521$2lxT<f!
zenqAi-;d_0#K`gpWf25a{Nkx_UtjbOPtC{Q))B55FHEn$OPkpJ9_1KH^@*Lo`pmPF
zQZK8P)EqujjXb(QMYeKn<N6ZUm$|;eRkuJrxn)6@p3vee@Xha9tksJg=a79Pa=d+N
zY0LAz#O@F};j_dY@BZhc`ZM^!<gItsH~Yf#TjFU)O;t@v`r0n>&yKE-B4;!5C;g4c
zpV++@`QJWu_u#z#dCE0;wG75<MfTvlDiW{B>+6H?>il+q`i^h)O^Ynw!~373+b+hm
zrA3S8r=j2X5>(&wYGU{BEnnL8pEvvZrqRE@eYx_~zM}=FOdrYEWsX-lbL&M155wc~
ziX|=2>WSU>^t^ZRMcsCLzYZ1O^^-5FUe3zar=TB6*EC$^)!{=P!v~8#?@Vgk^}H{^
zZ1=;y_~WmC-`6rRy7=id^2A+v_|%1|>d;0l{`iIW7d?HKW^|`*soQnoFAx7P>Wk}+
zQ<t9_&sf^={==uTN!R}7!>8Vys~VD2@)Jg2{1flsBaV!kcwG8~)SK_4@PiXuMW)Xq
z``68WGv4eslP9YNQ~vA1eXo<|6gEu!G2N**cD`fL`H5z|U(?4;{}}o4snh?1I(EaC
zDM{iueA!v3@R9n9-A8%XOuahs31TzGmBpugS&`+hPf&fY&-3+l75R^R6kc7UGW+7{
z!+jT?*80TPm~BNKXYA?yTxN^-_x8lzc@jU4$6rKKvG-5deur`R)z?&gyZD?`%jb0A
zYYhBTSE6b&$3txXZLX927b?_iTK!)9!@qKG`mOCBtM4TLD<kZ&llueQcfA&#&v-O8
zZjEn#vy7kc?!4I=KTn4kdyz%tFnKWUdu4Fmo3c=6Q=h~F*Gz}bOn$@%*GxCXPIq$J
zwbR{fmrHEn<!8!ui_NEbuBn5syL3=)>)>4{esI;lf%<Qxk2rNS>vl3Qco~k4Bt}8E
z54*}(ag8z_8mtUrl|kz<Q}r3xe21U$3OlY7IwjnfEtEDhgx<n?<{c8pG<_@~xSu%S
z+>1WOqj9Y@*usSojH?_|FyAjs2*w@o^?gs$*s-hG4~|`D^?&->Tf`9Kv3cjc=^wUD
zwfjlpba`J*x{;(2JxM$#v6RH1(r27}Cf~MHGv6B0KSy8cq%INqXcu+iv%2FM=%N$*
zE#SZA(uvG`=S?5f>yODZzWirG>62X#Q4TTDg{|hCYkDX1gsw+a-(<}=ezWi(jl>Tv
zx)t|K#&;24)b}h~Ld=mx?6H^_WD&85#PI)Q#_;a+d+}l44X6e;rh)wj<DVNVWZd>K
z#!IXu`V8Hk5d0jvWLZB^VnUYg5|g-CV#Rk5ThZ4fZJKXjKYK4#HAs9Y@z?EKPJG4u
zH<9K1MCSA{?4#TZ4~ex$QP(c~tf}`g{d#xHm`Tj{bJC46+tP~b-2Ar6J9z%R!GC22
zDzPb3=2&?mzax*t7-L+|UFbNCcIf=}q84et4(h?uo>^Zv4{6hGY){(sb9S39v)lBO
zLTS$?u>;z(lXetdhu|f3{5ABm$motGAH#P?7Y}2uG@3RH(w1Xr)3LPeIO54f=1jUd
zXR_u>H}w7t-f!u8YacOWudYqsLVQ=P<j>Yb#{Lm`StBs}OW_x;q>FC<;SS;@V!F2{
zJUdBZTfy-4)1{5o)P&$G6Nm|jRpdD`B_TNez@on2f%Q;M9kGPS&Di&aF7g{%()7AS
zHTMrb^@hYs(WtMbdHl1J#HV&BHSgTFW!^NtbsBn!Oz550LtprH?w(&gxcD2tVtnem
zckz)o9~}9eH~aFnmJK6+{^omkoPP5Hd@k$w`a3$`q;2Zc7^`35+V#q%H>az}ulO$u
z9eJH`L2T}vzUV+=p^tb>9XO|F9e8#0;scuIJK!6s9oVvU@qr7(im%?%zA$bndf%cS
z@J);??7=^GQQvv+oW^xsf|}b)TT6ZKIc5a^dQ(~Nf9b~bRL1)V^XER&@&|^@*rVLm
zU2>7HUg|GtCTbI>Ytd-lrYj@nNz9iG&w@o(dS5WITw>sNPpKo3t@?q^tv)WH{sW!k
zA`80~t0NWg?7Dd|adTYv*1l-o>z`ZHlB|tCZV*Qp(<bds)snjF#;Ck`U>DwB{PeVk
zC+(iz_sFSy;)!hHiTl&O`m5HxN8fDy@~_@}eNyL}cWLq6iL<`O*cn;=tS_m%Ym~~1
ze9_qb?{iecmM0b;Fo-WY(TV6r;tGi`BqmnFkZZ)^1HQ=-Q(tl9SHrXeucBAc&C|ZP
z-J)wB`W3y4&KDqi-zi_qTeP=39=URZ_*Sj{JJ_=Hqq4={SY9^rJ5~HQ!;VV~p+6jV
zo%C(~v&KhWkome3o26L3c|3f@f4<9H{q@n|BX2REoj#0tJoXbu|Cx5h(!*Vu)4P|_
zMk|=7cKX#JCXk6Q4`*JZCr^KsIEYxMRbmQr?yIS8#r#3+G-+&Pd8w?ou$IEw3|kvX
zPe_|ddtpB>#Y_40dz?l+zW8`t>4w9Hn1>+y(`8SoBh_+GJ3K2fKXZ+@un`##gwod!
z8Ros3E_E>bzKpxro%H=5p&QfBn{(ICn{!uL+v!=BM;~87Utdn2|10`_F8+I23%<ad
z!xs1>W8Xrb5~oG3L=W+&M<#TkA0tWTz!o3)=Y37aV-GHV@_z7R*ns%$cZt75Uh#>J
z{}W7nwD>mD2P3<@^UD8aQ~t!(zk}X_|8jhnw3W<-|3&<lE^9qn%iHwRo@IK=75dM;
z%zxi9*Su6~Gj%upi%JM~F>n0Ic+rWXA4ir`cHf#YmJc!>Th!Nu|B4%?UZQ`z-bp=D
z*)e(@d;K=|@kYn4d$t(6Wel3GsmH&I-&*^nMSW{G-QSzwQ->b;BJ(`TlDI(n*Iw4v
zq}=w)@xh*Di;*wfcjckX7UZqpH(n){$A$Zz)tC=3k6NpR`x02YEFUJA>JHJzMF#w7
z-m~<*BFcX<u4C8!9~irzrO!o}JDsQQ+qJmI<yrCE$#W@VSHYGS78Lj*3!DEd+NMob
z^&x!31=b&b!~1;NB)V1f<!gBt8;PwOY*qDtZLf`WPzPBT>q18@(daWh^oKU$p*q%I
zWt~T25{dUi{@!_J{oalbmY~yS^r7}Hk~qY)Nu|Pl?f7vcAo@t`-a?(WiEoZZ4|UQ;
zqW`xOunk-PKbAQwZICuvwZ)rl5dV4s^_Mp2rVXZWA4eP9LK}!JRnrf9(Dmt2=$_|K
z&?YVLm`0n-*tE9yVt~)1&?{rfp<>=|XI}a&{!R4VKzzlwLT%frQ@_6BhtPL|sqYoS
zLyJe>38uc6@%#jQQnmQksi!HY*hv5xBetD{k?Gb=1-%#bk*x=i<$3h57d;$6&I5&s
z_0MV}O~3yn?e6e-p7s_#-=n?%^^j$62PpS>@hQm8e}1`bot<86RMP(${!X4>+IhZ5
zo<ESMi8Oa@3iXPt$6a|vW~Z!H%KD_ItODN8*mSFzuj{EreP3hk_6be(Jxe@l&^}#H
z`T91%Z!hZ+jQ>yFhm9f6pzG^<$4Q^F*6Hi7$7jH=RMMh{RN`i{f4&wU{CyH*KW$nA
z-z_%ZyKTO8$S*wl*X<KqpMbB}tFtaAK1uwY#Ha7#za>V!^3WpIldQG5XKy$E12Qo`
zBr%%flML>~7l|yPKg0(G{|WMluTaA*`T2Vv4RQD)#}AFe2T8w+F7}!0&6g|u_|swd
z)#3Qp5yVi2x$gW~b3M-2Dm=6CbyAMg$4<T<edfRDWB)FD9E?*^$8(G&uQFabeNE|B
zUn}@+eDHB(`i<zq?n8a_p}E9<qD$f13Z3xHMSZWJ!>-}#rKrz%JtBU@H=(;1-ix_^
zEdG^U881!PEq>YQM{SeTq2KeIESHw}_|k7I>YKKywwFG2NaCOA_^W)@liHJ2-ZX6a
z7x15s9p+=x;;*C}v8jA*f@!~>h<jz%{Vfwre|e8)Jf5#5cZX%oioKdsvsHt{TCxUq
z6nPu<r1~!WcNcBnS<U)>u4<WBuC?&(PG229M6><ak68;nLi+hrlIqjY+2n-qKVpmZ
zN}I9=|IzlUZ_1t<jT>(Whe9{pG?w+d_Z~SF9i`rozH!0SMcnHbMm#%7e7MA8DtYn^
zX`0a*ucqyx|8-B;^7t-v_C_J;Kh1mbGp7D{mi0gO2pX8*wu-Kk(Q(w5++BvB?_yo0
zD@h&dV_ikoO?Fd1Nh5273Oy!&!`DaOFk|DFe;FU_u=lclnW7rb(3U?U?aQww62Hp&
zOR5=9ydv{H?DZF<ofdDkrRZDa2{DF?o^`0BXPIBT%KXgHOX_I;7#@0&I`Rj&_Do^k
zWsFcS8M^U!$1r@fU%ezcNHx?O#+dfscIn3Pw8<U2RC?X6o8cvGmh#Z_-dkwvZft<P
z(Zq{-eCq{0p;gAK*Y!Z_TK1V_%o3TD*cdVup{plp`~5$dV2)J<w7J9q+u<i;RVOjb
z$cM^%*I_^F;BzZJMV`e!f|>VH4t|a`vba_m=i(lk(aXGd!nd&Vs84mj`)FjB=zbMt
z&g)@M5B-S_Mc1k5I)bh{_AD~@3pb$SKkV_zT;1#!PM>H(PU#chf=a)T`Igwd4y~hq
zB-1}6j{(m(`oUw2foaGnYq@tIo4kwr4t)gsi~Ek{!wUW}K6oJUY9E$_-O~Pt>IU&)
zpJgsAKEd%}=V&L(hh^hKK8`QB8=ta-7|q^iSnM-nw8!*t-`8~2*MdALn=*P^;9bU;
z|2lR)&1{o+Glsd#Zj<S>$<psk*qyX#TJKBfavI}<-2amM0p&Bsuz%FR7~d*BhQFsE
zN1O1ImTwIIC_Y$29UTl=TR(=5+bO?P;xgg`=4gFxo)QzjLz=tj7mmNRVpwY)?T!t9
zKsxcc-_|Xkdo$1bx!gXt4VnLy{k7;~E0%eiSf*#0zvaqSEA}(}t1FIS%|Z6I`qJ>R
z#z@P@I=;2ZXZhC1_v3@NQ!mG_5+C$+vfgdBGku+Q#^0%z?qa+z!0u92Tr4gzj9=_Z
z*b+A&F2U#z-GbgeK@8y7kwIL-{UKQg3gAyA{tKaR1G{1^qb)$YIq`^;(=IkjEGho$
z$+%z8r{YY1>ck=9PsLtk-R4%>Nye^lOMEaehz-`TZab6>9+4Q#HIAO6Jj({NTHa<H
zHOJ7!))@NBS^euYo!_y>$xDpG(#Iv9ciLCla5ily^7Uhht<PPj8ZtcXd5-psZj~`~
zSWDmSs;@VH1h#K5e#Q~cYxSQo<9Q!z2O9f0{o`kIk$Op8i9XZJoJ3;xBy=b->H%bw
zeVU(*#O}my*{2a-(eYsFiVIUz{X8xF!>%c6{&?bc8QWwG`~+0yJ4>M*@!=mXW&cR_
zbTWp?o=$S>N8o9&rz8IV9bIdYxrB@f=O|Cc>IU8)MvmzHb2GFNi{^J>i=CA9J=&#f
zO4wQxmhp`~B73UK(1XbODEZ#m8lHcFdUf2Ot)TBz85;ZE#Jz>c{Hn<B=TDr<z5#6^
z?}fLN+c~~&m*j6}|48Pm^6mof{7H}PVy=7Ap6ec5WZYRF!Pmb=p3mClIlLsjLD}cV
zKSn+K_i$N5V*k?K3uf-p34f7$GIF=E9_WtIe#g4fP_}jB7{+>+f0OeAmTfJittCdw
z#>ah}IBf}Wn&sQv>BSazF>i2V;!m!i*ITH|acoTV>)04}FjsUev4qSq9b95Pt4@~B
zp&!nbI(1PusaN+T_TaInFZr&v+2Pdr2`;w}IxaS=%i7r}eDi30bdY+C!EVQ5x8v|d
zdi_dsPG#=_qXXH8ZQiP0T5&o0%#ZcY_ikiN`5IUAq_DYH+DweixZJjvxytj=1uf5S
zy}tKbuc?>B&i<47%HDir68oS&YmZ;fW;F5s+>KiOG<;kE>!HnC@5^Y}`ZvA%;F-$4
zQ8VwSB-IVHhyAyj_V7x&@JyZlJi2*+KJX%RJbmB=Xw&fU0g<N#KFxYcZ_|i{2g(w$
zGv==sinMxS8`h4cKcuo2$a>rqttE|T)+Ja|OKp|@A^DF`PgVBrf@pMDOLQK6CN;9~
z++D1d!9!xDgVH~WGUs=y-g()Yn%BAY=L@>#VQ&enS>e|WWRZ0-^ISrlnwQJ-t0V4i
z>BMf|q0W<~uOX8>pJGgqHkP)Pc6Dr)?{e_}ne#7xH>>3WWhGq6JSDoh4Z2F(zUxmj
z?{2w^=M&nKyYf|_dyDvYo@H%gl15C3Ey;V?+r3VEV%ItSy4HQ@j+o~TKG8{(cQWt)
zDDT|)q|XiLhbxonUnB2%`0yW?FlD-M3+qkThLcaD?{~c@x=C#H5%-1}PnAKNGdFmI
zHK13e|D?7roDc7U;j&MgY1MZM^@W$%a)#8GdYXEe364GmpACLwI5t9?CbMt&F6&UK
zI_pYrM)Ty1#)H0;<13<BPnWV56?bLxsb3_hLl-D_zLs))8f%1iG1oNr6}vb8@Gf2U
z72kjAI`$Pyqnl4P$EiaFf7yKM>`eTmn)F0m@VX~N&g;gEJAO`2!ADMNy}+0{E>qTN
zuVZc#S@>~u&`7M-$@_EILOk+Gy)N@!>ebaZVy>+5IPEW3NAHMvzW@^(i^5OhwqC||
z>EF_)<i6{MaNkjEb}wrkqDL9)#eSG;w22<2JdHa2c_QN;{YCTy?QNpph@QH@pTn0|
zGo}>U^U!^=j?UO!YQ}H_&xl-LO<sJcvrqDZ>Ep&T4_$#jSdL%#EBr$)eqtGZ?o+G*
zS?g?F$ZD>s+50Ope{IMAcyaM}pU2k!f^OxElFXZ=|4pIJ?&qmI%l^@5F6jr(yHfmu
z<LhLP!oh_H>+`W^(?_CX=e_7fYzqHs+RwMp%V2iZ2=3MGGehXM9=r)3c#CF@f8XbM
z4(<M|ea1!FZ#?sAPUUirOJaf%=+8iparo7E=F^(FCn4up7>8TCh+9M-&V2gIj0eKw
zu*7=!fHdN^0e!G>p6UB`qRT{l-Peg3s=3<ncR!17UnqHAoe){r`4#Oz0a)i(Snq$4
zeb~ifx7PX>`Zz+2Ii0^Nd*m(p{d3sGSoBzf50z)<oRMN(WIT35yf~=cd=9&jxal-<
zNWN;$CrW*sxq#RM_KO|eL;aVchivTU<D50J#>us&J;)xGs+V!@Wp(w~^=b5bmdhEt
z645PxKAJN`1J7M1tqgO1VtjW2bILRoo<DtmxFyc^lQl_OcHNF26j|l0jHFZ8c(a`M
zV162Jr(25ex=S0^eU7-)IS1mL3kz``<kQHj-jCiPbBDKynS@U#^YITlcWKT=OuN@w
z=fXo`yH&D|EwK@?oy_6ti0w+ptBeM8E%smMis9y(G2HmpL$|SB<O~0>hBG<z3D%rN
zcjN3BF0u7Gct3LgoD8o#4>CqsX9|5SeT+#1&J}L8)=sg<>GYfFvK|$)$0^ti{rO$m
z_7(ODls~e(L1c(V4;nAsQJ-4NsX?uMp?0o)0k*PG>x?YuU43^;sy?xMFLjdr&*UQU
z(G$DFvUi|!#sFRe^u0;FA^MKPugMrPiu1E+NjrDNr85(_HQX|id4^G#*_+QiBCa5_
zw?NBzuSxsVdrDjS-el(D8Zyb=wv<8qAZG@hxbfto`;zRqF>(5N*42(9yX-skP*xkU
zGYbpW`Vr4_c$TqH`0a#W*Nw=5|CBz14X~y$Zn`t)GV{}C#21~y_T||fPcD^pf8N)b
zzINc6-`_GP6CFE!WU|>uWX<nx+D76@=S&{!e)tMGleZVSHOdluk(gZiO2Qz0Wjk_@
zarG5h-}?`<ul%&-Eyfx-pFGZQ_V?Jha09YN7+2n+4$e8&(m}=u=l$nLv8J?D$FC*O
zrvv!3k@z&9xo6Q#y~K~TkCJ^>D{g%CcJVu@=rDEqYcl4sCmCU%seN>>xd(WTJ*#&X
ztNLulP0L4(YyHDLs;~V<eArgS{+|}x3uKM$2(mUvp1mX0oFe3O_zTa}8EV$#1m+w=
zlo<;2m-%7KE4Is<96xw@dq)giUK4ST>~o5|AGW+~r+&i+FK;sIbwk!~*nhvg8BYE5
z!ON3=9KyzBd}xOTp`BXqywZ<^TkdCX`hNDLUuQ3Rnr0k-oPFnMR~A1#{o(lC7pU`O
z*2`Kf`)>Vb%E1n%i;Xz8FL7$mvQJ`1IgAURVE&|=_AcpuhEIrRUo~xV>u%z?KK?TT
z6aH|kYPj;y(Uy0y<##^q!}i!O!=}X##^E=V3imyLOft`w^Wya1;}0NTJTkq5j9*8-
zdmbLY`z{sV{g|v%VfS*jya4{Y*|(SdblC@Etm*4u?>(D6_fq!SyVzfUp4hbu+miaN
zWgq#w>?2Qu*LT@V?q)C9+GkGczGutV7()`em(Hq#vhN(P@+MG^xerg+E&Kaf)S>x{
z6L!a`@lW8dTFNLZjxQ4;!`W{x^u6)ujqM8`zlXZ`^#hUNnFoBK$inz+#j|$cQQx8i
zKIJ>G#TPz+KRCc2@vYB9Pq)%0rHo?+^_6{B1G!``JdVBXIAQ}y&-%|Bl4lD%9vziQ
ze)j$Y@O*Uf0V!|Gq;|6$UqnBkB}W!Iyj!UE1^j9Pb-150_J1*9_q1sVyNw?t>=wQv
zb0+)S4&O}nyccn%K=?jk^Zmq9)whT<1(}>FxQBglk+}?=%etBDy_eCCW$mZ=BZk@5
zvfubF{^*@gFTyU4ndfqdlWF_s&GueSTP<Q<?mV|M9;u9kdg=$(|6PIjOXZ6!pG|tP
z5gE$^q}jq}h>vo~*g4ss*|*5Z?EAKy+YtW>R>-}?-9Ki(MEE(rQ+Ui9$ykG|9j}ZC
z8q5XEaoFWM-RYSlEFWi={Zr%}P;QWN6Epk1#QQ4`{R8o}MttO>FX-4cYk}BxQd79a
zv~4Zv_;lK}4BO^xz?&Da<;P50j@zBDY27#C6Kc@mk9>*8|Ali8pBNUm`(Lo%d$8a8
zvESFR-$&?+Vv9*y;_-6qx0!VNvElvLukmo)?u*!P9A_oOcBgHTd0?PBW7gxlBo0m0
z<Gbrvzmc}$AVRBp#Mu4R3~Mhz<~>QY<7Dhi-d`9SdFu7Gb-$W6)!04#`+MJ%@w4^l
zKfNjb|M559qtE=yZu<4Frd|2?sX5b(-LInOEATqxOMGGjHX(BYnUfF3tIs$73E?I4
zZinBbd}FtpXNJi$xwQ+P*7}yL35{>f(379|cd(7CRLg_(xjE+8E_+o;tv$=K(EDQa
zzle5_vtU1Oeuh2n!EhOmSFx}BWiE+9We?c-_NN(}GTV#w*2GY_<rZ_jHNjj5l|A)u
z<4faN2hHAVt%H`br@(&KjvUtLpWIa1`+97jb)2)$y5oSBRG-g2YZJcmldP}OJ|@5C
zZGPW_-@hKR_#My^*k?7m|0Hup`fM9@e3Cx<Ve>Gy<~_S9t#=)^^dxz|XO~xief@#*
zig<sV^41@T+x-X1Dd73>O}ClprS2P8FZrZ~KVx6v5#m#P&P%el;NEBT$@)04Q8Q(T
zZS?PlCbfP%AZ<3z{2pqadCnn`wpoOZB{q4{^aH=7j#75!<!GLqKX>={arl4cgMH75
zEr!G9cO-k!TMcr#<Fj+Jb~!|R_7Rs1&bK`*Dq#!#-}(Gc$~<<BGUEm*^WCI@Wq#Om
zBH_Qpndd~(i8Ezh<(w1w9q0O_jSOtFi?)rUZLmpmkL3f-iR@U5eSXk6kw|ykRp&$|
z5i9;*o)gJO$8t{O*SE;tinSj9F6;5Jz3j!Bc}}E<F<<(r#Nmo~pLk)q#I1irKIS$%
zj2Fh$vqrN+<~CxVlSjU=u!*%#nd2CS>f5XDS&&+w<|mC%a~XSfsPLWjT}7&XFY5wN
zGCq_tue?wco-gC&Mdstqdfly8WWDb3UGtddw6JcM&mIh8XI@#nHTUUa4JMTIG<$>U
z3m4$0u@3$dWKs!gjycAiH0rx(Qz@s~F6Uk5RArRY?V49zd_VKlBIdI2sd|hxJt=1k
z{vcKk{mCw;>H_?voF>Yl@0e#DIqN)6<~9Ys_JyU$_Q?ChMD*tf=W^=sogd+yoP%V~
zdcb!<_prC$MZG6zYAo;O$oiw4>ykC8#k_0QKcB%K#~j9cQ#S$haSNBMKgzkR`_YZe
z0Ut$n;)vrfqT3?>6y^`(T0co2k^CZ))Wa>)W5|SU&*gn@6KhdY-p!Qfo@dFof<4Q!
zTi(50;tG4cezCO<aR+mcAHNs9gYQ5lm}^MXLF}VT>gTG%Sa>@7h9Zl%%y>_kh4@F2
z{X5uYI{F<DuXK$bGF}-DA1Qy(cqN&*AtkeKBWav?<qqy8UXe9^cl;qd5)!O<CA(qp
zc*QzTrL}NKlyw2uw^)mnx&ANvPqJ1e>w~Y2V?BU&KhO9qYizPcZY0x(7O;mtLLHI$
zaRGA!)(ehcLvv*Ot((q#jXbY%FY5{u)r2QBbRp}Wa@KyFWlNl^Ol@ud7<)*Qta7Y%
zmkE?*tyxLh2y5)3PZ_h9V-H^=exIx-9hY(ByX+Z?j2Gw!GS-T{Q$F+RCDcvY+&b@V
zo?+W+&8tN}ZXUZlJe>Bs1HHCWkLY5V_l{s4)F4iXBVLFnZb%?r3z+MA;yYx|q?P`u
zl3rM7`jT7I>*J&k;7k4soyop{`a$~wX*-E?#`{(MXV`a;nDWm1M+95&LwpZ;;NG<x
zd&M_pP;Tc}SjU^9`clhTZ@~w3>g@~9jfT&`$b!xnt-ZAO;_(xT^Sg#M2FiC*b@a0)
zeAVOlhv%@@{q(UG{Fvj9*5N0_AJMm~T1|fxZ|)sDX8WUN`ck{^G4uUoy>8bt$l~~j
zr#Z7Md*I>+p7Zp*Z1mXmVt9TjY2N1Da?;8EUZ=ed8|M8X_CnreZ94ib^~T=bXkHif
z5T843*u?q?=tK6ILg?(yb79UHtG*3<t8nOBY4z9fE`_tFPje2Zm)J}6*_qJ3aPOn}
zy>Gp!=0{Vt`JMQw_g+=KqMNo4(97XL^fEGP=_OUawqE3YA$s{MTQ7Z_bKYs|Mb`We
zd-URS>4nMa9PzPky}ZXh^nCVY8W*cK4zah9$r<NfeD&@4r;n311ic%2$c~++NV%*f
zek+bMAf%JCzhYOiruZtpN7fWu(BoXur+&krYm4*DwZ#dod#2H5tSw4^Z`=B@7Si|1
zd{z3I#OQv?`U7i=4}3n{atNLMfwL#F*4pyjFSayeN6%wJ-=(Z^`0l)<C(O0hmsx9-
zbP|hpV2i)N4hO9L*=w!8u<gz2^W$1WNnhV}8F`ew*7^><L-@Rfeh+zcdH|h;^l|a#
z{>4`N`&L<7U6w=N`~-dU9{TE1`mDY7yx3Y}kbM-xJP&N;$wWrZ2$}v}>`Lrc{6jP4
zx!b6o^1OK+KXJ?dWADx5tE#U4|8wpQ;odL>$i!q45Ss)<5C}w}xe2HV;Dp%Lp-mv5
zH;kfK0S5xKeF8yi0BZ|AC17oHuOiNc$M%t-eVzb{0@Y4WYXaH^;zSfl7|ieeIp?0_
z<Px+`f3NTF_x+>1Ug4f|_O$leYp=cb+H0-NIlwEx9j%)d|1A2JaiW|t2{I<W1Y@jp
zyvr^zp3kRU)>!MjUbxqpz4RBOtZ_*QkEOnH#zo_Bc!d$FVI7{q`IcM9`|p{S?SgxK
zdDLKi8P7SbYt4C7d*rd!w_kx56a2L4P*SSwy{697b|aIFMwS*|T}}HIjcNUi&{jU_
zqOH%dE2u$doe;4@5O4me&M?U*eNnkfhwac=4E5DV=qzES5%Mv&-E=mabYBT{1FcE#
zV@x*=>Q_1e=>wXIB!}BNf#0wPTTI#;=sfMSmQIXwEaM$@=7QXJ1l^%*ste%Hz}GCj
zoYpYWfMma<U?7A(W^1vBa}$qe>${%54bul;8`nFqqdZ&ZYsNvzWLl@hgEIIN&%S+P
z=lC;E8X=u6<P0(@bN84hxNv#eV{?`;e-gu2MDXXyZnNds4IR{gzf<0RVa>}QMRfi(
zE_^w58{A3RYPa!9>%45U+qj7OWwY_)*#Y$KeH+rCeaR-_Z4b4cf86J-*pMAL|FHG(
zeH*IC=ks=;k2jO7^AATKZ~MO{F(-e#A(^%`C)JMjqw1e0(!cx>ZT&lfp26xLa}2pS
z=M~Oji@}f1>N}E~euWKL_UA3g3yI;6=&$H4|I)Vl{x|rV`xW>)M7r=L8CvxEYv{Ej
zm>vfv!Lu&{&x*`{4xWOqfalo=JjK{R2&SJn@O;?0ojiLF@C1=hJE9TA0bnd6wmqIu
zJ^l%{?!&h2d5rYM(8n3hjn#LJpTT*IWcA~h<y&+@EYZ8g*F-1D>={JQ4y}lP|8Hq!
z4Q)F7yNR=NwfQ;xn{(E7`-1WGOXuZhklQp4H6M4*UP3<wTQ=(*aP@iun!{H+xp=qj
zE3^?D6<=gD+v`i;hT0=7)1H_gz(2WPLo<C0K-+I?y$J_GdUw{RZ?Uc<vp!jKmARZt
z{s4W;U>;<;_D}XXV6rt2GQo-VB>2g&4kj}XezM`_NZ(Xm`gpa4Y@5BC^{wc~#)+yP
z*tagW<B;rPZR;|5^`VA2p~j4h1EDU3`x+aDe9)LBISpOg{)g8b%HUjU@<&@6hdlgx
zV?)J9jcMlO)BbB8ITRZDOyjB#_BWP3`$1!X^RCio*Bn~)$g_=^Z@kfXZ0<*mIs-G}
zjcNC?Ccnn|sJUMQEc>2qJNsNhpT|b#zJ2zY+)zfJtH~ESZ#_<lI{WNHpHt}bV;fQ;
zeO5bV@Gs#yo%Sw=PFTNWL)$PAo}l)F>>r`i=AG=-YLNlz*`G-!)85LK-;=^wjG^`b
zyMGV}iB?BqN3OgY$6|Q8>M!n~Ka1(lm`Hz~U<{QnjsBD~hN~_xhO5pS!zVVp_cfb7
zReslpEz|DXLJSPqr+m<2^`Ra)uA@Gn`%89Uj*Y<lZN6!o;~3{T$14sUZwNIGd3~!j
z-m|OsHLeaFZ>*Sdpt0f74;xd_!)9dUg*3($A5<L5tj%kh^XxN?bLJmt9P;6ZjOpal
zH6K<S3Np?aYYsG4f6&0#7o4spZ?)>2@_J+W)(@bOg421Q0QW%734vQY(wg(w6AF*T
zy^Q9unln7hckKXn1^PCUZ}rHDZrNuux?T4f{pmZeVI94ibrzepJ@y_sx{S%W*L$=T
z{XLI!mA`iIUA|*~=-~S<=FcI%OSZTV_;hA$JwpSsGnEaT_0D{kOri59$xfQXvK2v}
zpJ4JQ-l2RM*w69Yss|X1-d%Y;k$lP{8Z5+qBN}#Fj!OvdKqt?g(dWr=iO58f2_-iq
z%HM(cqcuWjLp!1U&yg?G*1Pg01m_0d_CE5Rv8!4-XB*3lntaQ@W9cRgV6ylba=hk_
z^xh_CH>cw{zmJ?hm1*t(XR)PoQ9kAbY1o+{3$?|Nl0Le{D_xg|G4mq(#2_PeLRN}p
zU)nh&n_|a~Pr5+K$&z>aTk@Sz$z6lZ??4+H*k7q{KjHTq75UBIKu1`EE%v(++xTVJ
zI-CNYJ<wTc+&de_ypgogOJ7s?OE!D2&ips|Tih4rZ_&RY?L2>r-j=_G>fK3QMaUb{
zi%<5ygTF<R%ikio)!*X2OKg9ODsZCl;~cKJ8r*LL*858mDv1XYs$F1&`umXU%9f8S
zM=xMTd@gQ9kNgDro>-YsSq|MVcllhrLcZNDpNsF~J6eO!#k&!oi@jF=zue~{arx>E
z)e)bIn^~`PrUgA57mpNeJO!VV-a|N*y+|SSUadG5y^WWDY57|uhjZzlWdAg9nEh{U
zz82Z}{#IX$d!UVXpcktz6Xa{5y_v07d5kf9hC0OmjuEd3cn-?fLU3qJDB>*8_O*B$
z94Br}1ja4Qc?TcrZ?vz4#=ge$kNaBud1;%k#W3oR_O;+F#PYQeOqv(+Wz%`W!~VCi
z3s1bDuf-cn+xuGReXD8vTIf02*JAHd+t=b6@XnsJ;bnX+gm<k?H{)v|9Or^##^<F1
z#zZmM`h(k|3Qx1f$f5ZvU=z)6;a7C8wMuj@nh!$%$<TiWb@`$BRh&1lA80OTZ^pS&
zGxYa~zcS)mQR%T_H8^M9dGNu{uD^!)c{TI&D(34%=IsP{EqvT-^V(AAbP;1pz0LiW
zjG=yfBhIzFw2v{7Z^XME$2TI$!eJJ3r|_wyjS2We)WP578=+^#T5|7;r-Oq(G_^dg
zd0y)^Di1WbJl-zdqS@ZzCCr%^=qdVqE8$|B|NV~s2D8Nb62hAzyzgX$_bE0`J#?=z
z4t2o$cJ+wxzDwX~!{}$0&HG;E`yzCIR^8Y?{xfxlow}(fIFPzoGsIVarn-seX4TDE
z&_7f6I;U>x336_*h_y;}KdibLpHZ#r!T%m74>)yGkJf`lk@diR_H|DWod>l)3p;Oo
z;OWz3HyC4&(?8SCTmAu9Zs-6OY?WAp&W~BAwWr}z^My>}5s232-27Oh)}OevKq%3S
z+plwI|KKhg>&a7aa~(eU*yyr<`~Vtt*4l@=<u!ePemYG44?i_tn8aE5)^IJh99=d}
z=FEB-`rgvzt2XGIG#k5%&zalrLYEon#cE=cDh%fM-!8UwJJ^<lefUNs;>Qku+gSTe
z)(+_SB=+Ce54QK7yOCimT};F_PkY&F^c)@S(;dCW0qU<uuki{xnrh~)c)s|*t<y>h
zkD~6^*n3SM7ziEzMIhuc&HXoX#xZKTZI`L^V#Xi48CxcpYTJesYb}G$KIJ^mJy&&}
zA-FFT$IYF0GxG6BbX)FkCf^pFiJJe+*|$!$@dsa28As2xkn@JK^w)h3nh?<+i64m1
zs4vCh6U-OE@0_3R;!JQ8F`er1jjNU2ANn2Hz{D;8&e%y&a?&gGxs>_v8GOtsFL}q&
zX;l#qK{~CK!2Hk9Ujp=0-U0m;xad#1xPO-Z3S9Jebrk(2;C?Oodj&kz-Xt1K3V#L-
zK1)97KSYC~A;&(n8X7Ez1|N&)imF|@B8LVqjnLp@(4f{L$x5OTJ9b54cpd4RW{<ug
z4J!T1XmINPOB!5@zAl;u51(%TO|)~Fiw5tED&x@LTj<hn1KuE^WECq8T5TR3qj;=s
z_Bu|Q_=wUkjgd|V`vT(5IrfYLpvUw0DCb!!W33nY|J-`f8C+R1K4)6NtKsSS_IhFR
zebMES^&<P9tNRnqeyzHxCwK*QXWMnV*N4A%JAb`Uzw7wkkqw>iXSV)VdmEjfNnTpT
z+|xcJ2_EJ5BU|J1u!*zaP0*J1{d1t*58&Hb@b<az^(3>){u<^}TxQo+eqIDWuSVv{
zBu%z+nGbf|_yIip8Tj`Qi+9I0%tnUJ#onmZW)9w#(aB$t2;UYDy>AdUs=%TBPaJl0
z<-nzVP%=Dx5q5~*0KNdQG2fa8V&5d5E8eQIf2FLo$GX)B-A5S?$>666q$PxZ3Ld}9
zTHBGm+27gQKm0j-#oAkSu&>%<@2ifx*0$M^wJpI~+Y%ycTU;wHw6+x>cQ-&=TE|3V
zOIX{qmdO{Ofi-TZH(~!8@U$8m$|>My6JxO|vbK$3Z94`0E$~=m{Au;E$=2F-8GY3L
z)>+$5!&hq1!w5gMMMmh<95YmdK4T|1tO0k@#YiWk^E*eEaTr-}5o^;D(q$v|IeLRr
zo<s|m(kmPRmld>gA9$4gl<=4itimJrtF~KPmb2%u_*s;kYsDFj$hgsbpaOimzljfA
z3jT#7$*QxW(<8F#0nTG?0j}sZ;fs?x`)IQTWF58QG~M)2Y`k%Co@H-X_qH!yareek
zUgrU+=<}Dq<BL!D<QG%*oHpW|l|CxX*pY_q<jAOe%2PYa&ZBhYbJnR0;wR@0^1j`&
z$3QMJL!UCX=O!4HHz5xlVXW)um*hyx4>Q%MM31pv@6P%4F8ZglYQ=q}j>^}lOKaan
z!0?~+P4TCT%8V2Btm8!i<3u%dRdlg&qNKn4A3PO9wtoLmmVurJy+fBff8E$6?=Ovh
z(^Jv#>ZgsFm+sz>WybB3{FM3YN&DC@?8~&C3$5QY)3;A;Wl~R(VV=mq?ltSuWuf|u
ze{d++{6gcUV*{b`E`MxH8_e0?qNc_v)VpT1Z{ua7@<N8uqhgNPts>JjDjqSrS3Jt|
zn#W#WcW}Ugb@7MZT6e(gQSs)32iDPkMdpCL>xO!|R`guIbKM#<zTz&*Og6hztRYVi
z@@_SIR!n+u-@1_Lr_Qd_N!<@(??>6={_;a{jZZc1C2jUKZ!~7zu71VQpTd0^Bgg}7
zmtObNLm5NSg&zK8V-|h+fHKG4c&D)|<vt3pIaIjz^TxT9J<vOB*+5Pjyeu@7dOm9U
zQ{%AAW^5I^ZtM!*nqzj~_Yr-cPv6&UeSO`W8~3k!g#KT;Wbe9X>HlP-ON9@(p8>{6
zBf4+&ng0ES;4q6Zhy(X=;QqMq&YboEAL;vi)^ou=gJ0qLvaJt<GRS}Fh=)Qx%J?WV
z+`PSM(DH9%7vrg@r~GQhDXr(S&?Io6zQuby73!P%G|PyoP=B_9k4G5OedHY$li#Gg
zlX$<8-{au-W8f^~x2vZ|#kGvhoU#6m^Nsk5A3p#3x+=b}F})Q}nw=^-J-2h+$BfAh
z#927NILw%~XPx(NOV=K_`M|oZMz@Mj7~3AS`7E$~==JU&Xgn0s7>%IbIgF1d&cAWQ
z4-T%IL>&acdVUUdUlJb(-Syc1bweKVZyYo+FSN$!S`p9l_0Y^D+FfaQD}H0fR!j=*
zTQ}2;0hj)bgNH8*r5h$OS~^ucMSCC9M!*1m%EkgCm-Fs>gmO0k^T)KY=XvPN)3f6J
zo8Mfwn=z05##`&&1pfJyy@5JTFz*h~#`4oG)3{l7-y3H9KH+B#_}R)|q3PfF@vo=s
zJMimk_bFZ9-!QxFQ`&02Kg0LJ!8~7T<z>DIzlHlKXFZGl()gw^Es8fz9EFc%5UW^o
zN%WApt7yAu!nbh1O%7cYVE^sVMCPvx_7T%#-(qCmTIkh)R*Rw0H0W{$I)H++d51;I
znfN$OI#Dz>BN!Z;k?so@`r^XJq3M0l@^R?b_n@&c%c9}9jjGQ_y$0U|m-v#yFH@&@
zPh`MD#LH@?oQe0xmQBsVCaa4-j&aQjXF?-$uL^8W#jiAzbvj5KH9s+s3}PyuyMI@;
z!<SO)i7U*xXZ6lihYI_aP3=lOz9*_0YyAJySibXEqwj&5jlOeNAMS>&vDzxV{!F~$
zW5gNV_CG><3;f*~n_=NKjMXQ!S7gRFtXclZh6ZeryVBll=9J1kea)HpN$2v{O`(lp
zOJ;Acf({?X#(RG0yzM=F2R5{r-5VyHX_@xXgWWf#8r>Vph8xqi_Jn_)@K}CE^G20T
zeKyZ~(8+rg8;g&vygeGyE;FWW>*GCmAk(Of_r19x)ziJ<D7Gm*9_m3|qz@y#C+U7y
z`YBgBXO`Pc(rK@?{O7Lpp`<r^+Lu4+N*_Y{G1A@TKXavLk$#Z$KCb#db)|DgxovM$
z{rJYV!k<C<^HJqbxYEBy`sS$iIb&!oe+lV7iK_o&SNdSmS4EZo$d!IE=?kOU=j^4m
z{z0VQ5|z$*Ol$f;(r=7vzrmHBPI^vM`QxtiG}1Fk@9DzdF;{vj>FH7R*Spd$BHbTV
z|KDBd*b8iHHrv<#H&;4q^R_zD-Q)MZE4?4-yGT!W!S|jky)Ws{N7aASmEMQ+5b1tb
zdCo>#@rN#c+fSm(*SXS@Nw175U+YRwB7J#O`FCCEiKI^_-3|X=UFiv=7n1Jo|6g3`
zy-ClBs{emn>BL0ZmL669&#rXz_uKlA?(YAeT<M&ZZu3Xg|3_Ck=eFBUu->`h`-3Z;
z_>kL<k?yYl_pWr}b!<BrRsJ1UdRNkSM5Vv&N=MGx79!nEpTBdZqnFsWIja4`u5|Pb
z+bW~VA9AH5BW_y~)&4<OI%j&@7Dm<omMfh-$F^Id%D?GKXP>vNFsl6nu5|Ww+w!97
zf5Vl|zG2&lsPeD7(pjgrWk!|X?@DK_?csZ4gZQ`B0WWDEJ=ksI)<SQk)`C3xaxL+W
zUfV^?C}K(+@4R|LH)Oo|U$i7^ZAts|^bIC*xV=8M?H!~?F<4{LuqD)fMEgt0>*yk$
zo57!S3hBeK%N>>1TuB~V@6tPbJ<r-7J;nKgQ>WXPXbyF#-Ha<@&+{d6)>X;*ZEJR$
zZo>@Nes39P->va+R%hU={WQAUD)wcLZo{b~$UZ&3r*sXy!|pW0llqS8*S@i>jrM-k
zLHegYTeec;xlbX_uyifDm&KcApKTd4jmk&x6Hh9}XK9)d+Jb#rYP_+-KBL0FhctVi
z-F9y2z~<oUJC<%HA$)5qt~!Rpm)8aZa#c>I&$iDPg^#yz{a4zO-b^r+ehEx}_y=Ih
ziNG}aD`2v4<AO`L`IQTfYrX`ISN;Jwk|S{RZiS;`A4s(;SpJ<lIiCp$52fe<x?m44
z8~eS`Ffq>#b{&v+I2{|GR5Q@{BWx)$jimjgTk*)MJtlkl-o%6D{s1$n;yr%fhd%zs
z{{Qdbm-G4cJ=t3&qT7{jR(04q?!@pId>3l*(ON?LYPZIdSg{JdgMUftO{E?qM>>ii
z`j(d28DrH(wBE&`iCjxQz3?3&8D`m9ANunmVhq*5(|pi@?4D11J9B0bi(PdmE4G5{
zcB;wynKvd}-|}%|GqInAld*|q8*(XI4ZqNNZy`FRNt_8-XAhEZ{ec&9vBNCvL>wc2
z>%p7igb4nA)Tj6#hwz)`>^#iGd&!RfA^V_&@D=nOd+3+Sya^R`*gaYL1-{jL5-M`A
zt*m8VUrw5zKgHcO%-$90W^%<)^6X;X<Z|XvZ0R;q!k_zu$ApR?wq2QKpNeYqZlOl>
zZ*wy7@$Wc>xr4(8(Gl2qY(I~5u0bqy@Z^P7?3h$NY5P6vdz-zl;sLwu3{)??(b8#r
z+5Ihk#zN;$+CzxurkUj%$~|VoldOGl=p#~14|W7*IAz2NbbdBXa)z_^BxCeBFo{0J
zZ$zKqXn&?@R^*y74J#O{a_GsXO?>JZ|M$>Ky^np8$4uF8(`Qn6A^PGx;1q2ZL7P`X
zldlnL4_-~2yu`51rUk<))~a9ey$@xVdXp=TQ2)!;SoUqzm;X0o9PlPq<atx9vD(AC
z=vw24!DqH;c`)?_dDnT9Y<UZaOQUD)`wA$RihV;V&s*Bnof3YIx{_)49r|<<8#Tos
z5`Den>Cbork3}1a6{eX|@f3LlTQT1qU4B&rmTFJRexC_EXF9jevt@If`Ss;Aa{H&Y
z9;t0y+pl@zC-UQ8MO%vFCH|_|o{o;IJx#nCQY_DCA6Dij{>`$b_CRk&IL^h3CNb8&
z0Y<MJcu*ntk@#8vvzT9#%s%iV?4*!Kq=R<mvF0#w+r!z3>o?>wmwe>UIJ4}q=I%0Z
z9$eA!+)ZZg%GTbgYc%CGN2MRu{JfU_l{2nEk1-~wa~61&cwDkI*OSA)#}C-H|Lbk>
z55;##XPn#SYErlhbG4rHzsJyxQoeZ|v>|-GHhUy<bt1Tt4~p$$D*sYvp04}MnWr7&
zPkLeD?G)$hU!&a`;B;*0_ihP<Zo-~137fbj9-|`nYsT{fp=<HD+}q$=(0m5>2Wfq8
zL3iE)Z1wbw*bxaC-1!q7Bktenr%(6(aDGI-W{r(-pPcac277ME?pXe`_-z8qXV9*V
zN9T;Gclb1QZ2F2mf1|a}wm)|wb-8s3KlsGKiJg9qI?D`Wv^$UFrd{7XJv<vbE}PHU
zc|RwwJKsI6b-fxo+W~#HOo%_Id(~tc4z8_xvUEOOPd&n83c8!RK{}&N%JP&EbDQT6
zNyENj6mjiFz-y*eDL(qQjD^s|G-5kGy1x71O3{-KUyd#KrspU4typ>{<ylv=RLAeA
zL-euTW9)dIXPx=YKt5KR?lZsO1<w4Om@vaB3r)OmFJl&D%xrym@78hp5$Ve~^Q%X<
z?AV~}f*;Xud<d{Txd2_d^Q(`?;1$cL>jnNKGYbDzFQ2~4(sS{i8xvUA0ROYcqD@XU
z@Y4})V<}e+ZjN31$kbx!(8$>}Uhlrdft98|u+<+hmdMu4^ch=I%Z(hjoT@f{h(1hp
zJ25j`{p43V@oO|seBr%TKU14b#%($=ErN_gDYjz5t21v3m@_rZ|ILg|`l3FJZSQax
z8^q0wV-<OQ;#qyr&3lc?G<@37)mwS?BKy>1XId?v5Nvdu`{lY4->;anl_0#z?Uz_i
zKWkigUk-j8pK>QArNakQuf{IA?vt_Y{TQb+7J~Ot&RqI|QyV9?uWP%w&G<aX_QIwI
zujRk@8SATPdvnFtLkW}>&252Z9hy5r-PQ2FW6)<d{tb#T`Pi47H&^1zT_5q~;G8@X
zQ&KX7%_CY!e^<1}7%4WP<`LugcpdNRL#*sUSDqj5ZaaOhA9Q}q$rt!8y35$vDZXmu
zU&m=LQXE@0UUct1JIZ4o$=B0~KWo{sPVlszp}6zbF(#Ko+jeY4YzsBEoVhr$_a387
zt;@n=M=(81y1PDSd@>lH7wNy|%2Lyjo7(1u>f;i)$At$IKR-9U<I@t6vuvKG^CHf`
ztb0fD&UKDAp+kF~oiE!N)aA%^*bznctGc@)5t%+Ayofe|@zELlsqOSB>{|=+nvas#
z*^6!FS-j~KK9+Vn?cvU)eG6{vN!@TyYK6N!Tp6tYL#m18#IN=s>buqz`Tt(SzRi~r
z2>k$g?=`+@ucG~l<Uq-Q+Fz`<_9zL+1hLk+bdBNcQHU{!?DHP5YLC*0Z<B0<FKM?o
z=}g~a;q9^E(a3^T$kR76E|wg}UZtb`$!o3qlk@kh&VF3K@CU}l%u)=Qw*7M(uEa+y
z-&tbz$~RW_!nC_1)ifK@%)ruG{2|=<b9iY6@^dEqOMdxjX1<lrNfZ57f7m(RIQMRi
z)8-e~zZUvFW5T}SCB;BsO@7&$Cm-1Pq^l@iVOIW~IA8&6Y>MGYoc*qU<|AAFQ{I~6
z?dx>T2Mi<k9qeo#HOeok?8#dDDRo%y<F2gi#`{KB9l?*=*Kwhk1=X~#bI)(NVD1f{
z(Rb(kvktx_xOT2Meb=WE_<u>;#kz-!zC6!!M)CI#1!q+^*4ON9EHABZ6uy?Twh7OY
zamt}_^V<AocfIMzM;81sIhB8*-k`@*3Emz>zO6Kd<~2`;hcm8{S(`^{9MGF+4Zz1B
zyB3}gy*xUKIyJUV?22~v!%vPv7qs!5k<ty@dpjoWZrbVyp3U%F3!aS2tUKWF8C@@b
zaeLm`^Izpcj6r6nah3jSJ<Thb!|rt9sq8PE<NwXyUiOL3Q~W=jIc{s8$4$?wr{E`@
zEM1fjdl`qm+%`3uyWFi}^R4Ll-^sog+3L^5Lo3}hTl4r=*ZY?X)H}*u@7V!Xy$)Y;
z?hp=wBf;iFN0q?1X>C|Oko^VyKsVOwb#!saYYS(A@3I-j!2!^Zc$j-H^XrI=5#3*6
zsM-A$??PTuoV3@FMY>1eGHB0@tMgz&H`EbKzlegVDPo`GhUv%uOPG#f1En#IhRLmW
z<OcK(`|~HtI(T*G=We17^B=fC{{Or{{@s!MEqfGqxL4@xM(r09Sf>;5RY<~Dfx8nc
ze4#~=u{^rY9}-R0-gf$~_cz9crbBN7v9bSq5qm3q<d5_)x4xI`+4{Fs@7DFR^O{%g
zj;XwexpOkMY^`LsV}m@EiJ!cSU6QAAOr24=9hvBrZ{~)|$hW=d>!B@P^Pu*#o4w1n
zZuWkCYj4UfCk<PosR=wQFLF!emX+o~<!{S7err7GRoH6w(y!)vd0*zb?D12xdh%@x
zX~>t4re8d=G62lVulkSRBdqbcKQd0v9C6c+8}|z%G+{>3-hvC@ewLG;J+YfsOD>TA
z7AL>tbQf)Z(;2G?k}YFHC$E&96!(FwG~31clddO|KiQ0xA$QsHkUM%AL*G1Pi@Wk7
zc8DhOhvESG!q|?j4`8P}1HE)U@uFpW<3oSlGK4l1hZ%fH=C02*aj7kv%3W}w+D})G
zW3Am<KiSw}@!kRUnp!`Sb&~s{wU&yPN_Go+jAjq~KaH~D&Cb4Ox+Q-X&=<|&t3$+y
zX_X1x`O;ZKEFShmVx={PH(XRHI(+ia%{LqwS2p!}=zARFsJSA)<1a=U&Cx!`y2D9z
z)?bEf%33i=Jn6<|p;fF+y*clfeuKNPr<KGs{nBT6_ow0u-v#^$7wI#N9+|+-J~5>I
zzi<Jqhng&TBY{}eMsqXz6zML6lherc($^gWHy2Y5StzUSdgIs983?DVz;h;k&RWNg
zfiJ~_uSa(#UD8oYN7*Nw>BnoCwuO7v!cZOU+54V^u*N}cX)IJ9@jtSh@hGQmAA2Rq
zH^*`V*4@fG!5{a=g;&KIqmMm#b>{I2_88S;|DEQ~TN>ccXKvaslrb9QY5HZV>3uqb
zXJ;$}ls`rp)ltfQ@5jd2^~&b?*p>G4W^_Lq>wc75<};p0rnTBk=H0=e`XYKM0RO^^
z@Fv`-55k*pBtJOyw-$UleO6zEPxZ-xDd^d>A;fqdzbrsJtvD-gk9_8IcY$Ktelaot
zFDt;G!;WvO^+9v`1$@&r-!pvdDMbVLZ%EG^0A8hMjH93E5;7CenP%8^FDETCUe6xO
zugurU=vfH-8RLu{>Qm-$e#e?QR(Z;ZRtE7clk|aUo{;r@I5_9dwmRZuDNWxxf}@JI
z3}6$D#%oS-CiH(CChWc)nC$iD{CETozSy&7Ne6k7@o{j63^=Xy>v=gT3B(T7nlD_z
z12!|i{pSkS)uYEd&VEPnU4vgI{yX>Dmoj#<v)b@miXTX>nb^RY-ZTfl!LQr+Exp{>
z5xm08nMipbzO1TK^~o18480eYmJ+KiF)UxN{n)oFZlvx3p2OJA$wF@8TdKLNQFrhh
z^{nqZ5PK-C9bLe2Fv7P|yBG^sB8%4aN~w6~h*6m`o%1UCR6`sSt1pa;)fdiB)Ry#@
zUkQt+sOdad_$F8cgJ6k<BX~t#P62&<7hU)}`9|eYY-iN3Ah;4;Edm#%;N{+diWSj5
z27^Q6!OLx0Gr31e`9E)!S^gt*ri*yv`S-kQe9`%5q4UquepO?vyD283SC@TjE#uMz
zuQb7__|+eXZ5tp4YY_Y^U3BZD9VD&HYm5#urkhljbNV3Tt>-d5Ume)--75_1zW7>f
z6zY?>uOJaW^j^LS#UwbxUo-ZuSI}RL!vy+&jJ6$mE92Z-?K<x}nN!DTtBHCtpp8;=
z2CGRgC=E8%GWNOPTl000`J=uoJidybd5m5<`w;FY!7Bss6^;KM>>Z9V{`I{AJ5Fse
zD#y}xx#1gA3eAcJ@;J}Gg?iY(CDg{|HL2b~-t+4$q)zd6-6=E>8wibQeY`P7eGq(^
zUvzGT?<2-0$amoeU#w}tY@0V1^ZeaxW5*KO%9(&}+nds`0(*pI8;m8H_!UO?GmX8F
z;8{ukCMIv_`xJdt|I|;NgB3>B8;ib(^%Km_v*Ph7W^?fJ$TRcUq8<8L#dz1}ql1t0
zWnW33<@+!HHGRv7Gpuia;{DxNW1&f2@xdTtdM)q@N7c}<&SL&iJRM<wDcGtz0~`33
z3?aVjz*EbZJNPR-*M`4(VE9MdK;E_5D357tBTZ{qWL);T>TRIjWyBK-(idzK`UbBy
zcKissN~BNa>MQT1Tdv7mlw|1sx}KtsV7{?qvx7r;eICy?Ud$ZXcB?LxlTWhq{5fsv
z?C^}G_ieiaS@$11^ZCnovgWKaU&VWW(@A&Q`Wke<%kSxz=42CdS~lYi_)#DArevjc
zw&$(#?QEU5$>F1s^eWbPXYTIQT#L-zVm&i=OCobuX`)Am)^@U27p+OJrS)BFnAUTx
z+YY_eX$+vZQqoJoMK%28GVrk%Se^OI-oD-Zu7U@uZp~ZKw6!)e$JACwJWy+9Ffyl1
z<Pv92RZ(vVbE-G(Eo1MQ&U=Q&g#L)1mq*5@qjBBk&?4h1*~Tts=5*A))^=yiqGKbA
z&uR_T`Y9fJF?tN?Ny=Dzl8{F<UgEp5)mX-O?2KvSv6AC#9-9<iOj>a#W3(T*+sQHN
zuZuTI_o}gcjj=9P8e^$vgJ-Ls^!?r_8op3p9sJ18KL~zRk7(S%Z!LJi_hm;X(l@~u
z+VCVh{Pr<~+tc=!*cN~<><6H6Yi+V{CfrH(hVHTzAIXxL;EBSGVhb00jM1gQXN^&|
zne#6GZRyy8m4b)h<z~(*?!S|)K^(_v;x(GTk~O{~TvCrihqds=rO@gF@X9{PfgPfC
zKQgYvd-p}w7=yi~c<*HBXQsKn?;d#Y`>r)cy53g)E83^NT-KX@X5XwU%>G#=jD1}1
zJ{5hQG%9ar%}D@`w9fYW;?&i~%k8=*(bh!T(mG?!C)Mfg-w<c^%Njzxw-KiWJ$J7a
z(D-cl>Lg^adia;aPen_<3DW8N#z;4(HB;}%G}-PoX73s9Oo{aK&+x>c*XUKqpYT`;
zZZ(%Q*7xFnD_KK$Orvg#Mj~>E=%AjM{Yn>Kx9Dq<&Ewl>M04rO&&QoP6&))}Hb>uw
zkE9Y;vyA>)dthim`X|}nd=BlLf@ZWgsKdtjB>S@_XzCaERb#J^rF*OtO9tDTEa?Z)
zRlqNMhl9|O_R^xGj8SIJGQ|gFth5)%7;ff-&}(Z?kj7k+j4nFTo`9Hq2@VX}hl`F3
zV6^xa{O~Em=+zP55Z~GaUm6&1G+)dfL3KH}%oq;7BD|-b{wUqSWkx}JTxN{DFkf=^
z99Iz^$KpG{ZsWE68G+`2LEmjzUvp3P0$%Xv3*Q3X#N!pmnRt-k?0nl4)|FA>gKplm
z9C<VvpLOg#9DE)_UoLzWLqBeO>g>NGylCye5MI)e2_3xbV*Rkj5WG11F6Vaxv4n+_
zbJV3@gEh-ZE1mWILmIQv`s&8LtM)dQ`naP!y`Vw54dt=%)@GxTFwRq1_R#~_LfPj$
z0qg)*@Ge@CF6wLGjaX)!^V+eC9Uk~8zFu4FZ5{F#JuYgJzA}M!MZdH0#|#2T5EyEJ
zAqWhq>C>>SFb|rV+bh1kUApli?zNwE^XgkgZ`g74oV{Ye_G0E;sb@fw&oG*OzQ7KD
zC*#H-`x(E_=FuwWN6)YH;0ndC%d_^+Uv$oIa$tKM*nSX!t?dlLbMQL)=swqfur*J6
zI<oCd>^p{%49~&TvXrJ5sI$t`x9PY1`ZzO?E+=Ff@j5$r>AIYd&JU_q^lj1^LiHtI
z2PS-RT`^W1*c|*j`Z?*7MX$ok^cm(s105E)ke>NO9k>XtxUDG&jTO^Z$t0Xx93-CA
zdbgfU<66Ap_NFI+t$;pV<LZ|?wz#`rrhI0>uXDB_KHvk#vS)b}-IQq0(uKzu%|@A7
zIU=I#HqpC9_d)rT=RwNpTxdCPIC&gB_D6ivxzbI<@R$v4)I(php$~tztDE*gBeS8A
zqV&Rs<y!BrAYLAKYXj3l$vM)~1c}FBkGUoHpRo8b>!s*4!So#bJ#c->{GL7#Jb}Yz
zbdtj1F0J+Krz{*o$HJk?>?gnETfr_K`)%vIvNwDb-+pK-n%;qBgkYHfKM*YPo&E6d
zEsuY|pWWB?G!&x0nh(<q<K+yV1zV!dnz~=zbT2e>5_)+IT1ooL;<bwPV*+P6{l*3n
zot1BLCgV{~d!l>kA>q$fU*Du(_jm%$mDCyh>*BSk$OMuJS5a2;K9@O_dGo4UHzDV!
zj#bp5IaS`*Xl9MJ<`jLoQDd!k(<6Izm9075^0M;i`*eJp${5S;wDV%5kB%Rr6|0{8
z-8A%*(kTni<>c-Cy-nE9D!wmx?2L^jXJGeOafR{Y2M@wK>-Ku(J%-Gpd9QKQJh5Wx
z?lD?*sVDKxc4)|%D;g`!yRz<`<Negjn7-A0Z+`Ou<_EICTbau*s(hC^h08Q><|oGM
ze7+xeKB+R)qw4PNdp)|dc}Hn?qf)vS)z#3gbNtYA`G+6Iru#59^UJyi8mF^Ic(YSr
z$uV#D@JD91$*-9`8V+<adL0<CX~O}0ncn4n0&Q&KS21z2%)pZQ_&ODto)gDet9P+>
z>JC8cTodZe?vt}JGb%DV8B1=Wet6yzwQ(KqX^dMLcMTcnh*@XeN`LF?mX3JBCCzso
z!O!}?!2M9_UQPd|P>!)(qJ7wGe^+$B#*#Stqdpk1o#Xd{FX1<uFLYS{pys>sd*Q=G
z{i3Za8D9stRo>3=uSDvCPS%eiO>2zWDUazKul0A2_!4;afp5L%^R9Y6BOrk@X3o4<
zy#(AksPa3F&hZ<mTV?%>+c9L3**s689_d4i!G|+0L(R^XZx{ExgInP|!IJ;yA1PY=
z!?^AhEoK+%eKz=cxE1$Z!VTPiFrD>T?Zvgk#wUOyd_5;;KIpk=mB(13?`3CW;~xZ$
z=s6ywZlBq$OOUaV{%J4IrAJa19|!+d|0!4Q@lEzo7y7OxACjk(_SMEQo{#;_<^^9B
z<5_pPW}wFw?=ObW%AO|u5(An+2S3<&Nw&s6<5y?X*u-Szroac`8Q=Jy#cQ2&>SSyi
zmV+<Fw9Vu9-rfJc{k!PtZ2L-`A@vSlX7TKVa5`;Bo+o}1G-BJ?W%GQq(UiT+L#$}h
zIhRj(40-!xx-Yw&v#V5d^la6OZYzA6KX<)-+SS`Poam}Ijpq&LT3$I0K3<DUy?Z+T
zP%7J?Gop)(mrh&!HX$5GzB7^M6QtF1hM@hCnHU&bz4D@_+_T<=wa}GpemD=qhY;H@
zVoz6j2Q-P+w)5+c<UNgk@K~zRoO{lD;+S`AxQw~kKpD|eSMogEC$M&F`u+`b1{jrL
zGcG*0C3j4m8CMZrY1gGYMpKyopW|Pxa@%QNWxwn7SM)UlIj8!;H<JTnvFBQw8L20W
zdV<tb?~ThkhHi0t$=5^4USCChveB&gPVaj9H9UzgmhPUO!LRQ7!<L(INevTQ#_GHK
z+X=qO7To>q1HOfbLnm0YE)AhCbAe$^`o0a5=u0{Gw$A~EW!|KQ5V4kn$d9YN{jejB
zYw++~+}n65<o$M2lHsqYj%ThRLmY$dPO%?6PJGYfse$H?I+soL)6dW0*V1E7?iN@Z
zUb%8A{+<<ugZKCC51sXpUkLa<HpJK=-LPP3!rnLzoJ<CuIq7>hWCBkRcxD4nu4$e)
z#<#$T>y~CN-?X8x=?@omHcm{2uU2!vWJUt<#egeygt4#&{bl_S*8ARyxyLu=XW@^U
z<EtisFW?itGPu`7_qi&~H@NS{YHw;2`;ql&+!3a@$}OyQb<nD<gXkT;5}UA&>^c;O
zKTo`C#jQ=Mqa2(}_uST$$8SArs`O1;XxE3mhU5g{DXklOQ1)2Dlkkwv*cN%Qi$$LH
znMqkMdsD`2;2cuCcYtisBJeCn?<yG1&}OuKiD0-N7&dk_UMive3H)xRf4W=s2z`Ff
z+Yei$-uO$Th7s<W8*S}Zp=%U9XdD`#ySc6OZPP>uT#LTB)91u-=%kD>n8X;s1H*ga
zWBoPOUSHND%+H(aI%mt)Ddb7*<?B=!SI<6Leb&9An)B$i!#A@>b^4T!UZ$S7Lp$LY
zOLq_0{s3}raDHw`^U;83h^IN{q|%vvS^VtRB4=B|+nd;2bu?ae5j-WH?L6jl<b`+f
zu~OTA19su{UhI%`SI4Wwm`~*S9iCO+pQ%shddC<G$r#hANAmHXi3Ran{{Bk5SoKMJ
zK+%r&M(BU6_49SgD(_q5i(bpHZDWsZ+q3T`-y-x6%BwoJwdS|&ZL<0sy^79x7w&`?
z6?8Lt`H`<uyBP}~<~?<=vG7{(lbUHP)cI}drN+WC^wF9R(pP>Hd}@wO=2!dW*C|uo
z30q;FrMLcoG^NY;c^>2cEOYQc`s*9kFb8XxgYy{wOI4P=cbVFu-8|Y+{vdwQllsKm
zbR2!DbeO3<jfFdzJAx@4efB?6cX#H&Cg|&9=EUo?TQ%bPrE8!upV^hOiI|(>&_O7s
zqt)K`15Nri8#`v{U94||1B>--ANJVNVcOrytZ$Pz$1DQgos3x#{hbbM>`h<7x4lAq
zwHg}s5ibB4;-x%eY_`v|?6jD>zOZ|5XZN+t>g(!rEu$6xX+7h<jz5j-SH-(jjPLh3
zJC`olvUlxlywt?~mg0>K-n4Mv9szuUV$sXQgl`-Cr@lI4KgIg3analyXLP9$zxs4R
zbNuR7K3TH?d-%#F%+X``W=vw7eu4~CG}2gDz&KsWTnjE;+Ej~djjsS}1wJab^x0U?
z`c}%`N_)8@R$8*9Pj>i})8@{zowMtiC%Nz^(X?Q9=A#K7zbs~;Gau_XlSyNa<<VX(
z&pzn92|u8o5xjlTqkofIm*tE25GG+um<=Di4|%Tk=hy5|OlI`MFD0Unkxi)f6ot@N
z&DFBorC%RDur|dHul@AF!)BgQIgk7S_@K|5xZmG3u|j1$#O{#}B8~J;q+i1LGw0q~
zzs0tt*wxjDS6wsIRz7#W^ZQ+N?yRpbTQcS!Cp07HRF;yK^ha-V_PI?p>_gr%YA>oh
zNBmR=RxT!7zmvU>U~}L~1g<K|T}c{e56EQfap|jVpF>PG%4?5Y?qOd>f3=VPaV%>;
z`QIkS;*Ti1bLqXvR+M#}d4AD(Vym7a$o|zYSu5Q*kxYD^ddk6%j_+bmv557k=_2;B
z_yzT)&VXX_87URVyvg|L_*WatQ=6u<uiZucqJ7bdY~)`AF6pw}-(KOH_~PNEqtVl}
zoxi$ad4oK!^S7VBef&x02ZzrQZ`L|<%Yz4L-pEc=bUpH=*!beuz>dzq#@!z|UtHf7
z$HB_iBee-!KW98@j}_(PcTz9-7_E9U!JU8kMLA!fGj?e28Pct?-?a5p+LLPkfUNzJ
z4>^QA-gDyFL2xeFJ?*J$c6{+o+m7z3p0<9!n!KMe|Lzq%fQR+?!)Y&k1bz})x~OSY
zOUp}X%Zr-!(w6Yw6j?J=pHtUv>Jl7^2PeB6gFWs+3--Vm!5}-0+~uh`q_^%@g_E5x
zHpSO*zm4!G*?vDbV_)}N`tYpETE6Eq*8i<E?ntWV&R?gljHtRqR~JevHa_{K=DXHh
zoy(l*(XT1`-an(8@4D5rOJASM8?kGA1;1<fdz8O!d+#~C;?iB?&53pMO9t#3fAQd5
z<74~o8jn2i9Cr0qKF`D>^Su*~&i`6W%5}!X_vWYfzvQ}~n|J>7`{}#Jzm>Ub{Coag
z<KxcVa9H(U)qn7HJ<r~7*z?JQhp(QPGJi(@;nx}cFTU=Y0Vx&?gGTQfpWgqe>n8Tx
zH9qF-t%r^NTdwPL?yAGFXRkZFyZ@l;de<&F>_2zi;iHu4c5eP*^W0SOY`!j`dd}hQ
z3%`9h>D)ID7Z~4NyTVwub~<H$W<0d^x5oWzJpp6>C7uV?c0K#;!=2AgJG?k{?%Jn}
z*zll$IsXpN?6tkmPB<KYw(xL|vsWMXp1nrxc26Yk$$HQAYcKK4e=+XtHx73>JMr+}
zjR)7J_kXhcdUNWFb3LVNON<3;Pnk>CzU*1Dwy$x=Pdj_=da=n|^y2GA*YF>^-MV&$
zx$woijO6e(PfU1<Ipf85Jom1>l6*PFv==uUox^dSl<*HdJ;HO$d)6NG^bOx&nBhrg
zk8p+AB|OyIlk~Xo)8^GL2AQjqST9qJK%)=YY=}AQ#eL@OYyF)Tzu?2Sq?B*S;9=2$
z&&+!v<D?gwZ-2+&na)==IeK4fuAZFGTmV0C^t=}RULR}C*V>;#o9Jc+Md<HC=0huO
z@?Er<MjCskQKI)mo;CLZ*Z}t8*~f1!>rb&K{{_`kf4vd<HfzKe+&S!?2ZrmPc*tGA
zAHSj~hu=|YM(uXN_6c%S+S#J=o<@9^5oddpZ)<58?ewF4{xqw9<PWDkP*g+yiV+X=
zsJU?d+P3^>Bl*v^<=32+UG7<Q)w&zAWkPSuPqcQAzp@6ucj>O`cwY998R8tudOyo=
z0NJIAIZ6J?vr&3*mHCuBMoY^m1D&PbHxDuo;yh&8lW0#<|3!;sr}!ReT3fXrcWlE_
z)37^4UzExoUu(3=Z<$~oBu}rE)KTrdjXQ|^tUI<|E!f>?mMwlquoPbaMw^$}{yk?p
zuroY|O{;X!v|-suX|1?|wue(+>R|8NpLyfMsl=ydtpUE?;a`zf)zujF%Na)HC~K|h
z9UeRQ%C}$PJ2YZ_{{w6PEtKyIUHzHgZ}2CZAeDcHeDA~>J#QUk^eo06r;Iz5x0FaO
zz?X!6UqyP|Ap8C2JePGbMq^)RrJJOW=bLZxQtXuA!`Q(sm)!^Qeg?6PLhK8|tc$|)
z7S>RmlW}i%So)>u-k<c<zD_u=(_WOk$H=2SLLPe1LBRJd%Kb3{uf2};mOjCP*FXkO
z>)amJzAjkr=Q#~~MZr?Qn12~8>E0i=!m^xkcf&HBz57kfn^e}6>322_zX!YI74X{p
zCx%yIxBphj&&<kVY>da^%dg)n`2C9&w}H7zA5#0%Kh_@3I8W?k%wExb8LS!Ld|}3Y
zL*Cwu4qLeXHFTso{!43*DLuIC6;s~{(0|z_o?)GnU7}-?=*04Wjd|qon0E8Y+pBdx
zeMXGR5@a!Sg)h75S3E;>Fq1KIe`g=C-s$tMqSijYm7kETK0jBImTL9+4E<D}&#Axs
zS+u><rfn{{!hW(dw%|VO%={tIHTpA)uBB7c*@kp%Iu~3)dwTaXW?HK&pog*aI|usG
zIk3|1C69Cp3tI7$Y~e>~XZWUd93z<<w<5dS^qLqx&3EWz^ls=%G?)kdD-MG0pnD$~
zt(ZH;4fbB5k(ACx&uVD4qr48CRzV9IPwj)8`KY;QK(9@wTNu|q=$|;V;Cv#Jv3-)U
zJ%~)xS|@xvy8X|tFAOzXV_U%3M(#0O*=EOV<5aPjJ6SkX-+m(;FkjSX1G`&`7O>-X
z(}H~uU|SiBuB7L`KpCwM@$3&CWz7=r5x#Vu?5qVd7zY~`JO1Ih3GhH*5f2y#Jhjwq
z-^FLN!l63l>!v(YDX(|UBjdMbyi>2_%J}i<cxX%Yi-sM2HS6c2zU8(aepOLyyl0?%
z;k4(+M)cz4)qjSrm#-+?8eHM4T)DbntLBXM1k*inTT9~nTbHkxymjU3Nn59Ty7JzI
z_iK5d!h3h#yKVJgAH96V^;^I9$aQ>+-#W8<kFB2PSB{$z*K_NPxL#Y=ctn?}S&~N`
zACb1X*8Z+wTRygZ;-x2ce2I3V$0>*Yv^V0;uPk50cMKZ==0IweEkC!#0e8l*YQ##;
z_|N}tje*ymV<(wo)}0W{EwyjkacSLXYaja04qELCH;MK>wx_LAdo9)&k*@PR(j6Y}
z8*Hbwl}XL=jkdqlqf?Sh@1$vcaQdTf(q~%VsGoSVR%{3Rj88bcCUg=yw`kSdM&EWn
zJ5Ce5s9ze>_;i~_oNu%<)%oVojdM0-j|F#uIelSok!o@-cKOO)%$M_g^z8B%wr!O@
zLA*-)&bO})Y!}`b*J+BGQiK0r26vz;j)83WcX@pKW3Vd{J}kdLctx4cmCE{5PGk;@
z4g{LAhZ~hQf6?+X-?``flFG01-Flufrt(UjMJqZp2xwl#8ZVd32;{ttZ+=ZL<e3t!
zy|zED?(M8bcRU1t<sf-vzZaeEMc*}u^wR%AcTRdPI&ti8vgHS(JLtIQbA9lRK+db;
zC+NtQdJWxUKTY+hth=qA<YoPRsf7H|?GW$3*-tt=Fq}pk(hvOyb?QAtObf*<=zEJ9
zN*Qc~j(L(Q{5?gxUv0N&`-ex}r9Q!^47_JvRy5qZxE{P0J>cP9b<I7Vi;X4nf6g<E
z=0J+^Yd<=+T==oUcqO5?Dg=H%u@3niW#POyrSf~gx+*`=RDQYqq<s~B;u8wqhxne-
zlUOwOU(|~_7EZ@@Cpi&$8{M?dJB}eM*A5aMldLn=XVicApw@u>=;eyDj2*|>Tj)-d
z0Cvk$D5G-^)`v>x97H<euIQfT4KR92m$&SF<3t0xyf@O{*r0RUvJsP)KD~TX-_*{W
zC7WHcN{1OcmeUv2q4WS}BE|cRoO%!UV;?gYGCtEL12=tp)OfCc<+VIJFn$mC+<DW{
zLpo^>lBP9R<F<IWk#mZ@x>e_RbKzF%Of57QegIvh=Fx`qn7o_(s=vxBd<dS>8AeVc
zYhG#}bK$khKfqjArQZ?eLdjO=<-fzokq$ZaT61AQ>nnYbeq-@}*)Y7TG{0&20xUjY
zf0Nzt;zRcH?|D|8&YExA6s3l}5qOBDGPz{7krSM6<Zza3-I*kK_fpQsJ!G1vI{(&q
z6Tf|b@aG2WPut$kTGQaK4qrwtdNh?a%uH^Ti=N9j49P{0mJ|=Q<f51H6_;G}OMY+V
zPdv+6@0{P<uEq%Vlbns0O|{mP2h4?f*P39xm)rJ_PI`u6-kAEJF{1Wsw(XGW%w1$G
z#AkO}?gPfc5A?ejyKDHl-UHw|fw9c>QATORwg~8#GQ0To)q1hNi1<0umh$J8A*%v|
zFA&q3=1XgP&b^DXPnAXY=DRk%!YS`F+Vc2{+n%HOvV*(yZmqa`H2-Y2jl0{kEZp4@
z!CjEwE)m?h`zigq`k5B#rvcnOBmJyW8vRVuFa4a(ujc{$H`wRq(#M_pP9HbZM^Cx^
z-SfRjI(_qzuD*G0NpDgaPgx|-nn<3AeB!J#PJcGXw)W?_{ESZR`g3`tKco2lJ^uF^
zw~Syv;;@*OkDJ=D*0k4!&#7nIzxQf;uPW62yZ9_e=)-~~N(QMe%#m!QvkA?$;16tG
zG#mX}m%5lr$@+6w7|qzCRL)7qC*VQ$B;au_bdb9QoFcF0-fPp{+=n=WWR6VX-WloZ
zgHr?8Q7K-InPs}x{TajZSf7n>32n^$xxZ4j+*&h!$J!-Xz6_jpB**ys<TaQ609c@Z
z-vFL}?#~IX#*U2nsCKlzJ90;GOJR;-8tjA4mxnCefgAN%dt&*D<)#_P`^MHZ!`v!-
z8s$63Gmpl5jHz3F#Pu`R>>Qs#o`IyN$CQnCaBeX6%ezGUZGTpnqwh8i+viA<E8Kn8
zSh&wQ?7Y9S;?lV9Vr}vEJE*d$)&3mTC<}j<3>%RJ13iqFR(S$zXaAfrMpp3~{{0Pm
zOw0bHcC;Bkiu3V0_5}5p#f3h*&1l{V9YN!x>L;+iBCj7IuPyt^c0M)hLt+=zb~VO`
zPt|scjem;#(9Waqmq&fmxyNW$zU5EpTTWa*_S;8fKio++fC&vjXduone-h5Ec}@gI
z)l=n-jVDO+`jhx~76T)4edSSW?bDt<HESE^tws#{OW>5e=J`$8RD6ZjD{mcnwO4qb
zG}(QAkFmXvy<Qn|QvDcPZmeDT+i}Y-F`I*Z&F1<S13OADGMoLyRa1il&F0dno*ngH
zn;0ryT{eE%<>VR0w{LiM41=Bp+s-dK#m`h9BedflqhjEd+{U?$75^uRI1IJeA}NpU
zYmgd_VP9xaz8YEX6%Tf?Iq*^DPdV@YOIJ+w-|!!IgQq#BzM*Hg^yOvtH}M$JTsg9t
z1zVD7+50Z)1)O1jPO+!g*5XIX#%o=bE;+cxp94K$D>)$&t4H=$ziIW=5Iu9QnRPfW
zLWj^~8y#NQ&b`Gu>R>%G5Vp#etg5}XbXQLf@*I@St;Wc<gU2U}u|hZUa&1YU*0FjN
z{A?!w7V^K(cg<nxYcy6}8LKMJ!|Ed6C7U+!{41}GQ^qp8de5z6Gx!ZY#5on`NwS68
zqP4`I_D3IQMtawNxOPxa+Uy<n<d;o7&GT&9EzOUq3?A`T>WsVoYi208#apSn)Kf}0
zpBorcS>M}ee!xSX-QLQRPkO9a6UpE+4SAk^gUc_s`}RpDyYto;GM4))jv<r!&V74b
zT50fXL63g$+@5FeC-zs$1jcWrc>-P9G@m!HqlWoa+PPn^T=;YzJW^+~Q;>HU>&wJz
z(qz}fneHxZCRD#sdhgi};FHx)-a2*}J_XaIM}((#Q{0PH#zLJj?$q;gJ@*e6^Lz}S
z9oF=P2G7#nwU&j>gn!}5j`NZdeimFyet(-bQWH6wCeC$gAKJ&y%aHs-evOO9>;dd~
z3?p!^hP=zTQNn~qqwB*?Vtwt?p5|T3v(h+GfPX`Do=Wm8yPtjo&$9cF5x|4qwYJo5
z@-)9d*<<KVQdu)<8EeaqkUp33oVw6hSPm{ryZb7}u)h34?JNUsV4*$Bx1;tK9{JQK
zFT2M$QA6Iq{Z}^qJMXm{J<S{S%UJ(}-|CgOj;%fFYo(hS&ba=ESPS*g;P#cq!K6B0
z<xb)?8Q!w-+!eW<b$nDE`JW_BeG(48LtlVvOeT1)!gi?^dj37Uq4r71?>0UDH+8z}
z5e?Ll?yhGF^#n}cnCcgA9eaX(z$esgtv&SX-E?#)k@}669@)zC@s(FME06LzYg7w!
zTzRF_+{CYVgTCqc6z39k%nR{z&5={W5pbn353d3j+AmMw*O5JT?LOt`Bp=Nmo?^=$
z1tTn3s<-$ra%dvI+o{7TlfKJUCQAN_jg;~6`?Raf^4D6+oG0TnlTYoO;rFNf+3Vn!
z@T!%44^FDG?x(3NWL+FGJTLT_S1~?4VcEM7d%t3PF+2m_{`kF3@zuW=7xJ+;$|SB(
z^|tY$ne2gze_)0R$X9A~-5;*?RaXB3`xlQ{>4z44)0xWyy`j>ueUJAO@R3b>xW{)q
zy4|CkbDRAu{Ij^PjCC&8?1Q~l|E8Z^5jee*IW1co-DMTW{-K)hMZboQx$C>aFycR0
zI(zXP>^+N3{45x+J?y!Q(VcGgn%Kql5swWQKp&@>r~9$tQ=Tf)>PQ=mU0v9Fdy{m(
zd+CerIow3swO3O&ZOLW}Tl30!*pF<*UaOk(rY`IYQ_IW~Vc_uOW7|reu9VGXk9dqd
z;%aP)iboVKEo6VVZx}Ymra!CTL0`YJfkx)jQSEo4ebsejEN8C~IQCg^_$@ffuCd{e
zEt}*+8;*UgaCGf$R20!J={>tqPBvJ=+g4!sA$#OvY@7BCE8D?db;Fy?vw7V4S7z=U
zueEYjPa~&lN!2*+)CjNQJtYdZzk)NtwtED+64u`bqSD{d-0fxT_-^ETd1FCN4Q-SX
zFVUb4t*hmYzMM4f43dvl`M|v9Oym|{r@*0d<cC7+tTK8U2g|#An`cGpII}0^;4&|E
za@db6{;T+>WES7|jHcfbQ|Eqcv~P`q<E03kTZrrL10R0+y%#uU(^tV^$p!Q^KwpL9
z<G_V2VLLi_k~+>n9}Zn?;$7=bK6P?gY9{9?R(|OaG(HWi-OHepz!>Co=tSe=V|;A=
z!M+WS{$O%sTr@_<8JnlEjTHTsjhM7_HuSL{`oQiitMoyCzg4lujzN)jGCFa;bQWpE
zKrfDhb#WA|iz2Xk2CM)5D)utoao}Kex-n)>1P594ISw2YFL`xbY@`k0I5^C{!&Us)
zk`3wC9O0RBBjLIw(l&QUT7KQKRsFJY))-@NWR349QE*QJPSKMMr#()&+8+?FzZ5vr
zmeh`WJ*o@>npGzM;;$ZCYn-uNKNMBRQ0gcHw@%&MtF@yXJCwU4`7(M27F)RPh7C>I
zx9!$9^h%n$w_>-ddG%^k-HFugrkkF;i*5$eCu?4(+hcNJntXL!h_OK*ET5enPe#>$
z4qdnE$>&alucB>qsXNw1mH#kOeg$_Dbi`k32mXJ<Ukd4??&4VmjOFx|Jx{y&x5t5#
zxB*|)PxXU2I5m#C{M6;l*%zpznl$8$3eB+_qT0Y9#2PD$r*X%DQx5;*_3n9t&0UA{
z#{YnS<7(O+8&&W62<%(%J9X2-BmZc<XZ;%oM(QkhF!rX~5(8@`lgvYQkzJyt7h+zE
zhBRL!_uBL2%s2zynnc-j?p&yWU-%yEXVI#3FHZmF3XYquY~>5;pZI}zqj-Y&WZ;%p
z$EkmlTzJ(wDO_tU-m<%8T9G%g;pm>0X}z#9mE1FnHZr(_*V1Wz%U|g$&1>H5Lsz*g
zrt+Kaw4J>xwI@{GV%;SfKiJB<E0TALJFU2nod&N|Jy*HwxqX0@wmec!`uW!O*Th?C
z)8p)NW87&wds%69kvfOF+bbAvrKS7ra*{(^>%1Y>N)sG)w5c&_OG~co=dNe?xJt>G
zN}o<2(^L9cWsk6i8I=DKdw=QuTFd_`&9c4HyM>b<r?$40PFwQ3YE2tHvNg@L;3%8=
zb?Q^PaIX4SNVmXV@-^1ZuiAI9r};!O+~#?whAW;I=jM;*8%AXba7$NOhRisd`t&=O
z-yZxqWz4x3F7xe3nIe8Yt}@eSU%1Q-kun4oSbq{-x6{t9;DyUfh?KdCUv%5H?hgHd
z_B$W2$I0+CWwQsg^s3CG5z<Kx1)ti}Y0sqnpT6mR7kkG7bgr_I&5SAAVIaF|U(a4<
zl<M0>zJjXr)3tXDs4n)6oB1t3*BV_%!Oru`WpI{Thn%4pU9vws#adi|E;qWY_GvZr
zrJ$?stZENiwElKvWIWT0?7hGY#!>oPYdj<RTYML+y+9Mc8~KZ_qZIr}Pm#-h`Wg6+
z_)HqO$z?B%{4p&TKC~JBRto&=(VL=usC1s3%l=n*RsV9?1EUL@mOB95HFo~Rlsig)
z-Q~8^cjx=d=rY(FH@nj{4$ySFGWr&zE{%<J?Cr)BeVMgy2ZjL}Z)l)OV+0LUDKBN}
zG**nK0Zyaa(wOcPU1&_nuQBZ?pXjBd?;5iVaOUe7SgUdCD355O!|%{QN8g>X&AY)h
zwx5l%$F|1S%`c0L?Q(uE=Fcg!`8rpbD0;X%Qf3jq$^6;$&|YsH>}vEHDg7v8f35I0
z*jOk#4%y__$`=1p^l{LHWs}dD)o+D!=%y<;W?tI1_{bf#&_<ng4ygDTF=6PMdl0NR
zxmo2G8NGbixvSiz)H%c+w}rLXny6iqyO87uYj9o&ziSTSGvMUkD!%~bhh~cf7w|3T
z?j!BxkPp@#qg(@j%kVu9K!c8)u6>jvr)xi_bH0w`bk+jS`7AkogCSogSKDu>J>VM(
z4C%oAy>7Z2CZ^(I;IZJvrav0qOQ9`ddL~=x*!Q284&D@>#!fFgKb<i+>ZD&)b{;;~
zVDD0n9g}d0Zep5Y^sd-rj2+XFeqM8}qwfyw>>AgqS7^63NS~k>#`=AqU*zcZ!hfyi
z4f9_%V@@5LuW;3I*F`qXjv8g@Kn_Lf_#MCZsSfyz$^3Q7?i$;^>`I;E-PPGDyC+ii
zxBLeAbIPQTX<x?Te+fxenO7oZ6!ZEvSDEFb+n2H0`CT`wOej+3X@0MBm8l!qzKqq*
z6S-EICn9Bj%5R>lOy1=eF7v}k84iNhkK!+yH_I;ueP=^}F_rIZJ^Xbtd(L8X68jln
z<lysoSrPenLYqT6?aZ0o$LMABj|*q9mwft*mTaZfqT3wekED$yjlIwQb9S1cv~H2K
zX{6zk+i=!SOJjV8^o*q4MH>5~E|IhV<2NKRlD394?)MsU#xAG%Iiyb{t(r9U%ac#r
zX=TvPkO7gj-;l-`*qmlNP5gUEdL*ruw82JYMU$Pjlld^2bM|G4sdt;yk;Q#f4dBB#
z+a-J<oJf|2Uf#0gpTYK+uwK5EzjL7I^R1HYU$e$BD>5cS`F#_;ty9LlxPvmk8*Y^u
z5GjN0+4|j-vB&XC^lf{(ayB4;#?+>&LB>JzMgv<s-5KKvFT(~fyt1fC{w&kj&*%(j
zHwM)8gN(|1(YJpWUHp9mV=5OP@mBT&UrRhOmR{~pe?Aqj^F+xE!5<n;s>3Rao}vK0
zCqJD+a5kiyapSV9JPYf;ZcJN)4(;0e=PX`>4{=#UhnBI+xbYKsjrIWYr5m!#yzzB-
z>W8f1uK`OHy0>ScLHScj@9`$I_%VJ?$KjLR;inIy_mD5(CiEU3Aa{R=-GtiSIbzDv
zXV69Ej`l2MZ#pe^yl3GDj9qRHu&^dnK_~iFkKbN^=ZolzV95QoX@5h%p1VWOiQ!uA
zjLdym&q?7jo-^{y8-v$nR7iJj=Sc~tsST?vdVa=U?J9pU&yulo^Yq>)Tq_x;P|wNX
zGM<;QmIp_1R(stLOa3av4qg6LPe*W4&@<3f2rY89Y42khKk2G^M#jz2CpMr@Tn4^&
z4zt%EN1te~Kej$m>(7vgp2*Q5N>3C9UuEbKOTkwv=jIPz43Cvf!6p21)~<MkJHKXs
zI}W~zdCrdLcIw%8l%m6ldsyS|Z#ag10`}|{tmmcu+oryM>mY4%x4j!mL;j8Lc93S(
ziT~6eB54IZ%N7^HLmrI0&-u5aCg)p-e(Y~(c?nzn3emuA5geWe$Cyohe-kO+UeA`$
zP)whl^;`7jtlwX%XS48Uuix_REM-27>!5A)+N*zlp*}vosqdz?K5j3B-%acwFLmsD
zEb=`F-V5Gqd4;vu!goQZvK;LVMaN3(8-YP{UNrMP?%Xa0w!}8tvf9aNEg#4!gm+&O
zdB2}>acy}myh{#p>bK^;*Jw5)d5XR7j#InED>w0*+H{8fyYjm6U&vT%KX26m&o~ju
zQ@rxsaRz=QD*IvNTLHRB!4vG^+po4XzVAoU)K0xOBOIiCVgQ}r4mxz%L7mtB;Jq8P
z*FWz&b1paXy?{1FKWd{87_=wp%9@yqyknsM&|YOTcY^}c61Bf8(!PV|Eby$dKKQB9
zcXR|_=H3m196VTg#Ya<{p6w_vckHHg4D<e89e>w-hOOg743qtW<M9saw&oZ9Pv``j
z&%kpZiR96oDqtS@m}|mCdE~p(#}k|(i&uOIe-p153J(>p5Wg(u4oQ6zZ#8&M0~YP~
z%2?BL)7j5*hwQ)eEfw1&<*DV)NNh!T?h`K4GxdshrtvKOlJbe~R7v(D-*NH<^i00v
z<g11E3J<B+_Nb0x?uksr-bXyv(6j88bWR%|SR3R#@+SJCysF0#{Nz1O-YWR9m6tJ&
zBk%0)aol6AarEQ&=Bv1xa*TP7a5>R_-l69_p6_K0WsBajr|VbhMVvLh?!C{gvpZ`a
zZR<tea%{*h=DbF-?<M^1Mc3<;$vb-CGRcuLefZVcyi;a#-G$4<Map#Lcblt>S=(CX
zt;in#t&+$dAAcPSwibT3@Ta-tw3YW)SGnI^X3OHkeU{wvairV{e%D8pTmC=im3yn?
zceXuUU8LMmet!^EZr7jAEB8rB)kRi&ha=@UU|p}X3<t*aKXy=NDCZyG`@bS(YWSVw
zDzp6et}^x>w-p~dB4u9XSLe)5J9TegxXd$=GCJ44k-x8$;W#rzX3LVyCVOPrv~Y$q
zYDV|G(EEeT$};S1{x-q3MV%NJT`?9tN3G8oGlTOm4>qq#FF|kn9(mu7<U{wcekU;u
z?!#_Ia%$OoG4ZksC_rv4<j=7c!uF+MAToDLtns{T=QJlB+o2iE`#9!E3-&_jBO`W1
zNe#Y;9g*T+Y~frr&Q)eN^VPODN@}$?Qa%r5k|Xv;X|*x&3xMVKz}`_Gbyr{u`}>{P
z#BtXi+Y07CeJK8GO#F1pbzFu!Whi41e^$1xOJpx})a3l%wpV%+{k8B^2ab+_qxVUZ
zzlLmJCO5S_9`Ip*xAMQnm2dG?DxSgT*t5UpLH|U$^yBpvfgP)4x8yaZ>fF(X{Zcu$
zOQ)Wk82S<RK%1~{D#vaqqtm9ok7L916Kt7kIuT1&XO^9emlsFIA@GM7e5uRE51}8o
zFb=o!mvLu)bK#tP%RlN#@OK;E?k&l09%&}-FaG?Y!w-BhVcn;|FPm=JfrviV@h+TH
z|2`)EHT-Ui89VVPoz<*L>R(ar>0Pm?#6!KF=34L0@hP_$mVaX4cQNtF-Hc|#Z=BOO
zXWZ#&?g}jGrw2Ss|J$;%?^p7<BKU%DcwmVSe`(RTd?3%=?+Fp)9p9iBe1ke+Ya7cQ
z1V&{c{<DeF6#%zrT=6wmz?;?9XZSTX3*X<o3Llw?*h}TN^K(=l>FZYG<D~P_7+~bS
zp%atpj7kIAn_>obY+~&eeNN%be~p<)%%-jlM@hRDzx-!S#c=B0FoX9}#y<|*us-1@
zrY2!`r`SFz>??lq$TN2j9c_d<QFr~<18ec$I*1+dLEo8{m&$2Zc&-_^eWRbYILDZS
zOfrpoN1Kbew^hFX@UF^q+Vz-bMP9lGdj@Ei*uC|v8<95G3cnedX6QG_Q#L<1|6W+d
zP@KShN%9d~*3~!>1V=?i?}lRLCpzu7=;J5p!@ZT#w~G$S;AxeNcRFwfWg`wAc0oTu
z?A7j#3*?l<62r5H(JXs@`Q{Oy&GHkFEk-%E+zDq|9)Il%@4_+<HkGWow%va+G^V=-
z60=mM3we4|f294l(uZb5+V^G2w^A_N1q}MVn_qiOJC5f{8a@r!4s0<(!iVhSPFb;y
z+uO;t(UTcEyTC)7elN7)qABJt^7M(I;i>qB@x2YpVvOhe_1yF)#nw?gpn=G9Cy5#H
zDRw7{?J55a(Vl2W>B{FpmnS*oG=K6VK-Z|a^dputj|wLQnhHkRHu!sqNdOPrA^!qo
zzfq<cx4(ruQfsgQ%QgBntl-zNL)y>XWX8Fcm+P_FdJ_AQx<QUVhy2p;9YY7Ac3vSS
zU^VGDQiP-P$S>nr(iPKt3$fw)8+|HLiQQVjb2WY*%ZSGt#J;JPy5*bj1IDKspN%Hk
zl#fR;J|1O^rRr_-@vz(fG4-MgdFe^=N4JYkzxh$pi>Y7or8763d3pLyY#J9h@#ETT
z=1<XXji>Ma`|dEUF<m;)2tCltXg(34^OlwJXNsY0C&n?Badi0&db#&5FsMRfB>#@1
zE7d36bK40TOkw<V&#Vz1#eTS|GxntTAO#tZ+M|J-lW!U!&YRYs;hXR%+a7e-CrY9J
zdt34jEAGru^3|1S40NYjO87-jU+y1E4nOcvpN+B;s%LK8M4yAi!bl}N%B_ReZFqHH
z`3A+66ED1d88Jbqr#Y$~)uHl7@d;EN`PAWVN8goa9N&+=8PMGvoYPoikfnM1=SFNa
zO=4$YU!<4`d!RY36MCM(vzr&ohw$@n+Wv#5@4Om3UImYw7y_@YehW4~aouHx&b^HJ
zMZAlJ*mqjCjBkJ!>6!z2M_#YuH-SD%5C5U$?GfyMly<3oR?M2$?v5GpU;}^k=<|+R
zc%k@?bR@_|&xu!>54Xxj&*k4W#MX)Zth*(HVWVTomv{1uer<iN{6Yp36Nh?Q%U7IN
z{<)H>G^_m0k@DZ<S3aQDI^;8YrhebF&brk8vFlF7XWUY~Jq@{DaC0{LmT_@c%hvW?
z)-6xhyiiO+ekiv8gplvziJ`cmSB1Kcx;oT-+%=(IQwl=~(<X(IZl4@VnK>oYckZ>J
z{)?^)T~vl0P|S_<JYA>Gi%Ga?UTptq^L!WIJTGqOH|BL6_04(R$9-#F{KQ-4^_p_)
zyo71D%}cud_IW8Yzdf(--0#fmzo=;5MMmDa)R??;@ein;Kq%E?RN`lPNPgcp7{<#N
z-Ph%9!7BKS7$fBAY67DN7`?z41B{)3F%}p*hvFytfYT40alqLHIJ*L8H{k3Zx@a+b
zW-q>*4;alCm9fsp^aSQ!z}y>{6M#7pn3I4x8JJUmxeqY+1?GOh+#i?+0P{t_oC?e)
zFq`KL;1q1pbjE(|gdL00j`PVL>*e5k#IwO}-7s?BISmhprWesw&T%^q;sNrqc0D(c
zKg%y5gFA?d^O~O~UE}(m!$YvMJ9obsI*G0DXV-i2l{Kt;jr`Ol7^)*NG4TyJF{+IC
zF7UEiaNyX@vX^Oo8d|AkJr<0)v<v-PFv<@?<&TMfA`9yrR_oG9Y+o(^Ab8Yk$T#Z0
zV2_KyzKJ^A<?5KX9ra}~`TIxc^bOiF`1i^EuZ4!w=bkI_n&UlPE7S0g72P_2R@x6p
z8)&Cl@2h#wcfCKt`wZ9nTHaT<-hagV7T5a*-gmp+f6Dt2*ZUUUJ>4u=toDA+`#{%w
znD>0w`?I{yaJ|34`wG|lE4*)Uz5fUAyIt@9$@>x4`)=Mn-P_v#FWv{b-uLmI?|MJL
z`wZ9nA>LQG-rwPUi|hSQyzh3s|CRS6uJ<FndwR6B|2N(Ty55iTp6`19i1!(;_eS1V
zxZXeKeT(b;H1E4z?_cnK#P#mUr~UZ0_G5V;=z5RiJ>T`-o%b28_g=iOaJ?t-zQy(4
zm-pSS_ltNx;(8y*yQgPc`<L)O(Dk0hd%o*^81FM&@0atw!u6ib`xg6MH2<%E|94}+
z{J$H#e?j*z4EzfN|H8nRV!+{HOW3^WpYy&l>b)fDePQIC*f`d|ipV?X#@0XdIo7{3
zEiHtoX{(pBU+Z5z3Q+xX@(oY4-~INF!TFB$k2}Pz@^z7SOBm!iCC&a2Y1SBvqC)@h
z9kTv?@`BwH_G{KZr(MqIt$zyCtbbkXpVs!!XIcNoMgWU|$>zfTe)0<&o|H&Ban!AU
z!=JO;!#36W=fK}L@}3q+N3OO0#YcWQ>$m#1I0E1ok@r7D-diH?PCp~X{`KSF?+zR9
zpZx3B!pQ$AJp6A7&Y^E-e*dH8^XAXIdqL^Uw2Tp>#%7Pa{PK}Q(}vu2=K}tpv0&~Z
ze&#OH%e=YzHe>odvu36(n4fm{=&_@6Mva}3nN~7)`usc7zB}vgdrJ9!`Q^ig4;zt|
z5nQzBu6wSy?6T>0?ZfU|u;9+Qv+h}N@7*P{hLtRsciEx^3+9#tr<cyZZ0_9e&b#!k
zyBEx!RkA4U@|oGAXN?*$eC+U%BS(%MJ}di<Sz~7nA3I~j9V5nGo?SBY@)>u`7+#W-
zgT-PS;MpTajv6z3v;+91Zon@+5AZRgMvNX?avtC#0DSmA4|vWUW5--Rdi02yBTKT!
zj+i+-`;M6-hmV{wGW(7Z*|TPjF1dWns4*i)&zg~WVYt5n;s1ZbJ*9O1oLP5Ykv3(@
z#I(yJ*t+Z+3+CQCZ`M7RMF!)t8TXdXojGH{qRZ~NyW}!^(C?Z%Yw@KKI<N=(?$K6X
zF1>r!+*uIRWee_I)Q$?Qm$ZKzqsFlL3l_~9=FnQ{%vtjnMZVoR|K4F1OqZ6<G=|Mw
zGXI_>^NeBo8ll*BFGY9Tufgf}1nu05_yU;IRW$N+*IX*Uv!tYG*5Z;`cP%PfG=0Y0
zS)?tPIepP|W7w=<(H(bBpEs*0IFqu@n=x$Bti_9rqN2Gaix(Fypz*r_(->w|rh;mP
zI*eg=l+G_Lntu1))0Y^-c>I4FIYZwlq96`GSwT_^maM3#YzP8F(vXS@5>62mP-w!P
zXm4|O3HAhnKLA0%A^=^5p%Q^WR-S;Q5>Z#fZ+7N8-kT<b5j*>4=G&RKd$&7#w|5KH
zRlvc~<hfE$E&p`ktgzYiNq=y7I5~cynui*m&F975Wk<t~n2+a+nX3HXGs3^)?Cfus
zO0JK0Vg>y+;n60nt=4wb{Ey(#TkA+)$^5p=)<ck=z5=}rz;alvoDb;_^tn;7Ydk!C
z0Q#x?CiFGLq3_CPJp*I<2K27M66Toezb~IY&s+2KHR#S@3Hhntt))B+ANlE<(DY5j
z`_-CJDUY>kHNn#tqUj5Be)iuu_<ONQ`a*Qw7wY#~SN8u*HmiyJqb=VM`rD?DS?2xs
zN)F?1m2L>>ZV#%U-_Q`cS&vJ#qGv#x{3j3GkG^IHu9BSpoqTour*=Rj=-0Y5)sm0j
z2RV(WFCHyD8vW>(k6GsWKg&_`AN6I033|_mgUuGX{x7lx-<khP|H6SWrzGe9Dx2}V
zK31PR;cDV~mx&oH$@Bj%n;l|!`t+`MKIhB)nOM6Ag6BS9CwN|`3K=BxKV`KN;rHV{
zVL$j&FJpNB+6LgMOV5@z^WTX3o{gD<=LS^*k4eveG(7iBzk^>!e&REKDTmppzdv!H
zU%1x)s5Fu`SM+^WlfS=c`Ef)4oj>O53a|68f<KG=qm-Zh27e>+?_dZGuiwWu;?;T0
V=C~;XbFTy6zx2p$fN-W^`2*{Un3Dhi

literal 0
HcmV?d00001

diff --git a/frame/openxr-compat/tests/compat_tests.cpp b/frame/openxr-compat/tests/compat_tests.cpp
new file mode 100644
index 0000000..addf345
--- /dev/null
+++ b/frame/openxr-compat/tests/compat_tests.cpp
@@ -0,0 +1,70 @@
+#include "compat_logic.h"
+#include <cstdlib>
+#include <iostream>
+#include <type_traits>
+#define CHECK(expr) do { if (!(expr)) { std::cerr << __LINE__ << ": " #expr "\n"; std::exit(1); } } while (false)
+namespace {
+void* sentinel = reinterpret_cast<void*>(0x1234);
+XrResult XRAPI_CALL fakeLocate(XrSession, const XrSpacesLocateInfo* in, XrSpaceLocations* out) {
+    CHECK(in->type == XR_TYPE_SPACES_LOCATE_INFO_KHR);
+    CHECK(out->type == XR_TYPE_SPACE_LOCATIONS_KHR);
+    CHECK(in->next == sentinel);
+    auto* velocities = static_cast<XrSpaceVelocitiesKHR*>(out->next);
+    CHECK(velocities->type == XR_TYPE_SPACE_VELOCITIES_KHR);
+    CHECK(velocities->next == sentinel);
+    CHECK(in->spaceCount == 1 && in->time == 123);
+    out->locations[0].pose.position.x = 42;
+    velocities->velocities[0].linearVelocity.y = 7;
+    return XR_SUCCESS;
+}
+}
+int main() {
+    using namespace frame;
+    CHECK(!downgrade(XR_MAKE_VERSION(1, 0, 99)));
+    CHECK(runtimeVersion(XR_MAKE_VERSION(1, 0, 42)) == XR_MAKE_VERSION(1, 0, 42));
+    CHECK(runtimeVersion(XR_MAKE_VERSION(1, 1, 0)) == XR_API_VERSION_1_0);
+    CHECK(runtimeVersion(XR_MAKE_VERSION(1, 1, 999)) == XR_API_VERSION_1_0);
+    CHECK(runtimeVersion(XR_MAKE_VERSION(2, 0, 0)) == XR_API_VERSION_1_0);
+    Names available{"XR_KHR_locate_spaces", "XR_EXT_palm_pose", "XR_EXT_hand_interaction", "XR_VARJO_quad_views"};
+    Names requested{stubs[0], stubs[1], "XR_MISSING_test", "XR_EXT_palm_pose"};
+    auto p = extensions(requested, available, true);
+    CHECK(p.stubbed.size() == 2 && p.missing == Names{"XR_MISSING_test"});
+    CHECK(has(p.downstream, "XR_MISSING_test"));
+    CHECK(has(p.downstream, "XR_KHR_locate_spaces") && has(p.downstream, "XR_VARJO_quad_views"));
+    CHECK(!has(p.downstream, "XR_EXT_hand_interaction"));
+    CHECK(!has(p.downstream, "XR_EXT_local_floor"));
+    CHECK(std::count(p.downstream.begin(), p.downstream.end(), "XR_EXT_palm_pose") == 1);
+    available.push_back(stubs[0]);
+    CHECK(extensions(requested, available, true).stubbed == Names{stubs[1]});
+    CHECK(extensions({}, available, false).downstream.empty());
+    CHECK(rewritePath("/user/hand/left/input/grip_surface/pose", true) == "/user/hand/left/input/palm_ext/pose");
+    CHECK(rewritePath("/user/hand/right/input/grip_surface/pose", true) == "/user/hand/right/input/palm_ext/pose");
+    CHECK(rewritePath("/user/hand/left/input/grip_surface/pose", false) == "/user/hand/left/input/grip_surface/pose");
+    CHECK(rewritePath("/user/hand/left/input/grip_surface/pose/extra", true) == "/user/hand/left/input/grip_surface/pose/extra");
+    CHECK(rewritePath("/user/hand/left/input/grip/pose", true) == "/user/hand/left/input/grip/pose");
+    CHECK(dropProfile("/interaction_profiles/meta/touch_pro_controller", {}));
+    CHECK(dropProfile("/interaction_profiles/meta/touch_controller_quest_2", {}));
+    CHECK(dropProfile("/interaction_profiles/hp/mixed_reality_controller", {}));
+    CHECK(!dropProfile("/interaction_profiles/hp/mixed_reality_controller", {"XR_EXT_hp_mixed_reality_controller"}));
+    CHECK(!dropProfile("/interaction_profiles/oculus/touch_controller", {}));
+    CHECK(!dropProfile("/interaction_profiles/khr/simple_controller", {}));
+    CHECK(!dropProfile("/interaction_profiles/valve/frame_controller", {}));
+    CHECK(!dropProfile("/interaction_profiles/ext/hand_interaction_ext", {}));
+    CHECK(extensionType(XR_TYPE_SPACES_LOCATE_INFO) == XR_TYPE_SPACES_LOCATE_INFO_KHR);
+    CHECK(extensionType(XR_TYPE_SPACE_LOCATIONS) == XR_TYPE_SPACE_LOCATIONS_KHR);
+    CHECK(extensionType(XR_TYPE_SPACE_VELOCITIES) == XR_TYPE_SPACE_VELOCITIES_KHR);
+    CHECK(extensionType(XR_TYPE_INSTANCE_CREATE_INFO) == XR_TYPE_INSTANCE_CREATE_INFO);
+    static_assert(std::is_same_v<XrSpaceVelocities, XrSpaceVelocitiesKHR>);
+    XrSpace space{};
+    XrSpaceLocationData data{};
+    XrSpaceVelocityData velocity{};
+    XrSpaceVelocities velocities{XR_TYPE_SPACE_VELOCITIES, sentinel, 1, &velocity};
+    XrSpaceLocations locations{XR_TYPE_SPACE_LOCATIONS, &velocities, 1, &data};
+    XrSpacesLocateInfo info{XR_TYPE_SPACES_LOCATE_INFO, sentinel, XR_NULL_HANDLE, 123, 1, &space};
+    CHECK(locate(fakeLocate, XR_NULL_HANDLE, &info, &locations) == XR_SUCCESS);
+    CHECK(data.pose.position.x == 42 && velocity.linearVelocity.y == 7);
+    CHECK(info.next == sentinel && locations.next == &velocities && velocities.next == sentinel);
+    CHECK(info.type == XR_TYPE_SPACES_LOCATE_INFO && locations.type == XR_TYPE_SPACE_LOCATIONS && velocities.type == XR_TYPE_SPACE_VELOCITIES);
+    CHECK(locate(fakeLocate, XR_NULL_HANDLE, nullptr, &locations) == XR_ERROR_VALIDATION_FAILURE);
+    std::cout << "All version, extension, path/profile and locate-chain checks passed\n";
+}
diff --git a/frame/openxr-compat/tests/dispatch_tests.cpp b/frame/openxr-compat/tests/dispatch_tests.cpp
new file mode 100644
index 0000000..97aa48b
--- /dev/null
+++ b/frame/openxr-compat/tests/dispatch_tests.cpp
@@ -0,0 +1,134 @@
+// Compile the actual layer with host-only JNI/logging shims, and a fake next
+// layer. This exercises ABI routing without a runtime or a headset.
+#include "../layer.cpp"
+#include <cstdlib>
+#include <iostream>
+#define CHECK(expr) do { if (!(expr)) { std::cerr << __LINE__ << ": " #expr "\n"; std::exit(1); } } while (false)
+namespace {
+uintptr_t serial = 100;
+frame::Names seenExtensions;
+XrVersion seenVersion{};
+XrApiLayerNextInfo* seenNext{};
+int suggestionCalls{}, locateCalls{}, realThreadCalls{};
+bool nativeThread{};
+std::unordered_map<XrPath, std::string> paths;
+XrResult XRAPI_CALL fakeEnumerate(const char*, uint32_t capacity, uint32_t* count, XrExtensionProperties* out) {
+    const char* extensions[] = {"XR_KHR_locate_spaces", "XR_EXT_palm_pose", frame::stubs[0]};
+    *count = nativeThread ? 3 : 2;
+    if (!capacity) return XR_SUCCESS;
+    if (capacity < *count) return XR_ERROR_SIZE_INSUFFICIENT;
+    for (uint32_t j = 0; j < *count; ++j) { std::strcpy(out[j].extensionName, extensions[j]); out[j].extensionVersion = 1; }
+    return XR_SUCCESS;
+}
+XrResult XRAPI_CALL fakeCreate(const XrInstanceCreateInfo* in, const XrApiLayerCreateInfo* layer, XrInstance* i) {
+    seenVersion = in->applicationInfo.apiVersion; seenNext = layer->nextInfo;
+    seenExtensions.clear();
+    for (uint32_t j = 0; j < in->enabledExtensionCount; ++j) seenExtensions.emplace_back(in->enabledExtensionNames[j]);
+    if (frame::has(seenExtensions, "XR_MISSING_test")) return XR_ERROR_EXTENSION_NOT_PRESENT;
+    *i = reinterpret_cast<XrInstance>(++serial); return XR_SUCCESS;
+}
+XrResult XRAPI_CALL fakeDestroy(XrInstance) { return XR_SUCCESS; }
+XrResult XRAPI_CALL fakeCreateSession(XrInstance, const XrSessionCreateInfo*, XrSession* s) {
+    *s = reinterpret_cast<XrSession>(++serial); return XR_SUCCESS;
+}
+XrResult XRAPI_CALL fakeDestroySession(XrSession) { return XR_SUCCESS; }
+XrResult XRAPI_CALL fakeString(XrInstance, const char* text, XrPath* p) {
+    *p = ++serial; paths[*p] = text; return XR_SUCCESS;
+}
+XrResult XRAPI_CALL fakePath(XrInstance, XrPath p, uint32_t cap, uint32_t* count, char* out) {
+    if (!paths.count(p)) return XR_ERROR_PATH_INVALID;
+    *count = static_cast<uint32_t>(paths[p].size() + 1);
+    if (!cap) return XR_SUCCESS;
+    if (cap < *count) return XR_ERROR_SIZE_INSUFFICIENT;
+    std::strcpy(out, paths[p].c_str()); return XR_SUCCESS;
+}
+XrResult XRAPI_CALL fakeSuggest(XrInstance, const XrInteractionProfileSuggestedBinding* info) {
+    ++suggestionCalls;
+    if (info->countSuggestedBindings) CHECK(paths[info->suggestedBindings[0].binding] == "/user/hand/left/input/palm_ext/pose");
+    return XR_SUCCESS;
+}
+XrResult XRAPI_CALL fakeLocate(XrSession, const XrSpacesLocateInfo*, XrSpaceLocations*) { ++locateCalls; return XR_SUCCESS; }
+XrResult XRAPI_CALL fakeThread(XrSession, XrAndroidThreadTypeKHR, uint32_t) { ++realThreadCalls; return XR_TIMEOUT_EXPIRED; }
+XrResult XRAPI_CALL fakeProperties(XrInstance, XrInstanceProperties*) { return XR_SUCCESS; }
+XrResult XRAPI_CALL fakeGipa(XrInstance, const char* n, PFN_xrVoidFunction* out) {
+#define MAP(name, f) if (!std::strcmp(n, name)) { *out = reinterpret_cast<PFN_xrVoidFunction>(f); return XR_SUCCESS; }
+    MAP("xrEnumerateInstanceExtensionProperties", fakeEnumerate)
+    MAP("xrDestroyInstance", fakeDestroy)
+    MAP("xrCreateSession", fakeCreateSession) MAP("xrDestroySession", fakeDestroySession)
+    MAP("xrStringToPath", fakeString) MAP("xrPathToString", fakePath)
+    MAP("xrSuggestInteractionProfileBindings", fakeSuggest) MAP("xrLocateSpacesKHR", fakeLocate)
+    MAP("xrSetAndroidApplicationThreadKHR", fakeThread) MAP("xrGetInstanceProperties", fakeProperties)
+#undef MAP
+    *out = nullptr; return XR_ERROR_FUNCTION_UNSUPPORTED;
+}
+}
+int main() {
+    XrNegotiateLoaderInfo loader{XR_LOADER_INTERFACE_STRUCT_LOADER_INFO, 1, sizeof(XrNegotiateLoaderInfo), 1, 1,
+                                XR_MAKE_VERSION(1,0,0), XR_MAKE_VERSION(1,1023,4095)};
+    XrNegotiateApiLayerRequest request{};
+    request.structType = XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST; request.structVersion = 1; request.structSize = sizeof(request);
+    CHECK(xrNegotiateLoaderApiLayerInterface(&loader, frame::layerName, &request) == XR_SUCCESS);
+    CHECK(request.getInstanceProcAddr && request.createApiLayerInstance);
+    loader.maxApiVersion = XR_MAKE_VERSION(1,1,0);
+    CHECK(xrNegotiateLoaderApiLayerInterface(&loader, frame::layerName, &request) == XR_SUCCESS);
+    CHECK(request.layerApiVersion == loader.maxApiVersion);
+    loader.maxApiVersion = XR_MAKE_VERSION(1,0,99);
+    CHECK(xrNegotiateLoaderApiLayerInterface(&loader, frame::layerName, &request) == XR_ERROR_INITIALIZATION_FAILED);
+    loader.maxApiVersion = XR_MAKE_VERSION(1,1023,4095);
+    CHECK(xrNegotiateLoaderApiLayerInterface(&loader, "wrong", &request) == XR_ERROR_INITIALIZATION_FAILED);
+    XrApiLayerNextInfo tail{};
+    XrApiLayerNextInfo next{XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO, 1, sizeof(XrApiLayerNextInfo), {}, fakeGipa, fakeCreate, &tail};
+    XrApiLayerCreateInfo layer{XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO, 1, sizeof(XrApiLayerCreateInfo), nullptr, {}, &next};
+    XrInstanceCreateInfo info{XR_TYPE_INSTANCE_CREATE_INFO, nullptr, 0, {}, 0, nullptr, 2, frame::stubs};
+    info.applicationInfo.apiVersion = XR_MAKE_VERSION(1,1,999);
+    XrInstance a{}, b{};
+    CHECK(createLayer(&info, &layer, &a) == XR_SUCCESS);
+    CHECK(seenVersion == XR_API_VERSION_1_0 && info.applicationInfo.apiVersion == XR_MAKE_VERSION(1,1,999));
+    CHECK(seenNext == &tail && layer.nextInfo == &next);
+    CHECK(!frame::has(seenExtensions, frame::stubs[0]) && frame::has(seenExtensions, "XR_KHR_locate_spaces"));
+    XrSession sa{}, sb{};
+    CHECK(createSession(a, nullptr, &sa) == XR_SUCCESS);
+    CHECK(threadSettings(sa, XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR, 1) == XR_SUCCESS);
+    nativeThread = true;
+    CHECK(createLayer(&info, &layer, &b) == XR_SUCCESS);
+    CHECK(frame::has(seenExtensions, frame::stubs[0]));
+    CHECK(createSession(b, nullptr, &sb) == XR_SUCCESS);
+    PFN_xrVoidFunction fn{};
+    CHECK(gipa(b, "xrSetAndroidApplicationThreadKHR", &fn) == XR_SUCCESS);
+    CHECK(reinterpret_cast<PFN_xrSetAndroidApplicationThreadKHR>(fn)(sb, XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR, 1) == XR_TIMEOUT_EXPIRED);
+    CHECK(realThreadCalls == 1);
+    CHECK(threadSettings(sa, XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR, 1) == XR_SUCCESS);
+    CHECK(gipa(a, "xrGetInstanceProperties", &fn) == XR_SUCCESS && fn == reinterpret_cast<PFN_xrVoidFunction>(fakeProperties));
+    CHECK(gipa(a, "xrLocateSpaces", &fn) == XR_SUCCESS);
+    XrSpacesLocateInfo locateInfo{XR_TYPE_SPACES_LOCATE_INFO, nullptr, XR_NULL_HANDLE, 1, 0, nullptr};
+    XrSpaceLocations locations{XR_TYPE_SPACE_LOCATIONS, nullptr, 0, nullptr};
+    CHECK(reinterpret_cast<PFN_xrLocateSpaces>(fn)(sa, &locateInfo, &locations) == XR_SUCCESS && locateCalls == 1);
+    XrPath binding{}, profile{};
+    CHECK(stringToPath(a, "/user/hand/left/input/grip_surface/pose", &binding) == XR_SUCCESS);
+    CHECK(paths[binding] == "/user/hand/left/input/palm_ext/pose");
+    fakeString(a, "/user/hand/left/input/grip_surface/pose", &binding); // preexisting path: rewrite in suggest too
+    fakeString(a, "/interaction_profiles/oculus/touch_controller", &profile);
+    XrActionSuggestedBinding action{XR_NULL_HANDLE, binding};
+    XrInteractionProfileSuggestedBinding suggested{XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING, nullptr, profile, 1, &action};
+    CHECK(suggest(a, &suggested) == XR_SUCCESS && suggestionCalls == 1);
+    CHECK(paths[action.binding] == "/user/hand/left/input/grip_surface/pose");
+    fakeString(a, "/interaction_profiles/meta/touch_pro_controller", &suggested.interactionProfile);
+    CHECK(suggest(a, &suggested) == XR_SUCCESS && suggestionCalls == 1);
+    uint32_t count{};
+    CHECK(enumerate(frame::layerName, 0, &count, nullptr) == XR_SUCCESS && count == 2);
+    XrExtensionProperties props[2]{{XR_TYPE_EXTENSION_PROPERTIES, nullptr, {}, 0}, {XR_TYPE_EXTENSION_PROPERTIES, nullptr, {}, 0}};
+    CHECK(enumerate(frame::layerName, 1, &count, props) == XR_ERROR_SIZE_INSUFFICIENT);
+    CHECK(enumerate(frame::layerName, 2, &count, props) == XR_SUCCESS && count == 2);
+    CHECK(enumerate(nullptr, 0, &count, nullptr) == XR_SUCCESS && count == 4);
+    const char* missing = "XR_MISSING_test";
+    info.enabledExtensionCount = 1; info.enabledExtensionNames = &missing;
+    XrInstance failed{};
+    CHECK(createLayer(&info, &layer, &failed) == XR_ERROR_EXTENSION_NOT_PRESENT && failed == XR_NULL_HANDLE);
+    CHECK(destroySession(sa) == XR_SUCCESS);
+    CHECK(threadSettings(sa, XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR, 1) == XR_ERROR_HANDLE_INVALID);
+    CHECK(destroyInstance(a) == XR_SUCCESS);
+    CHECK(get(sb) && !get(a));
+    CHECK(destroyInstance(b) == XR_SUCCESS && !get(sb));
+    CHECK(instances.empty() && sessions.empty() && enumerateNext == nullptr);
+    std::cout << "Negotiation, next-layer chaining, multi-instance dispatch, stubs, forwarding and cleanup passed\n";
+}
diff --git a/frame/openxr-compat/tests/shims/android/log.h b/frame/openxr-compat/tests/shims/android/log.h
new file mode 100644
index 0000000..dcaf894
--- /dev/null
+++ b/frame/openxr-compat/tests/shims/android/log.h
@@ -0,0 +1,9 @@
+#pragma once
+// Host-only logcat replacement. Android builds use the NDK header and liblog.
+#include <cstdarg>
+#include <cstdio>
+#define ANDROID_LOG_INFO 4
+inline int __android_log_print(int, const char*, const char* fmt, ...) {
+    va_list args; va_start(args, fmt); auto r = std::vfprintf(stderr, fmt, args);
+    va_end(args); std::fputc('\n', stderr); return r;
+}
diff --git a/frame/openxr-compat/tests/shims/jni.h b/frame/openxr-compat/tests/shims/jni.h
new file mode 100644
index 0000000..6223bc2
--- /dev/null
+++ b/frame/openxr-compat/tests/shims/jni.h
@@ -0,0 +1,3 @@
+#pragma once
+// Only the opaque jobject declaration is needed by openxr_platform.h.
+typedef void* jobject;
diff --git a/frame/openxr-compat/vendor/LICENSE b/frame/openxr-compat/vendor/LICENSE
new file mode 100644
index 0000000..527a83a
--- /dev/null
+++ b/frame/openxr-compat/vendor/LICENSE
@@ -0,0 +1,208 @@
+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/frame/openxr-compat/vendor/loader_interfaces.h b/frame/openxr-compat/vendor/loader_interfaces.h
new file mode 100644
index 0000000..020c345
--- /dev/null
+++ b/frame/openxr-compat/vendor/loader_interfaces.h
@@ -0,0 +1,114 @@
+// Copyright (c) 2017-2023, The Khronos Group Inc.
+// Copyright (c) 2017 Valve Corporation
+// Copyright (c) 2017 LunarG, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//
+// Initial Author: Mark Young <marky@lunarg.com>
+//
+
+#pragma once
+
+#include <openxr/openxr.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare.
+typedef struct XrApiLayerCreateInfo XrApiLayerCreateInfo;
+
+// Function pointer prototype for the xrCreateApiLayerInstance function used in place of xrCreateInstance.
+// This function allows us to pass special API layer information to each layer during the process of creating an Instance.
+typedef XrResult(XRAPI_PTR *PFN_xrCreateApiLayerInstance)(const XrInstanceCreateInfo *info,
+                                                          const XrApiLayerCreateInfo *apiLayerInfo, XrInstance *instance);
+
+// Loader/API Layer Interface versions
+//  1 - First version, introduces negotiation structure and functions
+#define XR_CURRENT_LOADER_API_LAYER_VERSION 1
+
+// Loader/Runtime Interface versions
+//  1 - First version, introduces negotiation structure and functions
+#define XR_CURRENT_LOADER_RUNTIME_VERSION 1
+
+// Version negotiation values
+typedef enum XrLoaderInterfaceStructs {
+    XR_LOADER_INTERFACE_STRUCT_UNINTIALIZED = 0,
+    XR_LOADER_INTERFACE_STRUCT_LOADER_INFO,
+    XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST,
+    XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST,
+    XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO,
+    XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO,
+} XrLoaderInterfaceStructs;
+
+#define XR_LOADER_INFO_STRUCT_VERSION 1
+typedef struct XrNegotiateLoaderInfo {
+    XrLoaderInterfaceStructs structType;  // XR_LOADER_INTERFACE_STRUCT_LOADER_INFO
+    uint32_t structVersion;               // XR_LOADER_INFO_STRUCT_VERSION
+    size_t structSize;                    // sizeof(XrNegotiateLoaderInfo)
+    uint32_t minInterfaceVersion;
+    uint32_t maxInterfaceVersion;
+    XrVersion minApiVersion;
+    XrVersion maxApiVersion;
+} XrNegotiateLoaderInfo;
+
+#define XR_API_LAYER_INFO_STRUCT_VERSION 1
+typedef struct XrNegotiateApiLayerRequest {
+    XrLoaderInterfaceStructs structType;  // XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST
+    uint32_t structVersion;               // XR_API_LAYER_INFO_STRUCT_VERSION
+    size_t structSize;                    // sizeof(XrNegotiateApiLayerRequest)
+    uint32_t layerInterfaceVersion;       // CURRENT_LOADER_API_LAYER_VERSION
+    XrVersion layerApiVersion;
+    PFN_xrGetInstanceProcAddr getInstanceProcAddr;
+    PFN_xrCreateApiLayerInstance createApiLayerInstance;
+} XrNegotiateApiLayerRequest;
+
+#define XR_RUNTIME_INFO_STRUCT_VERSION 1
+typedef struct XrNegotiateRuntimeRequest {
+    XrLoaderInterfaceStructs structType;  // XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST
+    uint32_t structVersion;               // XR_RUNTIME_INFO_STRUCT_VERSION
+    size_t structSize;                    // sizeof(XrNegotiateRuntimeRequest)
+    uint32_t runtimeInterfaceVersion;     // CURRENT_LOADER_RUNTIME_VERSION
+    XrVersion runtimeApiVersion;
+    PFN_xrGetInstanceProcAddr getInstanceProcAddr;
+} XrNegotiateRuntimeRequest;
+
+// Function used to negotiate an interface betewen the loader and an API layer.  Each library exposing one or
+// more API layers needs to expose at least this function.
+typedef XrResult(XRAPI_PTR *PFN_xrNegotiateLoaderApiLayerInterface)(const XrNegotiateLoaderInfo *loaderInfo,
+                                                                    const char *apiLayerName,
+                                                                    XrNegotiateApiLayerRequest *apiLayerRequest);
+
+// Function used to negotiate an interface betewen the loader and a runtime.  Each runtime should expose
+// at least this function.
+typedef XrResult(XRAPI_PTR *PFN_xrNegotiateLoaderRuntimeInterface)(const XrNegotiateLoaderInfo *loaderInfo,
+                                                                   XrNegotiateRuntimeRequest *runtimeRequest);
+
+// Forward declare.
+typedef struct XrApiLayerNextInfo XrApiLayerNextInfo;
+
+#define XR_API_LAYER_NEXT_INFO_STRUCT_VERSION 1
+struct XrApiLayerNextInfo {
+    XrLoaderInterfaceStructs structType;                      // XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO
+    uint32_t structVersion;                                   // XR_API_LAYER_NEXT_INFO_STRUCT_VERSION
+    size_t structSize;                                        // sizeof(XrApiLayerNextInfo)
+    char layerName[XR_MAX_API_LAYER_NAME_SIZE];               // Name of API layer which should receive this info
+    PFN_xrGetInstanceProcAddr nextGetInstanceProcAddr;        // Pointer to next API layer's xrGetInstanceProcAddr
+    PFN_xrCreateApiLayerInstance nextCreateApiLayerInstance;  // Pointer to next API layer's xrCreateApiLayerInstance
+    XrApiLayerNextInfo *next;                                 // Pointer to the next API layer info in the sequence
+};
+
+#define XR_API_LAYER_MAX_SETTINGS_PATH_SIZE 512
+#define XR_API_LAYER_CREATE_INFO_STRUCT_VERSION 1
+typedef struct XrApiLayerCreateInfo {
+    XrLoaderInterfaceStructs structType;                               // XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO
+    uint32_t structVersion;                                            // XR_API_LAYER_CREATE_INFO_STRUCT_VERSION
+    size_t structSize;                                                 // sizeof(XrApiLayerCreateInfo)
+    void *loaderInstance;                                              // Pointer to the LoaderInstance class
+    char settings_file_location[XR_API_LAYER_MAX_SETTINGS_PATH_SIZE];  // Location to the found settings file (or empty '\0')
+    XrApiLayerNextInfo *nextInfo;                                      // Pointer to the next API layer's Info
+} XrApiLayerCreateInfo;
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
diff --git a/frame/openxr-compat/vendor/openxr/openxr.h b/frame/openxr-compat/vendor/openxr/openxr.h
new file mode 100644
index 0000000..af56c0f
--- /dev/null
+++ b/frame/openxr-compat/vendor/openxr/openxr.h
@@ -0,0 +1,14911 @@
+#ifndef OPENXR_H_
+#define OPENXR_H_ 1
+
+/*
+** Copyright 2017-2026 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0 OR MIT
+*/
+
+/*
+** This header is generated from the Khronos OpenXR XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+// XR_VERSION_1_0 is a preprocessor guard. Do not pass it to API calls.
+#define XR_VERSION_1_0 1
+#include "openxr_platform_defines.h"
+#define XR_MAKE_VERSION(major, minor, patch) \
+    ((((major) & 0xffffULL) << 48) | (((minor) & 0xffffULL) << 32) | ((patch) & 0xffffffffULL))
+
+// OpenXR current version number.
+#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 1, 63)
+
+// OpenXR 1.0 version number
+#define XR_API_VERSION_1_0 XR_MAKE_VERSION(1, 0, XR_VERSION_PATCH(XR_CURRENT_API_VERSION))
+
+#define XR_VERSION_MAJOR(version) (uint16_t)(((uint64_t)(version) >> 48)& 0xffffULL)
+#define XR_VERSION_MINOR(version) (uint16_t)(((uint64_t)(version) >> 32) & 0xffffULL)
+#define XR_VERSION_PATCH(version) (uint32_t)((uint64_t)(version) & 0xffffffffULL)
+
+#define XR_MIN_COMPOSITION_LAYERS_SUPPORTED 16
+
+
+#if !defined(XR_NULL_HANDLE)
+#if (XR_PTR_SIZE == 8) && XR_CPP_NULLPTR_SUPPORTED
+    #define XR_NULL_HANDLE nullptr
+#else
+    #define XR_NULL_HANDLE 0
+#endif
+#endif
+
+
+#define XR_NULL_SYSTEM_ID 0
+
+
+#define XR_NULL_PATH 0
+
+
+#define XR_SUCCEEDED(result) ((result) >= 0)
+
+
+#define XR_FAILED(result) ((result) < 0)
+
+
+#define XR_UNQUALIFIED_SUCCESS(result) ((result) == 0)
+
+
+#define XR_NO_DURATION 0
+
+
+#define XR_INFINITE_DURATION 0x7fffffffffffffffLL
+
+
+#define XR_MIN_HAPTIC_DURATION -1
+
+
+#define XR_FREQUENCY_UNSPECIFIED 0
+
+
+#define XR_MAX_EVENT_DATA_SIZE sizeof(XrEventDataBuffer)
+
+
+#define XR_EXTENSION_ENUM_BASE 1000000000
+
+
+#define XR_EXTENSION_ENUM_STRIDE 1000
+
+
+#if !defined(XR_MAY_ALIAS)
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4))
+#define XR_MAY_ALIAS __attribute__((__may_alias__))
+#else
+#define XR_MAY_ALIAS
+#endif
+#endif
+
+
+#if !defined(XR_DEFINE_HANDLE)
+#if (XR_PTR_SIZE == 8)
+    #define XR_DEFINE_HANDLE(object) typedef struct object##_T* object;
+#else
+    #define XR_DEFINE_HANDLE(object) typedef uint64_t object;
+#endif
+#endif
+
+
+#if !defined(XR_DEFINE_OPAQUE_64)
+    #if (XR_PTR_SIZE == 8)
+        #define XR_DEFINE_OPAQUE_64(object) typedef struct object##_T* object;
+    #else
+        #define XR_DEFINE_OPAQUE_64(object) typedef uint64_t object;
+    #endif
+#endif
+
+
+#if !defined(XR_DEFINE_ATOM)
+    #define XR_DEFINE_ATOM(object) typedef uint64_t object;
+#endif
+
+typedef uint64_t XrVersion;
+typedef uint64_t XrFlags64;
+XR_DEFINE_ATOM(XrSystemId)
+typedef uint32_t XrBool32;
+XR_DEFINE_ATOM(XrPath)
+typedef int64_t XrTime;
+typedef int64_t XrDuration;
+XR_DEFINE_HANDLE(XrInstance)
+XR_DEFINE_HANDLE(XrSession)
+XR_DEFINE_HANDLE(XrSpace)
+XR_DEFINE_HANDLE(XrAction)
+XR_DEFINE_HANDLE(XrSwapchain)
+XR_DEFINE_HANDLE(XrActionSet)
+#define XR_TRUE                           1
+#define XR_FALSE                          0
+#define XR_MAX_EXTENSION_NAME_SIZE        128
+#define XR_MAX_API_LAYER_NAME_SIZE        256
+#define XR_MAX_API_LAYER_DESCRIPTION_SIZE 256
+#define XR_MAX_SYSTEM_NAME_SIZE           256
+#define XR_MAX_APPLICATION_NAME_SIZE      128
+#define XR_MAX_ENGINE_NAME_SIZE           128
+#define XR_MAX_RUNTIME_NAME_SIZE          128
+#define XR_MAX_PATH_LENGTH                256
+#define XR_MAX_STRUCTURE_NAME_SIZE        64
+#define XR_MAX_RESULT_STRING_SIZE         64
+#define XR_MAX_ACTION_SET_NAME_SIZE       64
+#define XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE 128
+#define XR_MAX_ACTION_NAME_SIZE           64
+#define XR_MAX_LOCALIZED_ACTION_NAME_SIZE 128
+
+typedef enum XrResult {
+    XR_SUCCESS = 0,
+    XR_TIMEOUT_EXPIRED = 1,
+    XR_SESSION_LOSS_PENDING = 3,
+    XR_EVENT_UNAVAILABLE = 4,
+    XR_SPACE_BOUNDS_UNAVAILABLE = 7,
+    XR_SESSION_NOT_FOCUSED = 8,
+    XR_FRAME_DISCARDED = 9,
+    XR_ERROR_VALIDATION_FAILURE = -1,
+    XR_ERROR_RUNTIME_FAILURE = -2,
+    XR_ERROR_OUT_OF_MEMORY = -3,
+    XR_ERROR_API_VERSION_UNSUPPORTED = -4,
+    XR_ERROR_INITIALIZATION_FAILED = -6,
+    XR_ERROR_FUNCTION_UNSUPPORTED = -7,
+    XR_ERROR_FEATURE_UNSUPPORTED = -8,
+    XR_ERROR_EXTENSION_NOT_PRESENT = -9,
+    XR_ERROR_LIMIT_REACHED = -10,
+    XR_ERROR_SIZE_INSUFFICIENT = -11,
+    XR_ERROR_HANDLE_INVALID = -12,
+    XR_ERROR_INSTANCE_LOST = -13,
+    XR_ERROR_SESSION_RUNNING = -14,
+    XR_ERROR_SESSION_NOT_RUNNING = -16,
+    XR_ERROR_SESSION_LOST = -17,
+    XR_ERROR_SYSTEM_INVALID = -18,
+    XR_ERROR_PATH_INVALID = -19,
+    XR_ERROR_PATH_COUNT_EXCEEDED = -20,
+    XR_ERROR_PATH_FORMAT_INVALID = -21,
+    XR_ERROR_PATH_UNSUPPORTED = -22,
+    XR_ERROR_LAYER_INVALID = -23,
+    XR_ERROR_LAYER_LIMIT_EXCEEDED = -24,
+    XR_ERROR_SWAPCHAIN_RECT_INVALID = -25,
+    XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED = -26,
+    XR_ERROR_ACTION_TYPE_MISMATCH = -27,
+    XR_ERROR_SESSION_NOT_READY = -28,
+    XR_ERROR_SESSION_NOT_STOPPING = -29,
+    XR_ERROR_TIME_INVALID = -30,
+    XR_ERROR_REFERENCE_SPACE_UNSUPPORTED = -31,
+    XR_ERROR_FILE_ACCESS_ERROR = -32,
+    XR_ERROR_FILE_CONTENTS_INVALID = -33,
+    XR_ERROR_FORM_FACTOR_UNSUPPORTED = -34,
+    XR_ERROR_FORM_FACTOR_UNAVAILABLE = -35,
+    XR_ERROR_API_LAYER_NOT_PRESENT = -36,
+    XR_ERROR_CALL_ORDER_INVALID = -37,
+    XR_ERROR_GRAPHICS_DEVICE_INVALID = -38,
+    XR_ERROR_POSE_INVALID = -39,
+    XR_ERROR_INDEX_OUT_OF_RANGE = -40,
+    XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED = -41,
+    XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED = -42,
+    XR_ERROR_NAME_DUPLICATED = -44,
+    XR_ERROR_NAME_INVALID = -45,
+    XR_ERROR_ACTIONSET_NOT_ATTACHED = -46,
+    XR_ERROR_ACTIONSETS_ALREADY_ATTACHED = -47,
+    XR_ERROR_LOCALIZED_NAME_DUPLICATED = -48,
+    XR_ERROR_LOCALIZED_NAME_INVALID = -49,
+    XR_ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING = -50,
+    XR_ERROR_RUNTIME_UNAVAILABLE = -51,
+    XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED = -1000710001,
+    XR_ERROR_PERMISSION_INSUFFICIENT = -1000710000,
+    XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR = -1000003000,
+    XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR = -1000003001,
+    XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT = -1000039001,
+    XR_ERROR_SECONDARY_VIEW_CONFIGURATION_TYPE_NOT_ENABLED_MSFT = -1000053000,
+    XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT = -1000055000,
+    XR_ERROR_REPROJECTION_MODE_UNSUPPORTED_MSFT = -1000066000,
+    XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT = -1000097000,
+    XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT = -1000097001,
+    XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT = -1000097002,
+    XR_ERROR_SCENE_MESH_BUFFER_ID_INVALID_MSFT = -1000097003,
+    XR_ERROR_SCENE_COMPUTE_FEATURE_INCOMPATIBLE_MSFT = -1000097004,
+    XR_ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT = -1000097005,
+    XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB = -1000101000,
+    XR_ERROR_COLOR_SPACE_UNSUPPORTED_FB = -1000108000,
+    XR_ERROR_SPACE_COMPONENT_NOT_SUPPORTED_FB = -1000113000,
+    XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB = -1000113001,
+    XR_ERROR_SPACE_COMPONENT_STATUS_PENDING_FB = -1000113002,
+    XR_ERROR_SPACE_COMPONENT_STATUS_ALREADY_SET_FB = -1000113003,
+    XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB = -1000118000,
+    XR_ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB = -1000118001,
+    XR_ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB = -1000118002,
+    XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB = -1000118003,
+    XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB = -1000118004,
+    XR_ERROR_UNKNOWN_PASSTHROUGH_FB = -1000118050,
+    XR_ERROR_RENDER_MODEL_KEY_INVALID_FB = -1000119000,
+    XR_RENDER_MODEL_UNAVAILABLE_FB = 1000119020,
+    XR_ERROR_MARKER_NOT_TRACKED_VARJO = -1000124000,
+    XR_ERROR_MARKER_ID_INVALID_VARJO = -1000124001,
+    XR_ERROR_MARKER_DETECTOR_PERMISSION_DENIED_ML = -1000138000,
+    XR_ERROR_MARKER_DETECTOR_LOCATE_FAILED_ML = -1000138001,
+    XR_ERROR_MARKER_DETECTOR_INVALID_DATA_QUERY_ML = -1000138002,
+    XR_ERROR_MARKER_DETECTOR_INVALID_CREATE_INFO_ML = -1000138003,
+    XR_ERROR_MARKER_INVALID_ML = -1000138004,
+    XR_ERROR_LOCALIZATION_MAP_INCOMPATIBLE_ML = -1000139000,
+    XR_ERROR_LOCALIZATION_MAP_UNAVAILABLE_ML = -1000139001,
+    XR_ERROR_LOCALIZATION_MAP_FAIL_ML = -1000139002,
+    XR_ERROR_LOCALIZATION_MAP_IMPORT_EXPORT_PERMISSION_DENIED_ML = -1000139003,
+    XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML = -1000139004,
+    XR_ERROR_LOCALIZATION_MAP_ALREADY_EXISTS_ML = -1000139005,
+    XR_ERROR_LOCALIZATION_MAP_CANNOT_EXPORT_CLOUD_MAP_ML = -1000139006,
+    XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML = -1000140000,
+    XR_ERROR_SPATIAL_ANCHORS_NOT_LOCALIZED_ML = -1000140001,
+    XR_ERROR_SPATIAL_ANCHORS_OUT_OF_MAP_BOUNDS_ML = -1000140002,
+    XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML = -1000140003,
+    XR_ERROR_SPATIAL_ANCHORS_ANCHOR_NOT_FOUND_ML = -1000141000,
+    XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT = -1000142001,
+    XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT = -1000142002,
+    XR_SCENE_MARKER_DATA_NOT_STRING_MSFT = 1000147000,
+    XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB = -1000169000,
+    XR_ERROR_SPACE_LOCALIZATION_FAILED_FB = -1000169001,
+    XR_ERROR_SPACE_NETWORK_TIMEOUT_FB = -1000169002,
+    XR_ERROR_SPACE_NETWORK_REQUEST_FAILED_FB = -1000169003,
+    XR_ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB = -1000169004,
+    XR_ERROR_SPACE_INSUFFICIENT_RESOURCES_META = -1000259000,
+    XR_ERROR_SPACE_STORAGE_AT_CAPACITY_META = -1000259001,
+    XR_ERROR_SPACE_INSUFFICIENT_VIEW_META = -1000259002,
+    XR_ERROR_SPACE_PERMISSION_INSUFFICIENT_META = -1000259003,
+    XR_ERROR_SPACE_RATE_LIMITED_META = -1000259004,
+    XR_ERROR_SPACE_TOO_DARK_META = -1000259005,
+    XR_ERROR_SPACE_TOO_BRIGHT_META = -1000259006,
+    XR_ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META = -1000266000,
+    XR_ENVIRONMENT_DEPTH_NOT_AVAILABLE_META = 1000291000,
+    XR_ERROR_RENDER_MODEL_ID_INVALID_EXT = -1000300000,
+    XR_ERROR_RENDER_MODEL_ASSET_UNAVAILABLE_EXT = -1000300001,
+    XR_ERROR_RENDER_MODEL_GLTF_EXTENSION_REQUIRED_EXT = -1000300002,
+    XR_ERROR_NOT_INTERACTION_RENDER_MODEL_EXT = -1000301000,
+    XR_ERROR_HINT_ALREADY_SET_QCOM = -1000306000,
+    XR_ERROR_NOT_AN_ANCHOR_HTC = -1000319000,
+    XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD = -1000389000,
+    XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD = -1000389001,
+    XR_ERROR_ANCHOR_NOT_SUPPORTED_FOR_ENTITY_BD = -1000389002,
+    XR_ERROR_SPATIAL_ANCHOR_NOT_FOUND_BD = -1000390000,
+    XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_TIMEOUT_BD = -1000391000,
+    XR_ERROR_SPATIAL_ANCHOR_SHARING_AUTHENTICATION_FAILURE_BD = -1000391001,
+    XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_FAILURE_BD = -1000391002,
+    XR_ERROR_SPATIAL_ANCHOR_SHARING_LOCALIZATION_FAIL_BD = -1000391003,
+    XR_ERROR_SPATIAL_ANCHOR_SHARING_MAP_INSUFFICIENT_BD = -1000391004,
+    XR_ERROR_SCENE_CAPTURE_FAILURE_BD = -1000392000,
+    XR_ERROR_SPACE_NOT_LOCATABLE_EXT = -1000429000,
+    XR_ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT = -1000429001,
+    XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID = -1000455000,
+    XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID = -1000455001,
+    XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID = -1000457000,
+    XR_ERROR_ANCHOR_ALREADY_PERSISTED_ANDROID = -1000457001,
+    XR_ERROR_ANCHOR_NOT_TRACKING_ANDROID = -1000457002,
+    XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID = -1000457003,
+    XR_ERROR_SERVICE_NOT_READY_ANDROID = -1000458000,
+    XR_ERROR_MESH_DATA_LIMIT_EXCEEDED_ANDROID = -1000462000,
+    XR_ERROR_FUTURE_PENDING_EXT = -1000469001,
+    XR_ERROR_FUTURE_INVALID_EXT = -1000469002,
+    XR_ERROR_SYSTEM_NOTIFICATION_PERMISSION_DENIED_ML = -1000473000,
+    XR_ERROR_SYSTEM_NOTIFICATION_INCOMPATIBLE_SKU_ML = -1000473001,
+    XR_ERROR_WORLD_MESH_DETECTOR_PERMISSION_DENIED_ML = -1000474000,
+    XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML = -1000474001,
+    XR_ERROR_FACIAL_EXPRESSION_PERMISSION_DENIED_ML = 1000482000,
+    XR_BOUNDARY_VISIBILITY_SUPPRESSION_NOT_ALLOWED_META = 1000528000,
+    XR_ERROR_COLOCATION_DISCOVERY_NETWORK_FAILED_META = -1000571001,
+    XR_ERROR_COLOCATION_DISCOVERY_NO_DISCOVERY_METHOD_META = -1000571002,
+    XR_COLOCATION_DISCOVERY_ALREADY_ADVERTISING_META = 1000571003,
+    XR_COLOCATION_DISCOVERY_ALREADY_DISCOVERING_META = 1000571004,
+    XR_ERROR_SPACE_GROUP_NOT_FOUND_META = -1000572002,
+    XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID = -1000701000,
+    XR_ERROR_IMAGE_FORMAT_UNSUPPORTED_ANDROID = -1000709000,
+    XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT = -1000740001,
+    XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT = -1000740002,
+    XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT = -1000740003,
+    XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT = -1000740004,
+    XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT = -1000740005,
+    XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT = -1000740006,
+    XR_ERROR_CAMERA_UNAVAILABLE_BD = -1000755000,
+    XR_ERROR_CAMERA_OCCUPIED_BD = -1000755001,
+    XR_ERROR_CAMERA_CAPTURE_SESSION_CAPTURING_BD = -1000755002,
+    XR_ERROR_CAMERA_CAPTURE_SESSION_NOT_CAPTURING_BD = -1000755003,
+    XR_ERROR_CAMERA_ID_INVALID_BD = -1000755004,
+    XR_ERROR_CAMERA_IMAGE_ID_INVALID_BD = -1000755005,
+    XR_ERROR_CAMERA_PROPERTY_TYPE_INVALID_BD = -1000755006,
+    XR_ERROR_CAMERA_CAPABILITY_TYPE_INVALID_BD = -1000755007,
+    XR_ERROR_IMAGE_BUFFER_EXHAUSTED_BD = -1000755008,
+    XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_UNSUPPORTED_EXT = -1000763001,
+    XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_INCOMPATIBLE_EXT = -1000781001,
+    XR_ERROR_SPATIAL_IMAGE_FORMAT_UNSUPPORTED_EXT = -1000782001,
+    XR_ERROR_SPATIAL_IMAGE_INVALID_EXT = -1000782002,
+    XR_ERROR_SPATIAL_IMAGE_SIZE_MISSING_EXT = -1000782003,
+    XR_ERROR_KEYLESS_AUTH_NOT_SETUP_ANDROID = -1000787000,
+    XR_ERROR_KEYLESS_AUTH_FAILED_ANDROID = -1000787001,
+    XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID = -1000789000,
+    XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID = -1000789001,
+    XR_ERROR_GEOSPATIAL_CLOUD_AUTH_FAILED_ANDROID = -1000789002,
+    XR_ERROR_SPATIAL_ANCHOR_ATTACHABLE_COMPONENT_NOT_FOUND_ANDROID = -1000790001,
+    XR_ERROR_SPATIAL_ANCHOR_ENTITY_ID_INVALID_ANDROID = -1000795001,
+    XR_ERROR_SURFACE_ANCHOR_LOCATION_UNSUPPORTED_ANDROID = -1000797000,
+    XR_ERROR_SPATIAL_CONTAINER_CLOSED_EXT = -1000810000,
+    XR_ERROR_SPATIAL_CONTAINERS_ENABLED_EXT = -1000810001,
+    XR_ERROR_SPATIAL_CONTAINERS_NOT_ENABLED_EXT = -1000810002,
+    XR_ERROR_COMPATIBLE_SPATIAL_CONTAINER_MISSING_EXT = -1000810003,
+    XR_ERROR_SPATIAL_CONTAINER_IS_RENDERING_EXT = -1000813001,
+    XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT = -1000813002,
+    XR_ERROR_SPATIAL_CONTAINER_MISSING_EXT = -1000813003,
+    XR_ERROR_SPATIAL_CONTAINER_DUPLICATE_EXT = -1000813004,
+    XR_ERROR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MISSING_EXT = -1000813005,
+    XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED_KHR = XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED,
+    XR_ERROR_PERMISSION_INSUFFICIENT_KHR = XR_ERROR_PERMISSION_INSUFFICIENT,
+    XR_RESULT_MAX_ENUM = 0x7FFFFFFF
+} XrResult;
+
+typedef enum XrStructureType {
+    XR_TYPE_UNKNOWN = 0,
+    XR_TYPE_API_LAYER_PROPERTIES = 1,
+    XR_TYPE_EXTENSION_PROPERTIES = 2,
+    XR_TYPE_INSTANCE_CREATE_INFO = 3,
+    XR_TYPE_SYSTEM_GET_INFO = 4,
+    XR_TYPE_SYSTEM_PROPERTIES = 5,
+    XR_TYPE_VIEW_LOCATE_INFO = 6,
+    XR_TYPE_VIEW = 7,
+    XR_TYPE_SESSION_CREATE_INFO = 8,
+    XR_TYPE_SWAPCHAIN_CREATE_INFO = 9,
+    XR_TYPE_SESSION_BEGIN_INFO = 10,
+    XR_TYPE_VIEW_STATE = 11,
+    XR_TYPE_FRAME_END_INFO = 12,
+    XR_TYPE_HAPTIC_VIBRATION = 13,
+    XR_TYPE_EVENT_DATA_BUFFER = 16,
+    XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING = 17,
+    XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED = 18,
+    XR_TYPE_ACTION_STATE_BOOLEAN = 23,
+    XR_TYPE_ACTION_STATE_FLOAT = 24,
+    XR_TYPE_ACTION_STATE_VECTOR2F = 25,
+    XR_TYPE_ACTION_STATE_POSE = 27,
+    XR_TYPE_ACTION_SET_CREATE_INFO = 28,
+    XR_TYPE_ACTION_CREATE_INFO = 29,
+    XR_TYPE_INSTANCE_PROPERTIES = 32,
+    XR_TYPE_FRAME_WAIT_INFO = 33,
+    XR_TYPE_COMPOSITION_LAYER_PROJECTION = 35,
+    XR_TYPE_COMPOSITION_LAYER_QUAD = 36,
+    XR_TYPE_REFERENCE_SPACE_CREATE_INFO = 37,
+    XR_TYPE_ACTION_SPACE_CREATE_INFO = 38,
+    XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING = 40,
+    XR_TYPE_VIEW_CONFIGURATION_VIEW = 41,
+    XR_TYPE_SPACE_LOCATION = 42,
+    XR_TYPE_SPACE_VELOCITY = 43,
+    XR_TYPE_FRAME_STATE = 44,
+    XR_TYPE_VIEW_CONFIGURATION_PROPERTIES = 45,
+    XR_TYPE_FRAME_BEGIN_INFO = 46,
+    XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW = 48,
+    XR_TYPE_EVENT_DATA_EVENTS_LOST = 49,
+    XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING = 51,
+    XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED = 52,
+    XR_TYPE_INTERACTION_PROFILE_STATE = 53,
+    XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO = 55,
+    XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO = 56,
+    XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO = 57,
+    XR_TYPE_ACTION_STATE_GET_INFO = 58,
+    XR_TYPE_HAPTIC_ACTION_INFO = 59,
+    XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO = 60,
+    XR_TYPE_ACTIONS_SYNC_INFO = 61,
+    XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO = 62,
+    XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO = 63,
+    XR_TYPE_SPACES_LOCATE_INFO = 1000471000,
+    XR_TYPE_SPACE_LOCATIONS = 1000471001,
+    XR_TYPE_SPACE_VELOCITIES = 1000471002,
+    XR_TYPE_COMPOSITION_LAYER_CUBE_KHR = 1000006000,
+    XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR = 1000008000,
+    XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR = 1000010000,
+    XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR = 1000014000,
+    XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT = 1000015000,
+    XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR = 1000017000,
+    XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR = 1000018000,
+    XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000019000,
+    XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000019001,
+    XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000019002,
+    XR_TYPE_DEBUG_UTILS_LABEL_EXT = 1000019003,
+    XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR = 1000023000,
+    XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR = 1000023001,
+    XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR = 1000023002,
+    XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR = 1000023003,
+    XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR = 1000023004,
+    XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR = 1000023005,
+    XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR = 1000024001,
+    XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR = 1000024002,
+    XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR = 1000024003,
+    XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR = 1000025000,
+    XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR = 1000025001,
+    XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR = 1000025002,
+    XR_TYPE_GRAPHICS_BINDING_D3D11_KHR = 1000027000,
+    XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR = 1000027001,
+    XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR = 1000027002,
+    XR_TYPE_GRAPHICS_BINDING_D3D12_KHR = 1000028000,
+    XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR = 1000028001,
+    XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR = 1000028002,
+    XR_TYPE_GRAPHICS_BINDING_METAL_KHR = 1000029000,
+    XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR = 1000029001,
+    XR_TYPE_GRAPHICS_REQUIREMENTS_METAL_KHR = 1000029002,
+    XR_TYPE_SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT = 1000030000,
+    XR_TYPE_EYE_GAZE_SAMPLE_TIME_EXT = 1000030001,
+    XR_TYPE_VISIBILITY_MASK_KHR = 1000031000,
+    XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR = 1000031001,
+    XR_TYPE_SESSION_CREATE_INFO_OVERLAY_EXTX = 1000033000,
+    XR_TYPE_EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX = 1000033003,
+    XR_TYPE_COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR = 1000034000,
+    XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT = 1000039000,
+    XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT = 1000039001,
+    XR_TYPE_COMPOSITION_LAYER_IMAGE_LAYOUT_FB = 1000040000,
+    XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB = 1000041001,
+    XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT = 1000046000,
+    XR_TYPE_GRAPHICS_BINDING_EGL_MNDX = 1000048004,
+    XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT = 1000049000,
+    XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT = 1000049001,
+    XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT = 1000049002,
+    XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT = 1000049003,
+    XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT = 1000051000,
+    XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT = 1000051001,
+    XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT = 1000051002,
+    XR_TYPE_HAND_JOINT_LOCATIONS_EXT = 1000051003,
+    XR_TYPE_HAND_JOINT_VELOCITIES_EXT = 1000051004,
+    XR_TYPE_SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT = 1000052000,
+    XR_TYPE_HAND_MESH_SPACE_CREATE_INFO_MSFT = 1000052001,
+    XR_TYPE_HAND_MESH_UPDATE_INFO_MSFT = 1000052002,
+    XR_TYPE_HAND_MESH_MSFT = 1000052003,
+    XR_TYPE_HAND_POSE_TYPE_INFO_MSFT = 1000052004,
+    XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT = 1000053000,
+    XR_TYPE_SECONDARY_VIEW_CONFIGURATION_STATE_MSFT = 1000053001,
+    XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT = 1000053002,
+    XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT = 1000053003,
+    XR_TYPE_SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT = 1000053004,
+    XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT = 1000053005,
+    XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT = 1000055000,
+    XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT = 1000055001,
+    XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT = 1000055002,
+    XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT = 1000055003,
+    XR_TYPE_CONTROLLER_MODEL_STATE_MSFT = 1000055004,
+    XR_TYPE_VIEW_CONFIGURATION_VIEW_FOV_EPIC = 1000059000,
+    XR_TYPE_HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT = 1000063000,
+    XR_TYPE_COMPOSITION_LAYER_REPROJECTION_INFO_MSFT = 1000066000,
+    XR_TYPE_COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT = 1000066001,
+    XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB = 1000070000,
+    XR_TYPE_COMPOSITION_LAYER_SECURE_CONTENT_FB = 1000072000,
+    XR_TYPE_BODY_TRACKER_CREATE_INFO_FB = 1000076001,
+    XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB = 1000076002,
+    XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_FB = 1000076004,
+    XR_TYPE_BODY_JOINT_LOCATIONS_FB = 1000076005,
+    XR_TYPE_BODY_SKELETON_FB = 1000076006,
+    XR_TYPE_INTERACTION_PROFILE_DPAD_BINDING_EXT = 1000078000,
+    XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE = 1000079000,
+    XR_TYPE_HAND_JOINTS_MOTION_RANGE_INFO_EXT = 1000080000,
+    XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR = 1000089000,
+    XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR = 1000090000,
+    XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR = 1000090001,
+    XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR = 1000090003,
+    XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR = 1000091000,
+    XR_TYPE_SCENE_OBSERVER_CREATE_INFO_MSFT = 1000097000,
+    XR_TYPE_SCENE_CREATE_INFO_MSFT = 1000097001,
+    XR_TYPE_NEW_SCENE_COMPUTE_INFO_MSFT = 1000097002,
+    XR_TYPE_VISUAL_MESH_COMPUTE_LOD_INFO_MSFT = 1000097003,
+    XR_TYPE_SCENE_COMPONENTS_MSFT = 1000097004,
+    XR_TYPE_SCENE_COMPONENTS_GET_INFO_MSFT = 1000097005,
+    XR_TYPE_SCENE_COMPONENT_LOCATIONS_MSFT = 1000097006,
+    XR_TYPE_SCENE_COMPONENTS_LOCATE_INFO_MSFT = 1000097007,
+    XR_TYPE_SCENE_OBJECTS_MSFT = 1000097008,
+    XR_TYPE_SCENE_COMPONENT_PARENT_FILTER_INFO_MSFT = 1000097009,
+    XR_TYPE_SCENE_OBJECT_TYPES_FILTER_INFO_MSFT = 1000097010,
+    XR_TYPE_SCENE_PLANES_MSFT = 1000097011,
+    XR_TYPE_SCENE_PLANE_ALIGNMENT_FILTER_INFO_MSFT = 1000097012,
+    XR_TYPE_SCENE_MESHES_MSFT = 1000097013,
+    XR_TYPE_SCENE_MESH_BUFFERS_GET_INFO_MSFT = 1000097014,
+    XR_TYPE_SCENE_MESH_BUFFERS_MSFT = 1000097015,
+    XR_TYPE_SCENE_MESH_VERTEX_BUFFER_MSFT = 1000097016,
+    XR_TYPE_SCENE_MESH_INDICES_UINT32_MSFT = 1000097017,
+    XR_TYPE_SCENE_MESH_INDICES_UINT16_MSFT = 1000097018,
+    XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT = 1000098000,
+    XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT = 1000098001,
+    XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB = 1000101000,
+    XR_TYPE_VIVE_TRACKER_PATHS_HTCX = 1000103000,
+    XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX = 1000103001,
+    XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC = 1000104000,
+    XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC = 1000104001,
+    XR_TYPE_FACIAL_EXPRESSIONS_HTC = 1000104002,
+    XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB = 1000108000,
+    XR_TYPE_HAND_TRACKING_MESH_FB = 1000110001,
+    XR_TYPE_HAND_TRACKING_SCALE_FB = 1000110003,
+    XR_TYPE_HAND_TRACKING_AIM_STATE_FB = 1000111001,
+    XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB = 1000112000,
+    XR_TYPE_SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB = 1000113004,
+    XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_FB = 1000113003,
+    XR_TYPE_SPACE_COMPONENT_STATUS_SET_INFO_FB = 1000113007,
+    XR_TYPE_SPACE_COMPONENT_STATUS_FB = 1000113001,
+    XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB = 1000113005,
+    XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB = 1000113006,
+    XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB = 1000114000,
+    XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB = 1000114001,
+    XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB = 1000114002,
+    XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB = 1000115000,
+    XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB = 1000116009,
+    XR_TYPE_KEYBOARD_TRACKING_QUERY_FB = 1000116004,
+    XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB = 1000116002,
+    XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB = 1000117001,
+    XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB = 1000118000,
+    XR_TYPE_PASSTHROUGH_CREATE_INFO_FB = 1000118001,
+    XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB = 1000118002,
+    XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB = 1000118003,
+    XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB = 1000118004,
+    XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB = 1000118005,
+    XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES2_FB = 1000118006,
+    XR_TYPE_PASSTHROUGH_STYLE_FB = 1000118020,
+    XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB = 1000118021,
+    XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB = 1000118022,
+    XR_TYPE_PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_FB = 1000118023,
+    XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB = 1000118030,
+    XR_TYPE_RENDER_MODEL_PATH_INFO_FB = 1000119000,
+    XR_TYPE_RENDER_MODEL_PROPERTIES_FB = 1000119001,
+    XR_TYPE_RENDER_MODEL_BUFFER_FB = 1000119002,
+    XR_TYPE_RENDER_MODEL_LOAD_INFO_FB = 1000119003,
+    XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB = 1000119004,
+    XR_TYPE_RENDER_MODEL_CAPABILITIES_REQUEST_FB = 1000119005,
+    XR_TYPE_BINDING_MODIFICATIONS_KHR = 1000120000,
+    XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO = 1000121000,
+    XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO = 1000121001,
+    XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO = 1000121002,
+    XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO = 1000122000,
+    XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO = 1000124000,
+    XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO = 1000124001,
+    XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO = 1000124002,
+    XR_TYPE_FRAME_END_INFO_ML = 1000135000,
+    XR_TYPE_GLOBAL_DIMMER_FRAME_END_INFO_ML = 1000136000,
+    XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML = 1000137000,
+    XR_TYPE_SYSTEM_MARKER_UNDERSTANDING_PROPERTIES_ML = 1000138000,
+    XR_TYPE_MARKER_DETECTOR_CREATE_INFO_ML = 1000138001,
+    XR_TYPE_MARKER_DETECTOR_ARUCO_INFO_ML = 1000138002,
+    XR_TYPE_MARKER_DETECTOR_SIZE_INFO_ML = 1000138003,
+    XR_TYPE_MARKER_DETECTOR_APRIL_TAG_INFO_ML = 1000138004,
+    XR_TYPE_MARKER_DETECTOR_CUSTOM_PROFILE_INFO_ML = 1000138005,
+    XR_TYPE_MARKER_DETECTOR_SNAPSHOT_INFO_ML = 1000138006,
+    XR_TYPE_MARKER_DETECTOR_STATE_ML = 1000138007,
+    XR_TYPE_MARKER_SPACE_CREATE_INFO_ML = 1000138008,
+    XR_TYPE_LOCALIZATION_MAP_ML = 1000139000,
+    XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML = 1000139001,
+    XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML = 1000139002,
+    XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML = 1000139003,
+    XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML = 1000139004,
+    XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML = 1000140000,
+    XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML = 1000140001,
+    XR_TYPE_SPATIAL_ANCHOR_STATE_ML = 1000140002,
+    XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML = 1000141000,
+    XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML = 1000141001,
+    XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML = 1000141002,
+    XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML = 1000141003,
+    XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML = 1000141004,
+    XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML = 1000141005,
+    XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML = 1000141006,
+    XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML = 1000141007,
+    XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML = 1000141008,
+    XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML = 1000141009,
+    XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML = 1000141010,
+    XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML = 1000141011,
+    XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML = 1000141012,
+    XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML = 1000472000,
+    XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML = 1000472001,
+    XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML = 1000472002,
+    XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT = 1000142000,
+    XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT = 1000142001,
+    XR_TYPE_SCENE_MARKERS_MSFT = 1000147000,
+    XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT = 1000147001,
+    XR_TYPE_SCENE_MARKER_QR_CODES_MSFT = 1000147002,
+    XR_TYPE_SPACE_QUERY_INFO_FB = 1000156001,
+    XR_TYPE_SPACE_QUERY_RESULTS_FB = 1000156002,
+    XR_TYPE_SPACE_STORAGE_LOCATION_FILTER_INFO_FB = 1000156003,
+    XR_TYPE_SPACE_UUID_FILTER_INFO_FB = 1000156054,
+    XR_TYPE_SPACE_COMPONENT_FILTER_INFO_FB = 1000156052,
+    XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB = 1000156103,
+    XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB = 1000156104,
+    XR_TYPE_SPACE_SAVE_INFO_FB = 1000158000,
+    XR_TYPE_SPACE_ERASE_INFO_FB = 1000158001,
+    XR_TYPE_EVENT_DATA_SPACE_SAVE_COMPLETE_FB = 1000158106,
+    XR_TYPE_EVENT_DATA_SPACE_ERASE_COMPLETE_FB = 1000158107,
+    XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB = 1000160000,
+    XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB = 1000161000,
+    XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB = 1000162000,
+    XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB = 1000163000,
+    XR_TYPE_SPACE_SHARE_INFO_FB = 1000169001,
+    XR_TYPE_EVENT_DATA_SPACE_SHARE_COMPLETE_FB = 1000169002,
+    XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB = 1000171000,
+    XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB = 1000171001,
+    XR_TYPE_HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB = 1000173001,
+    XR_TYPE_SEMANTIC_LABELS_FB = 1000175000,
+    XR_TYPE_ROOM_LAYOUT_FB = 1000175001,
+    XR_TYPE_BOUNDARY_2D_FB = 1000175002,
+    XR_TYPE_SEMANTIC_LABELS_SUPPORT_INFO_FB = 1000175010,
+    XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE = 1000196000,
+    XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB = 1000198001,
+    XR_TYPE_SCENE_CAPTURE_REQUEST_INFO_FB = 1000198050,
+    XR_TYPE_SPACE_CONTAINER_FB = 1000199000,
+    XR_TYPE_FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META = 1000200000,
+    XR_TYPE_FOVEATION_EYE_TRACKED_STATE_META = 1000200001,
+    XR_TYPE_SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META = 1000200002,
+    XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_FB = 1000201004,
+    XR_TYPE_FACE_TRACKER_CREATE_INFO_FB = 1000201005,
+    XR_TYPE_FACE_EXPRESSION_INFO_FB = 1000201002,
+    XR_TYPE_FACE_EXPRESSION_WEIGHTS_FB = 1000201006,
+    XR_TYPE_EYE_TRACKER_CREATE_INFO_FB = 1000202001,
+    XR_TYPE_EYE_GAZES_INFO_FB = 1000202002,
+    XR_TYPE_EYE_GAZES_FB = 1000202003,
+    XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_FB = 1000202004,
+    XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB = 1000203002,
+    XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB = 1000204000,
+    XR_TYPE_HAPTIC_PCM_VIBRATION_FB = 1000209001,
+    XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB = 1000209002,
+    XR_TYPE_FRAME_SYNTHESIS_INFO_EXT = 1000211000,
+    XR_TYPE_FRAME_SYNTHESIS_CONFIG_VIEW_EXT = 1000211001,
+    XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_FB = 1000212000,
+    XR_TYPE_LOCAL_DIMMING_FRAME_END_INFO_META = 1000216000,
+    XR_TYPE_PASSTHROUGH_PREFERENCES_META = 1000217000,
+    XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META = 1000219001,
+    XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META = 1000219002,
+    XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META = 1000219003,
+    XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META = 1000219004,
+    XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META = 1000219005,
+    XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META = 1000219006,
+    XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META = 1000219007,
+    XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META = 1000219009,
+    XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META = 1000219010,
+    XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META = 1000219011,
+    XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META = 1000219014,
+    XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META = 1000219015,
+    XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META = 1000219016,
+    XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META = 1000219017,
+    XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META = 1000219018,
+    XR_TYPE_EXTERNAL_CAMERA_OCULUS = 1000226000,
+    XR_TYPE_VULKAN_SWAPCHAIN_CREATE_INFO_META = 1000227000,
+    XR_TYPE_PERFORMANCE_METRICS_STATE_META = 1000232001,
+    XR_TYPE_PERFORMANCE_METRICS_COUNTER_META = 1000232002,
+    XR_TYPE_SPACE_LIST_SAVE_INFO_FB = 1000238000,
+    XR_TYPE_EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB = 1000238001,
+    XR_TYPE_SPACE_USER_CREATE_INFO_FB = 1000241001,
+    XR_TYPE_SYSTEM_HEADSET_ID_PROPERTIES_META = 1000245000,
+    XR_TYPE_SYSTEM_SPACE_DISCOVERY_PROPERTIES_META = 1000247000,
+    XR_TYPE_SPACE_DISCOVERY_INFO_META = 1000247001,
+    XR_TYPE_SPACE_FILTER_UUID_META = 1000247003,
+    XR_TYPE_SPACE_FILTER_COMPONENT_META = 1000247004,
+    XR_TYPE_SPACE_DISCOVERY_RESULT_META = 1000247005,
+    XR_TYPE_SPACE_DISCOVERY_RESULTS_META = 1000247006,
+    XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_RESULTS_AVAILABLE_META = 1000247007,
+    XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_COMPLETE_META = 1000247008,
+    XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META = 1000254000,
+    XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META = 1000254001,
+    XR_TYPE_SYSTEM_SPACE_PERSISTENCE_PROPERTIES_META = 1000259000,
+    XR_TYPE_SPACES_SAVE_INFO_META = 1000259001,
+    XR_TYPE_EVENT_DATA_SPACES_SAVE_RESULT_META = 1000259002,
+    XR_TYPE_SPACES_ERASE_INFO_META = 1000259003,
+    XR_TYPE_EVENT_DATA_SPACES_ERASE_RESULT_META = 1000259004,
+    XR_TYPE_SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META = 1000266000,
+    XR_TYPE_PASSTHROUGH_COLOR_LUT_CREATE_INFO_META = 1000266001,
+    XR_TYPE_PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META = 1000266002,
+    XR_TYPE_PASSTHROUGH_COLOR_MAP_LUT_META = 1000266100,
+    XR_TYPE_PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META = 1000266101,
+    XR_TYPE_SPACE_TRIANGLE_MESH_GET_INFO_META = 1000269001,
+    XR_TYPE_SPACE_TRIANGLE_MESH_META = 1000269002,
+    XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FULL_BODY_META = 1000274000,
+    XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META = 1000282000,
+    XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META = 1000283002,
+    XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META = 1000283003,
+    XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META = 1000283004,
+    XR_TYPE_BODY_TRACKING_FIDELITY_STATUS_META = 1000284000,
+    XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FIDELITY_META = 1000284001,
+    XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB = 1000287013,
+    XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB = 1000287014,
+    XR_TYPE_FACE_EXPRESSION_INFO2_FB = 1000287015,
+    XR_TYPE_FACE_EXPRESSION_WEIGHTS2_FB = 1000287016,
+    XR_TYPE_SYSTEM_SPATIAL_ENTITY_SHARING_PROPERTIES_META = 1000290000,
+    XR_TYPE_SHARE_SPACES_INFO_META = 1000290001,
+    XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META = 1000290002,
+    XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META = 1000291000,
+    XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META = 1000291001,
+    XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META = 1000291002,
+    XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_ACQUIRE_INFO_META = 1000291003,
+    XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_VIEW_META = 1000291004,
+    XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META = 1000291005,
+    XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META = 1000291006,
+    XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META = 1000291007,
+    XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_TIMESTAMP_META = 1000291008,
+    XR_TYPE_RENDER_MODEL_CREATE_INFO_EXT = 1000300000,
+    XR_TYPE_RENDER_MODEL_PROPERTIES_GET_INFO_EXT = 1000300001,
+    XR_TYPE_RENDER_MODEL_PROPERTIES_EXT = 1000300002,
+    XR_TYPE_RENDER_MODEL_SPACE_CREATE_INFO_EXT = 1000300003,
+    XR_TYPE_RENDER_MODEL_STATE_GET_INFO_EXT = 1000300004,
+    XR_TYPE_RENDER_MODEL_STATE_EXT = 1000300005,
+    XR_TYPE_RENDER_MODEL_ASSET_CREATE_INFO_EXT = 1000300006,
+    XR_TYPE_RENDER_MODEL_ASSET_DATA_GET_INFO_EXT = 1000300007,
+    XR_TYPE_RENDER_MODEL_ASSET_DATA_EXT = 1000300008,
+    XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_GET_INFO_EXT = 1000300009,
+    XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_EXT = 1000300010,
+    XR_TYPE_INTERACTION_RENDER_MODEL_IDS_ENUMERATE_INFO_EXT = 1000301000,
+    XR_TYPE_INTERACTION_RENDER_MODEL_SUBACTION_PATH_INFO_EXT = 1000301001,
+    XR_TYPE_EVENT_DATA_INTERACTION_RENDER_MODELS_CHANGED_EXT = 1000301002,
+    XR_TYPE_INTERACTION_RENDER_MODEL_TOP_LEVEL_USER_PATH_GET_INFO_EXT = 1000301003,
+    XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC = 1000317001,
+    XR_TYPE_PASSTHROUGH_COLOR_HTC = 1000317002,
+    XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC = 1000317003,
+    XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC = 1000317004,
+    XR_TYPE_FOVEATION_APPLY_INFO_HTC = 1000318000,
+    XR_TYPE_FOVEATION_DYNAMIC_MODE_INFO_HTC = 1000318001,
+    XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC = 1000318002,
+    XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC = 1000319000,
+    XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC = 1000319001,
+    XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC = 1000320000,
+    XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC = 1000320001,
+    XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC = 1000320002,
+    XR_TYPE_BODY_JOINT_LOCATIONS_HTC = 1000320003,
+    XR_TYPE_BODY_SKELETON_HTC = 1000320004,
+    XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT = 1000373000,
+    XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX = 1000375000,
+    XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX = 1000375001,
+    XR_TYPE_BODY_TRACKER_CREATE_INFO_BD = 1000385001,
+    XR_TYPE_BODY_JOINTS_LOCATE_INFO_BD = 1000385002,
+    XR_TYPE_BODY_JOINT_LOCATIONS_BD = 1000385003,
+    XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_BD = 1000385004,
+    XR_TYPE_SYSTEM_FACIAL_SIMULATION_PROPERTIES_BD = 1000386001,
+    XR_TYPE_FACE_TRACKER_CREATE_INFO_BD = 1000386002,
+    XR_TYPE_FACIAL_SIMULATION_DATA_GET_INFO_BD = 1000386003,
+    XR_TYPE_FACIAL_SIMULATION_DATA_BD = 1000386004,
+    XR_TYPE_LIP_EXPRESSION_DATA_BD = 1000386005,
+    XR_TYPE_SYSTEM_SPATIAL_SENSING_PROPERTIES_BD = 1000389000,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_GET_INFO_BD = 1000389001,
+    XR_TYPE_SPATIAL_ENTITY_LOCATION_GET_INFO_BD = 1000389002,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LOCATION_BD = 1000389003,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SEMANTIC_BD = 1000389004,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_2D_BD = 1000389005,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_POLYGON_BD = 1000389006,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_3D_BD = 1000389007,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_TRIANGLE_MESH_BD = 1000389008,
+    XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_BD = 1000389009,
+    XR_TYPE_SENSE_DATA_PROVIDER_START_INFO_BD = 1000389010,
+    XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD = 1000389011,
+    XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD = 1000389012,
+    XR_TYPE_SENSE_DATA_QUERY_INFO_BD = 1000389013,
+    XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD = 1000389014,
+    XR_TYPE_SENSE_DATA_FILTER_UUID_BD = 1000389015,
+    XR_TYPE_SENSE_DATA_FILTER_SEMANTIC_BD = 1000389016,
+    XR_TYPE_QUERIED_SENSE_DATA_GET_INFO_BD = 1000389017,
+    XR_TYPE_QUERIED_SENSE_DATA_BD = 1000389018,
+    XR_TYPE_SPATIAL_ENTITY_STATE_BD = 1000389019,
+    XR_TYPE_SPATIAL_ENTITY_ANCHOR_CREATE_INFO_BD = 1000389020,
+    XR_TYPE_ANCHOR_SPACE_CREATE_INFO_BD = 1000389021,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SPHERE_BD = 1000389022,
+    XR_TYPE_SYSTEM_SPATIAL_ANCHOR_PROPERTIES_BD = 1000390000,
+    XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_BD = 1000390001,
+    XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD = 1000390002,
+    XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_BD = 1000390003,
+    XR_TYPE_SPATIAL_ANCHOR_UNPERSIST_INFO_BD = 1000390004,
+    XR_TYPE_SYSTEM_SPATIAL_ANCHOR_SHARING_PROPERTIES_BD = 1000391000,
+    XR_TYPE_SPATIAL_ANCHOR_SHARE_INFO_BD = 1000391001,
+    XR_TYPE_SHARED_SPATIAL_ANCHOR_DOWNLOAD_INFO_BD = 1000391002,
+    XR_TYPE_SYSTEM_SPATIAL_SCENE_PROPERTIES_BD = 1000392000,
+    XR_TYPE_SCENE_CAPTURE_INFO_BD = 1000392001,
+    XR_TYPE_SYSTEM_SPATIAL_MESH_PROPERTIES_BD = 1000393000,
+    XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_SPATIAL_MESH_BD = 1000393001,
+    XR_TYPE_FUTURE_POLL_RESULT_PROGRESS_BD = 1000394001,
+    XR_TYPE_BODY_TRACKING_POSTURE_DATA_BD = 1000395001,
+    XR_TYPE_BODY_JOINT_VELOCITIES_BD = 1000395002,
+    XR_TYPE_BODY_JOINT_ACCELERATIONS_BD = 1000395003,
+    XR_TYPE_BODY_TRACKING_STATE_BD = 1000395004,
+    XR_TYPE_SYSTEM_SPATIAL_PLANE_PROPERTIES_BD = 1000396000,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_PLANE_ORIENTATION_BD = 1000396001,
+    XR_TYPE_SENSE_DATA_FILTER_PLANE_ORIENTATION_BD = 1000396002,
+    XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_BD = 1000397000,
+    XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_LIGHT_ESTIMATION_BD = 1000397001,
+    XR_TYPE_ENVIRONMENT_TEXTURE_CREATE_CONFIG_INFO_BD = 1000397002,
+    XR_TYPE_LIGHT_ESTIMATION_DATA_ENVIRONMENT_TEXTURE_RAW_BD = 1000397003,
+    XR_TYPE_LIGHT_ESTIMATION_DATA_SPHERICAL_HARMONICS_BD = 1000397005,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LIGHT_ESTIMATION_BD = 1000397006,
+    XR_TYPE_SPATIAL_AUDIO_RENDERER_CREATE_INFO_BD = 1000409000,
+    XR_TYPE_AUDIO_BUFFER_BD = 1000409001,
+    XR_TYPE_SOUND_OBJECT_DIRECTIVITY_CARDIOID_BD = 1000409003,
+    XR_TYPE_SOUND_OBJECT_SHAPE_SPHERE_BD = 1000409004,
+    XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_BD = 1000409005,
+    XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_CURVE_BD = 1000409006,
+    XR_TYPE_SOUND_OBJECT_CONFIG_BD = 1000409007,
+    XR_TYPE_SOUND_FIELD_CONFIG_BD = 1000409008,
+    XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_SURROUND_BD = 1000409009,
+    XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_AMBIX_BD = 1000409010,
+    XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_FUMA_BD = 1000409011,
+    XR_TYPE_SOUND_TRIANGLE_MESH_BD = 1000409012,
+    XR_TYPE_SOUND_OBSTACLE_CONFIG_BD = 1000409013,
+    XR_TYPE_SOUND_OBSTACLE_MATERIAL_CONFIG_BD = 1000409014,
+    XR_TYPE_HAND_TRACKING_DATA_SOURCE_INFO_EXT = 1000428000,
+    XR_TYPE_HAND_TRACKING_DATA_SOURCE_STATE_EXT = 1000428001,
+    XR_TYPE_PLANE_DETECTOR_CREATE_INFO_EXT = 1000429001,
+    XR_TYPE_PLANE_DETECTOR_BEGIN_INFO_EXT = 1000429002,
+    XR_TYPE_PLANE_DETECTOR_GET_INFO_EXT = 1000429003,
+    XR_TYPE_PLANE_DETECTOR_LOCATIONS_EXT = 1000429004,
+    XR_TYPE_PLANE_DETECTOR_LOCATION_EXT = 1000429005,
+    XR_TYPE_PLANE_DETECTOR_POLYGON_BUFFER_EXT = 1000429006,
+    XR_TYPE_SYSTEM_PLANE_DETECTION_PROPERTIES_EXT = 1000429007,
+    XR_TYPE_TRACKABLE_GET_INFO_ANDROID = 1000455000,
+    XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID = 1000455001,
+    XR_TYPE_TRACKABLE_PLANE_ANDROID = 1000455003,
+    XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID = 1000455004,
+    XR_TYPE_SYSTEM_TRACKABLES_PROPERTIES_ANDROID = 1000455005,
+    XR_TYPE_EYES_ANDROID = 1000456000,
+    XR_TYPE_EYE_TRACKER_CREATE_INFO_ANDROID = 1000456001,
+    XR_TYPE_EYES_GET_INFO_ANDROID = 1000456002,
+    XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_ANDROID = 1000456004,
+    XR_TYPE_PERSISTED_ANCHOR_SPACE_CREATE_INFO_ANDROID = 1000457001,
+    XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID = 1000457002,
+    XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID = 1000457003,
+    XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID = 1000457004,
+    XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID = 1000458000,
+    XR_TYPE_FACE_STATE_GET_INFO_ANDROID = 1000458001,
+    XR_TYPE_FACE_STATE_ANDROID = 1000458002,
+    XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID = 1000458003,
+    XR_TYPE_PASSTHROUGH_CAMERA_STATE_GET_INFO_ANDROID = 1000460000,
+    XR_TYPE_SYSTEM_PASSTHROUGH_CAMERA_STATE_PROPERTIES_ANDROID = 1000460001,
+    XR_TYPE_EVENT_DATA_RECOMMENDED_RESOLUTION_CHANGED_ANDROID = 1000461000,
+    XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_ANDROID = 1000462000,
+    XR_TYPE_PASSTHROUGH_LAYER_MESH_ANDROID = 1000462001,
+    XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID = 1000462002,
+    XR_TYPE_SYSTEM_PASSTHROUGH_LAYER_PROPERTIES_ANDROID = 1000462003,
+    XR_TYPE_RAYCAST_INFO_ANDROID = 1000463000,
+    XR_TYPE_RAYCAST_HIT_RESULTS_ANDROID = 1000463001,
+    XR_TYPE_PERFORMANCE_METRICS_STATE_ANDROID = 1000465000,
+    XR_TYPE_PERFORMANCE_METRICS_COUNTER_ANDROID = 1000465001,
+    XR_TYPE_TRACKABLE_OBJECT_ANDROID = 1000466000,
+    XR_TYPE_TRACKABLE_OBJECT_CONFIGURATION_ANDROID = 1000466001,
+    XR_TYPE_FUTURE_CANCEL_INFO_EXT = 1000469000,
+    XR_TYPE_FUTURE_POLL_INFO_EXT = 1000469001,
+    XR_TYPE_FUTURE_COMPLETION_EXT = 1000469002,
+    XR_TYPE_FUTURE_POLL_RESULT_EXT = 1000469003,
+    XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT = 1000470000,
+    XR_TYPE_SYSTEM_USER_PRESENCE_PROPERTIES_EXT = 1000470001,
+    XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML = 1000473000,
+    XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML = 1000474001,
+    XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML = 1000474002,
+    XR_TYPE_WORLD_MESH_BLOCK_STATE_ML = 1000474003,
+    XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML = 1000474004,
+    XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML = 1000474005,
+    XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML = 1000474006,
+    XR_TYPE_WORLD_MESH_BUFFER_ML = 1000474007,
+    XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML = 1000474008,
+    XR_TYPE_WORLD_MESH_GET_INFO_ML = 1000474009,
+    XR_TYPE_WORLD_MESH_BLOCK_ML = 1000474010,
+    XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML = 1000474011,
+    XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML = 1000474012,
+    XR_TYPE_SYSTEM_FACIAL_EXPRESSION_PROPERTIES_ML = 1000482004,
+    XR_TYPE_FACIAL_EXPRESSION_CLIENT_CREATE_INFO_ML = 1000482005,
+    XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_GET_INFO_ML = 1000482006,
+    XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_ML = 1000482007,
+    XR_TYPE_SYSTEM_BOUNDARY_VISIBILITY_PROPERTIES_META = 1000528000,
+    XR_TYPE_EVENT_DATA_BOUNDARY_VISIBILITY_CHANGED_META = 1000528001,
+    XR_TYPE_SYSTEM_SIMULTANEOUS_HANDS_AND_CONTROLLERS_PROPERTIES_META = 1000532001,
+    XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_RESUME_INFO_META = 1000532002,
+    XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_PAUSE_INFO_META = 1000532003,
+    XR_TYPE_FACE_TRACKING_VISEMES_META = 1000541000,
+    XR_TYPE_SYSTEM_FACE_TRACKING_VISEMES_PROPERTIES_META = 1000541001,
+    XR_TYPE_ROOM_MESH_FACE_INDICES_META = 1000553000,
+    XR_TYPE_SPACE_ROOM_MESH_GET_INFO_META = 1000553001,
+    XR_TYPE_ROOM_MESH_META = 1000553002,
+    XR_TYPE_COLOCATION_DISCOVERY_START_INFO_META = 1000571010,
+    XR_TYPE_COLOCATION_DISCOVERY_STOP_INFO_META = 1000571011,
+    XR_TYPE_COLOCATION_ADVERTISEMENT_START_INFO_META = 1000571012,
+    XR_TYPE_COLOCATION_ADVERTISEMENT_STOP_INFO_META = 1000571013,
+    XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META = 1000571020,
+    XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META = 1000571021,
+    XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META = 1000571022,
+    XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META = 1000571023,
+    XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META = 1000571024,
+    XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META = 1000571025,
+    XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META = 1000571026,
+    XR_TYPE_SYSTEM_COLOCATION_DISCOVERY_PROPERTIES_META = 1000571030,
+    XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META = 1000572000,
+    XR_TYPE_SPACE_GROUP_UUID_FILTER_INFO_META = 1000572001,
+    XR_TYPE_SYSTEM_SPATIAL_ENTITY_GROUP_SHARING_PROPERTIES_META = 1000572100,
+    XR_TYPE_SYSTEM_ENVIRONMENT_RAYCAST_PROPERTIES_META = 1000592000,
+    XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_INFO_META = 1000592001,
+    XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META = 1000592002,
+    XR_TYPE_ENVIRONMENT_RAYCAST_HIT_GET_INFO_META = 1000592003,
+    XR_TYPE_ENVIRONMENT_RAYCAST_HIT_META = 1000592004,
+    XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META = 1000592005,
+    XR_TYPE_TILE_PROPERTIES_META = 1000609000,
+    XR_TYPE_TILE_PROPERTIES_HINT_META = 1000609001,
+    XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_REQUEST_META = 1000693000,
+    XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_META = 1000693001,
+    XR_TYPE_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID = 1000700000,
+    XR_TYPE_LIGHT_ESTIMATE_GET_INFO_ANDROID = 1000700001,
+    XR_TYPE_LIGHT_ESTIMATE_ANDROID = 1000700002,
+    XR_TYPE_DIRECTIONAL_LIGHT_ANDROID = 1000700003,
+    XR_TYPE_SPHERICAL_HARMONICS_ANDROID = 1000700004,
+    XR_TYPE_AMBIENT_LIGHT_ANDROID = 1000700005,
+    XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_ANDROID = 1000700006,
+    XR_TYPE_ANCHOR_SHARING_INFO_ANDROID = 1000701000,
+    XR_TYPE_ANCHOR_SHARING_TOKEN_ANDROID = 1000701001,
+    XR_TYPE_SYSTEM_ANCHOR_SHARING_EXPORT_PROPERTIES_ANDROID = 1000701002,
+    XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID = 1000707000,
+    XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID = 1000707001,
+    XR_TYPE_TRACKABLE_MARKER_ANDROID = 1000707002,
+    XR_TYPE_SYSTEM_QR_CODE_TRACKING_PROPERTIES_ANDROID = 1000708000,
+    XR_TYPE_TRACKABLE_QR_CODE_CONFIGURATION_ANDROID = 1000708001,
+    XR_TYPE_TRACKABLE_QR_CODE_ANDROID = 1000708002,
+    XR_TYPE_SYSTEM_IMAGE_TRACKING_PROPERTIES_ANDROID = 1000709000,
+    XR_TYPE_TRACKABLE_IMAGE_DATABASE_ENTRY_ANDROID = 1000709001,
+    XR_TYPE_TRACKABLE_IMAGE_DATABASE_CREATE_INFO_ANDROID = 1000709002,
+    XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID = 1000709003,
+    XR_TYPE_TRACKABLE_IMAGE_CONFIGURATION_ANDROID = 1000709004,
+    XR_TYPE_TRACKABLE_IMAGE_ANDROID = 1000709005,
+    XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID = 1000709006,
+    XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID = 1000718000,
+    XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID = 1000718001,
+    XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID = 1000718002,
+    XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID = 1000718003,
+    XR_TYPE_SCENE_SUBMESH_STATE_ANDROID = 1000718004,
+    XR_TYPE_SCENE_SUBMESH_DATA_ANDROID = 1000718005,
+    XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT = 1000740000,
+    XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT = 1000740001,
+    XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT = 1000740002,
+    XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT = 1000740003,
+    XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT = 1000740004,
+    XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT = 1000740005,
+    XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT = 1000740006,
+    XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT = 1000740007,
+    XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT = 1000740008,
+    XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT = 1000740009,
+    XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT = 1000740010,
+    XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT = 1000740011,
+    XR_TYPE_SPATIAL_COMPONENT_MESH_3D_LIST_EXT = 1000740012,
+    XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT = 1000740013,
+    XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT = 1000740014,
+    XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT = 1000740015,
+    XR_TYPE_SPATIAL_FILTER_TRACKING_STATE_EXT = 1000740016,
+    XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT = 1000741000,
+    XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT = 1000741001,
+    XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT = 1000741002,
+    XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT = 1000741003,
+    XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT = 1000741004,
+    XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_GET_INFO_EXT = 1000742001,
+    XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_RESULT_EXT = 1000742002,
+    XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT = 1000743000,
+    XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT = 1000743001,
+    XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT = 1000743002,
+    XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT = 1000743003,
+    XR_TYPE_SPATIAL_MARKER_SIZE_EXT = 1000743004,
+    XR_TYPE_SPATIAL_MARKER_STATIC_OPTIMIZATION_EXT = 1000743005,
+    XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT = 1000743006,
+    XR_TYPE_SYSTEM_DYNAMIC_OBJECT_TRACKING_PROPERTIES_BD = 1000746000,
+    XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_DYNAMIC_OBJECT_BD = 1000746001,
+    XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_DYNAMIC_OBJECT_BD = 1000746002,
+    XR_TYPE_DYNAMIC_OBJECT_DATA_BD = 1000746003,
+    XR_TYPE_SENSE_DATA_FILTER_DYNAMIC_OBJECT_TYPE_BD = 1000746004,
+    XR_TYPE_SYSTEM_DYNAMIC_OBJECT_KEYBOARD_PROPERTIES_BD = 1000747000,
+    XR_TYPE_SYSTEM_DYNAMIC_OBJECT_MOUSE_PROPERTIES_BD = 1000748000,
+    XR_TYPE_AVAILABLE_CAMERAS_ENUMERATE_INFO_BD = 1000755000,
+    XR_TYPE_CAMERA_PROPERTIES_GET_INFO_BD = 1000755001,
+    XR_TYPE_CAMERA_PROPERTIES_BD = 1000755002,
+    XR_TYPE_CAMERA_PROPERTY_FACING_BD = 1000755003,
+    XR_TYPE_CAMERA_PROPERTY_POSITION_BD = 1000755004,
+    XR_TYPE_CAMERA_PROPERTY_CAMERA_TYPE_BD = 1000755005,
+    XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_GET_INFO_BD = 1000755006,
+    XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_BD = 1000755007,
+    XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD = 1000755008,
+    XR_TYPE_CAMERA_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD = 1000755009,
+    XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_DATA_TRANSFER_TYPE_BD = 1000755010,
+    XR_TYPE_CAMERA_CAPABILITY_DATA_TRANSFER_TYPE_BD = 1000755011,
+    XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_FORMAT_BD = 1000755012,
+    XR_TYPE_CAMERA_CAPABILITY_IMAGE_FORMAT_BD = 1000755013,
+    XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_CAMERA_MODEL_BD = 1000755014,
+    XR_TYPE_CAMERA_CAPABILITY_CAMERA_MODEL_BD = 1000755015,
+    XR_TYPE_CAMERA_DEVICE_CREATE_INFO_BD = 1000755016,
+    XR_TYPE_CREATE_CAMERA_DEVICE_COMPLETION_BD = 1000755017,
+    XR_TYPE_CAMERA_CAPTURE_SESSION_CREATE_INFO_BD = 1000755018,
+    XR_TYPE_CREATE_CAMERA_CAPTURE_SESSION_COMPLETION_BD = 1000755019,
+    XR_TYPE_CAMERA_INTRINSICS_BD = 1000755020,
+    XR_TYPE_CAMERA_EXTRINSICS_BD = 1000755021,
+    XR_TYPE_CAMERA_CAPTURE_BEGIN_INFO_BD = 1000755022,
+    XR_TYPE_CAMERA_IMAGE_ACQUIRE_INFO_BD = 1000755023,
+    XR_TYPE_CAMERA_IMAGE_BD = 1000755024,
+    XR_TYPE_CAMERA_IMAGE_DATA_RAW_BUFFER_BD = 1000755025,
+    XR_TYPE_CAMERA_CAPABILITIES_BD = 1000755026,
+    XR_TYPE_CAMERA_CAPABILITY_TYPES_ENUMERATE_INFO_BD = 1000755027,
+    XR_TYPE_CAMERA_CAPABILITY_TYPES_BD = 1000755028,
+    XR_TYPE_CAMERA_PROPERTY_TYPES_ENUMERATE_INFO_BD = 1000755029,
+    XR_TYPE_CAMERA_PROPERTY_TYPES_BD = 1000755030,
+    XR_TYPE_AVAILABLE_CAMERA_BD = 1000755031,
+    XR_TYPE_SPATIAL_BOUNDS_SPHEREF_ANDROID = 1000761000,
+    XR_TYPE_SPATIAL_BOUNDS_BOXF_ANDROID = 1000761001,
+    XR_TYPE_SPATIAL_BOUNDS_FRUSTUMF_ANDROID = 1000761002,
+    XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANCHOR_EXT = 1000762000,
+    XR_TYPE_SPATIAL_COMPONENT_ANCHOR_LIST_EXT = 1000762001,
+    XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_EXT = 1000762002,
+    XR_TYPE_SPATIAL_PERSISTENCE_CONTEXT_CREATE_INFO_EXT = 1000763000,
+    XR_TYPE_CREATE_SPATIAL_PERSISTENCE_CONTEXT_COMPLETION_EXT = 1000763001,
+    XR_TYPE_SPATIAL_CONTEXT_PERSISTENCE_CONFIG_EXT = 1000763002,
+    XR_TYPE_SPATIAL_DISCOVERY_PERSISTENCE_UUID_FILTER_EXT = 1000763003,
+    XR_TYPE_SPATIAL_COMPONENT_PERSISTENCE_LIST_EXT = 1000763004,
+    XR_TYPE_HAPTIC_PARAMETRIC_VIBRATION_EXT = 1000775000,
+    XR_TYPE_HAPTIC_PARAMETRIC_PROPERTIES_EXT = 1000775001,
+    XR_TYPE_SYSTEM_HAPTIC_PARAMETRIC_PROPERTIES_EXT = 1000775002,
+    XR_TYPE_COLOR_SPACES_ENUMERATE_INFO_SONY = 1000776000,
+    XR_TYPE_SWAPCHAIN_CREATE_INFO_COLOR_SPACE_SONY = 1000776001,
+    XR_TYPE_HDR_METADATA_SONY = 1000777000,
+    XR_TYPE_SPATIAL_ENTITY_PERSIST_INFO_EXT = 1000781000,
+    XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT = 1000781001,
+    XR_TYPE_SPATIAL_ENTITY_UNPERSIST_INFO_EXT = 1000781002,
+    XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT = 1000781003,
+    XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT = 1000782000,
+    XR_TYPE_SPATIAL_IMAGE_STATIC_OPTIMIZATION_EXT = 1000782001,
+    XR_TYPE_SPATIAL_IMAGE_SIZE_EXT = 1000782002,
+    XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT = 1000782003,
+    XR_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_CREATE_INFO_EXT = 1000782004,
+    XR_TYPE_SPATIAL_COMPONENT_IMAGE_2D_LIST_EXT = 1000782005,
+    XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT = 1000782006,
+    XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID = 1000785000,
+    XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_ANDROID = 1000785001,
+    XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID = 1000786000,
+    XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID = 1000786001,
+    XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID = 1000786002,
+    XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID = 1000786003,
+    XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_API_KEY_ANDROID = 1000787000,
+    XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_TOKEN_ANDROID = 1000787001,
+    XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_KEYLESS_ANDROID = 1000787002,
+    XR_TYPE_GOOGLE_CLOUD_AUTH_ERROR_RESULT_ANDROID = 1000787003,
+    XR_TYPE_SYSTEM_GEOSPATIAL_PROPERTIES_ANDROID = 1000789000,
+    XR_TYPE_GEOSPATIAL_TRACKER_CREATE_INFO_ANDROID = 1000789001,
+    XR_TYPE_EVENT_DATA_GEOSPATIAL_TRACKER_STATE_CHANGED_ANDROID = 1000789002,
+    XR_TYPE_GEOSPATIAL_POSE_FROM_POSE_LOCATE_INFO_ANDROID = 1000789003,
+    XR_TYPE_GEOSPATIAL_POSE_RESULT_ANDROID = 1000789004,
+    XR_TYPE_GEOSPATIAL_POSE_LOCATE_INFO_ANDROID = 1000789005,
+    XR_TYPE_VPS_AVAILABILITY_CHECK_COMPLETION_ANDROID = 1000789006,
+    XR_TYPE_SPATIAL_ANCHOR_PARENT_ANDROID = 1000790000,
+    XR_TYPE_SPATIAL_DISCOVERY_UNIQUE_ENTITIES_FILTER_ANDROID = 1000791001,
+    XR_TYPE_SPATIAL_COMPONENT_SUBSUMED_BY_LIST_ANDROID = 1000791002,
+    XR_TYPE_SPATIAL_ANCHOR_SPACE_FROM_ID_CREATE_INFO_ANDROID = 1000795000,
+    XR_TYPE_GEOSPATIAL_ANCHOR_CREATE_INFO_ANDROID = 1000797000,
+    XR_TYPE_SURFACE_ANCHOR_CREATE_INFO_ANDROID = 1000797001,
+    XR_TYPE_SURFACE_ANCHOR_CREATE_COMPLETION_ANDROID = 1000797002,
+    XR_TYPE_SYSTEM_GEOSPATIAL_ANCHOR_PROPERTIES_ANDROID = 1000797003,
+    XR_TYPE_GEOSPATIAL_TRACKER_ANCHOR_TRACKING_INFO_ANDROID = 1000797004,
+    XR_TYPE_SPATIAL_CONTAINER_CREATE_INFO_EXT = 1000810000,
+    XR_TYPE_SPATIAL_CONTAINER_SPACE_CREATE_INFO_EXT = 1000810001,
+    XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_CLOSED_EXT = 1000810003,
+    XR_TYPE_SYSTEM_SPATIAL_CONTAINER_PROPERTIES_EXT = 1000810004,
+    XR_TYPE_SPATIAL_CONTAINER_BOUNDS_EXT = 1000810005,
+    XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_CHANGED_EXT = 1000810006,
+    XR_TYPE_SPATIAL_CONTAINER_BOUNDS_GET_INFO_EXT = 1000810007,
+    XR_TYPE_SPATIAL_CONTAINER_STATE_GET_INFO_EXT = 1000810008,
+    XR_TYPE_SPATIAL_CONTAINER_VISIBLE_REQUEST_INFO_EXT = 1000810009,
+    XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_CHANGED_EXT = 1000810010,
+    XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_REQUEST_DENIED_EXT = 1000810011,
+    XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_INTERACTABLE_CHANGED_EXT = 1000810012,
+    XR_TYPE_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_INFO_EXT = 1000810013,
+    XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_DENIED_EXT = 1000810014,
+    XR_TYPE_SPATIAL_CONTAINER_STATE_EXT = 1000810015,
+    XR_TYPE_SESSION_CREATE_INFO_SPATIAL_CONTAINERS_EXT = 1000810016,
+    XR_TYPE_SPATIAL_CONTAINER_VIEW_LOCATE_INFO_EXT = 1000813000,
+    XR_TYPE_SPATIAL_CONTAINER_VIEWS_LOCATE_INFO_EXT = 1000813001,
+    XR_TYPE_SPATIAL_CONTAINER_VIEW_STATE_EXT = 1000813002,
+    XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT = 1000813003,
+    XR_TYPE_SPATIAL_CONTAINER_LAYER_FRAME_END_INFO_EXT = 1000813004,
+    XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT = 1000813005,
+    XR_TYPE_SPATIAL_CONTAINER_COMPOSITION_LAYER_VIEW_CONFIGURATION_EXT = 1000813006,
+    XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT = 1000813007,
+    XR_TYPE_SPATIAL_CONTAINER_LAYER_VOLUME_CLIPPING_EXT = 1000813008,
+    XR_TYPE_BATTERY_STATE_DISPLAY_EXT = 1000836000,
+    XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT = 1000838000,
+    XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT = 1000839000,
+    XR_TYPE_GRAPHICS_BINDING_VULKAN2_KHR = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR,
+    XR_TYPE_SWAPCHAIN_IMAGE_VULKAN2_KHR = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR,
+    XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN2_KHR = XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR,
+    XR_TYPE_DEVICE_PCM_SAMPLE_RATE_GET_INFO_FB = XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB,
+    XR_TYPE_SPACES_LOCATE_INFO_KHR = XR_TYPE_SPACES_LOCATE_INFO,
+    XR_TYPE_SPACE_LOCATIONS_KHR = XR_TYPE_SPACE_LOCATIONS,
+    XR_TYPE_SPACE_VELOCITIES_KHR = XR_TYPE_SPACE_VELOCITIES,
+    XR_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} XrStructureType;
+
+typedef enum XrFormFactor {
+    XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY = 1,
+    XR_FORM_FACTOR_HANDHELD_DISPLAY = 2,
+    XR_FORM_FACTOR_MAX_ENUM = 0x7FFFFFFF
+} XrFormFactor;
+
+typedef enum XrEnvironmentBlendMode {
+    XR_ENVIRONMENT_BLEND_MODE_OPAQUE = 1,
+    XR_ENVIRONMENT_BLEND_MODE_ADDITIVE = 2,
+    XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND = 3,
+    XR_ENVIRONMENT_BLEND_MODE_MAX_ENUM = 0x7FFFFFFF
+} XrEnvironmentBlendMode;
+
+typedef enum XrViewConfigurationType {
+    XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO = 1,
+    XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO = 2,
+    XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO_WITH_FOVEATED_INSET = 1000037000,
+    XR_VIEW_CONFIGURATION_TYPE_SECONDARY_MONO_FIRST_PERSON_OBSERVER_MSFT = 1000054000,
+    XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO_WITH_FOVEATED_INSET,
+    XR_VIEW_CONFIGURATION_TYPE_MAX_ENUM = 0x7FFFFFFF
+} XrViewConfigurationType;
+
+typedef enum XrReferenceSpaceType {
+    XR_REFERENCE_SPACE_TYPE_VIEW = 1,
+    XR_REFERENCE_SPACE_TYPE_LOCAL = 2,
+    XR_REFERENCE_SPACE_TYPE_STAGE = 3,
+    XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR = 1000426000,
+    XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT = 1000038000,
+    XR_REFERENCE_SPACE_TYPE_COMBINED_EYE_VARJO = 1000121000,
+    XR_REFERENCE_SPACE_TYPE_LOCALIZATION_MAP_ML = 1000139000,
+    XR_REFERENCE_SPACE_TYPE_UNBOUNDED_ANDROID = 1000467000,
+    XR_REFERENCE_SPACE_TYPE_STATIONARY_EXT = 1000742000,
+    XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT = XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR,
+    XR_REFERENCE_SPACE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} XrReferenceSpaceType;
+
+typedef enum XrEyeVisibility {
+    XR_EYE_VISIBILITY_BOTH = 0,
+    XR_EYE_VISIBILITY_LEFT = 1,
+    XR_EYE_VISIBILITY_RIGHT = 2,
+    XR_EYE_VISIBILITY_MAX_ENUM = 0x7FFFFFFF
+} XrEyeVisibility;
+
+typedef enum XrActionType {
+    XR_ACTION_TYPE_BOOLEAN_INPUT = 1,
+    XR_ACTION_TYPE_FLOAT_INPUT = 2,
+    XR_ACTION_TYPE_VECTOR2F_INPUT = 3,
+    XR_ACTION_TYPE_POSE_INPUT = 4,
+    XR_ACTION_TYPE_VIBRATION_OUTPUT = 100,
+    XR_ACTION_TYPE_MAX_ENUM = 0x7FFFFFFF
+} XrActionType;
+
+typedef enum XrSessionState {
+    XR_SESSION_STATE_UNKNOWN = 0,
+    XR_SESSION_STATE_IDLE = 1,
+    XR_SESSION_STATE_READY = 2,
+    XR_SESSION_STATE_SYNCHRONIZED = 3,
+    XR_SESSION_STATE_VISIBLE = 4,
+    XR_SESSION_STATE_FOCUSED = 5,
+    XR_SESSION_STATE_STOPPING = 6,
+    XR_SESSION_STATE_LOSS_PENDING = 7,
+    XR_SESSION_STATE_EXITING = 8,
+    XR_SESSION_STATE_MAX_ENUM = 0x7FFFFFFF
+} XrSessionState;
+
+typedef enum XrObjectType {
+    XR_OBJECT_TYPE_UNKNOWN = 0,
+    XR_OBJECT_TYPE_INSTANCE = 1,
+    XR_OBJECT_TYPE_SESSION = 2,
+    XR_OBJECT_TYPE_SWAPCHAIN = 3,
+    XR_OBJECT_TYPE_SPACE = 4,
+    XR_OBJECT_TYPE_ACTION_SET = 5,
+    XR_OBJECT_TYPE_ACTION = 6,
+    XR_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000019000,
+    XR_OBJECT_TYPE_SPATIAL_ANCHOR_MSFT = 1000039000,
+    XR_OBJECT_TYPE_SPATIAL_GRAPH_NODE_BINDING_MSFT = 1000049000,
+    XR_OBJECT_TYPE_HAND_TRACKER_EXT = 1000051000,
+    XR_OBJECT_TYPE_BODY_TRACKER_FB = 1000076000,
+    XR_OBJECT_TYPE_SCENE_OBSERVER_MSFT = 1000097000,
+    XR_OBJECT_TYPE_SCENE_MSFT = 1000097001,
+    XR_OBJECT_TYPE_FACIAL_TRACKER_HTC = 1000104000,
+    XR_OBJECT_TYPE_FOVEATION_PROFILE_FB = 1000114000,
+    XR_OBJECT_TYPE_TRIANGLE_MESH_FB = 1000117000,
+    XR_OBJECT_TYPE_PASSTHROUGH_FB = 1000118000,
+    XR_OBJECT_TYPE_PASSTHROUGH_LAYER_FB = 1000118002,
+    XR_OBJECT_TYPE_GEOMETRY_INSTANCE_FB = 1000118004,
+    XR_OBJECT_TYPE_MARKER_DETECTOR_ML = 1000138000,
+    XR_OBJECT_TYPE_EXPORTED_LOCALIZATION_MAP_ML = 1000139000,
+    XR_OBJECT_TYPE_SPATIAL_ANCHORS_STORAGE_ML = 1000141000,
+    XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT = 1000142000,
+    XR_OBJECT_TYPE_FACE_TRACKER_FB = 1000201000,
+    XR_OBJECT_TYPE_EYE_TRACKER_FB = 1000202000,
+    XR_OBJECT_TYPE_VIRTUAL_KEYBOARD_META = 1000219000,
+    XR_OBJECT_TYPE_SPACE_USER_FB = 1000241000,
+    XR_OBJECT_TYPE_PASSTHROUGH_COLOR_LUT_META = 1000266000,
+    XR_OBJECT_TYPE_FACE_TRACKER2_FB = 1000287012,
+    XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_PROVIDER_META = 1000291000,
+    XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_META = 1000291001,
+    XR_OBJECT_TYPE_RENDER_MODEL_EXT = 1000300000,
+    XR_OBJECT_TYPE_RENDER_MODEL_ASSET_EXT = 1000300001,
+    XR_OBJECT_TYPE_PASSTHROUGH_HTC = 1000317000,
+    XR_OBJECT_TYPE_BODY_TRACKER_HTC = 1000320000,
+    XR_OBJECT_TYPE_BODY_TRACKER_BD = 1000385000,
+    XR_OBJECT_TYPE_FACE_TRACKER_BD = 1000386000,
+    XR_OBJECT_TYPE_SENSE_DATA_PROVIDER_BD = 1000389000,
+    XR_OBJECT_TYPE_SENSE_DATA_SNAPSHOT_BD = 1000389001,
+    XR_OBJECT_TYPE_ANCHOR_BD = 1000389002,
+    XR_OBJECT_TYPE_SPATIAL_AUDIO_RENDERER_BD = 1000409000,
+    XR_OBJECT_TYPE_SOUND_FIELD_BD = 1000409001,
+    XR_OBJECT_TYPE_SOUND_OBJECT_BD = 1000409002,
+    XR_OBJECT_TYPE_SOUND_OBSTACLE_BD = 1000409003,
+    XR_OBJECT_TYPE_SOUND_OBSTACLE_MATERIAL_BD = 1000409004,
+    XR_OBJECT_TYPE_PLANE_DETECTOR_EXT = 1000429000,
+    XR_OBJECT_TYPE_TRACKABLE_TRACKER_ANDROID = 1000455001,
+    XR_OBJECT_TYPE_EYE_TRACKER_ANDROID = 1000456000,
+    XR_OBJECT_TYPE_DEVICE_ANCHOR_PERSISTENCE_ANDROID = 1000457000,
+    XR_OBJECT_TYPE_FACE_TRACKER_ANDROID = 1000458000,
+    XR_OBJECT_TYPE_PASSTHROUGH_LAYER_ANDROID = 1000462000,
+    XR_OBJECT_TYPE_WORLD_MESH_DETECTOR_ML = 1000474000,
+    XR_OBJECT_TYPE_FACIAL_EXPRESSION_CLIENT_ML = 1000482000,
+    XR_OBJECT_TYPE_ENVIRONMENT_RAYCASTER_META = 1000592000,
+    XR_OBJECT_TYPE_LIGHT_ESTIMATOR_ANDROID = 1000700000,
+    XR_OBJECT_TYPE_TRACKABLE_IMAGE_DATABASE_ANDROID = 1000709000,
+    XR_OBJECT_TYPE_SCENE_MESHING_TRACKER_ANDROID = 1000718000,
+    XR_OBJECT_TYPE_SCENE_MESH_SNAPSHOT_ANDROID = 1000718001,
+    XR_OBJECT_TYPE_SPATIAL_ENTITY_EXT = 1000740000,
+    XR_OBJECT_TYPE_SPATIAL_CONTEXT_EXT = 1000740001,
+    XR_OBJECT_TYPE_SPATIAL_SNAPSHOT_EXT = 1000740002,
+    XR_OBJECT_TYPE_CAMERA_DEVICE_BD = 1000755000,
+    XR_OBJECT_TYPE_CAMERA_CAPTURE_SESSION_BD = 1000755001,
+    XR_OBJECT_TYPE_SPATIAL_PERSISTENCE_CONTEXT_EXT = 1000763000,
+    XR_OBJECT_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_EXT = 1000782000,
+    XR_OBJECT_TYPE_GEOSPATIAL_TRACKER_ANDROID = 1000789000,
+    XR_OBJECT_TYPE_SPATIAL_CONTAINER_EXT = 1000810000,
+    XR_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
+} XrObjectType;
+typedef XrFlags64 XrInstanceCreateFlags;
+
+// Flag bits for XrInstanceCreateFlags
+
+typedef XrFlags64 XrSessionCreateFlags;
+
+// Flag bits for XrSessionCreateFlags
+
+typedef XrFlags64 XrSpaceLocationFlags;
+
+// Flag bits for XrSpaceLocationFlags
+static const XrSpaceLocationFlags XR_SPACE_LOCATION_ORIENTATION_VALID_BIT = 0x00000001;
+static const XrSpaceLocationFlags XR_SPACE_LOCATION_POSITION_VALID_BIT = 0x00000002;
+static const XrSpaceLocationFlags XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT = 0x00000004;
+static const XrSpaceLocationFlags XR_SPACE_LOCATION_POSITION_TRACKED_BIT = 0x00000008;
+
+typedef XrFlags64 XrSpaceVelocityFlags;
+
+// Flag bits for XrSpaceVelocityFlags
+static const XrSpaceVelocityFlags XR_SPACE_VELOCITY_LINEAR_VALID_BIT = 0x00000001;
+static const XrSpaceVelocityFlags XR_SPACE_VELOCITY_ANGULAR_VALID_BIT = 0x00000002;
+
+typedef XrFlags64 XrSwapchainCreateFlags;
+
+// Flag bits for XrSwapchainCreateFlags
+static const XrSwapchainCreateFlags XR_SWAPCHAIN_CREATE_PROTECTED_CONTENT_BIT = 0x00000001;
+static const XrSwapchainCreateFlags XR_SWAPCHAIN_CREATE_STATIC_IMAGE_BIT = 0x00000002;
+
+typedef XrFlags64 XrSwapchainUsageFlags;
+
+// Flag bits for XrSwapchainUsageFlags
+static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT = 0x00000001;
+static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000002;
+static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT = 0x00000004;
+static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_TRANSFER_SRC_BIT = 0x00000008;
+static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_TRANSFER_DST_BIT = 0x00000010;
+static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_SAMPLED_BIT = 0x00000020;
+static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT = 0x00000040;
+static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND = 0x00000080;
+static const XrSwapchainUsageFlags XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_KHR = 0x00000080;  // alias of XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND
+
+typedef XrFlags64 XrCompositionLayerFlags;
+
+// Flag bits for XrCompositionLayerFlags
+// XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT is deprecated and should not be used
+static const XrCompositionLayerFlags XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT = 0x00000001;
+static const XrCompositionLayerFlags XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT = 0x00000002;
+static const XrCompositionLayerFlags XR_COMPOSITION_LAYER_UNPREMULTIPLIED_ALPHA_BIT = 0x00000004;
+static const XrCompositionLayerFlags XR_COMPOSITION_LAYER_INVERTED_ALPHA_BIT_EXT = 0x00000008;
+
+typedef XrFlags64 XrViewStateFlags;
+
+// Flag bits for XrViewStateFlags
+static const XrViewStateFlags XR_VIEW_STATE_ORIENTATION_VALID_BIT = 0x00000001;
+static const XrViewStateFlags XR_VIEW_STATE_POSITION_VALID_BIT = 0x00000002;
+static const XrViewStateFlags XR_VIEW_STATE_ORIENTATION_TRACKED_BIT = 0x00000004;
+static const XrViewStateFlags XR_VIEW_STATE_POSITION_TRACKED_BIT = 0x00000008;
+
+typedef XrFlags64 XrInputSourceLocalizedNameFlags;
+
+// Flag bits for XrInputSourceLocalizedNameFlags
+static const XrInputSourceLocalizedNameFlags XR_INPUT_SOURCE_LOCALIZED_NAME_USER_PATH_BIT = 0x00000001;
+static const XrInputSourceLocalizedNameFlags XR_INPUT_SOURCE_LOCALIZED_NAME_INTERACTION_PROFILE_BIT = 0x00000002;
+static const XrInputSourceLocalizedNameFlags XR_INPUT_SOURCE_LOCALIZED_NAME_COMPONENT_BIT = 0x00000004;
+
+typedef void (XRAPI_PTR *PFN_xrVoidFunction)(void);
+typedef struct XrApiLayerProperties {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    char                  layerName[XR_MAX_API_LAYER_NAME_SIZE];
+    XrVersion             specVersion;
+    uint32_t              layerVersion;
+    char                  description[XR_MAX_API_LAYER_DESCRIPTION_SIZE];
+} XrApiLayerProperties;
+
+typedef struct XrExtensionProperties {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    char                  extensionName[XR_MAX_EXTENSION_NAME_SIZE];
+    uint32_t              extensionVersion;
+} XrExtensionProperties;
+
+typedef struct XrApplicationInfo {
+    char         applicationName[XR_MAX_APPLICATION_NAME_SIZE];
+    uint32_t     applicationVersion;
+    char         engineName[XR_MAX_ENGINE_NAME_SIZE];
+    uint32_t     engineVersion;
+    XrVersion    apiVersion;
+} XrApplicationInfo;
+
+typedef struct XrInstanceCreateInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrInstanceCreateFlags       createFlags;
+    XrApplicationInfo           applicationInfo;
+    uint32_t                    enabledApiLayerCount;
+    const char* const*          enabledApiLayerNames;
+    uint32_t                    enabledExtensionCount;
+    const char* const*          enabledExtensionNames;
+} XrInstanceCreateInfo;
+
+typedef struct XrInstanceProperties {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrVersion             runtimeVersion;
+    char                  runtimeName[XR_MAX_RUNTIME_NAME_SIZE];
+} XrInstanceProperties;
+
+typedef struct XrEventDataBuffer {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint8_t                     varying[4000];
+} XrEventDataBuffer;
+
+typedef struct XrSystemGetInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrFormFactor                formFactor;
+} XrSystemGetInfo;
+
+typedef struct XrSystemGraphicsProperties {
+    uint32_t    maxSwapchainImageHeight;
+    uint32_t    maxSwapchainImageWidth;
+    uint32_t    maxLayerCount;
+} XrSystemGraphicsProperties;
+
+typedef struct XrSystemTrackingProperties {
+    XrBool32    orientationTracking;
+    XrBool32    positionTracking;
+} XrSystemTrackingProperties;
+
+typedef struct XrSystemProperties {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    XrSystemId                    systemId;
+    uint32_t                      vendorId;
+    char                          systemName[XR_MAX_SYSTEM_NAME_SIZE];
+    XrSystemGraphicsProperties    graphicsProperties;
+    XrSystemTrackingProperties    trackingProperties;
+} XrSystemProperties;
+
+typedef struct XrSessionCreateInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSessionCreateFlags        createFlags;
+    XrSystemId                  systemId;
+} XrSessionCreateInfo;
+
+typedef struct XrQuaternionf {
+    float    x;
+    float    y;
+    float    z;
+    float    w;
+} XrQuaternionf;
+
+typedef struct XrVector3f {
+    float    x;
+    float    y;
+    float    z;
+} XrVector3f;
+
+typedef struct XrPosef {
+    XrQuaternionf    orientation;
+    XrVector3f       position;
+} XrPosef;
+
+typedef struct XrReferenceSpaceCreateInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrReferenceSpaceType        referenceSpaceType;
+    XrPosef                     poseInReferenceSpace;
+} XrReferenceSpaceCreateInfo;
+
+typedef struct XrActionSpaceCreateInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAction                    action;
+    XrPath                      subactionPath;
+    XrPosef                     poseInActionSpace;
+} XrActionSpaceCreateInfo;
+
+typedef struct XrSpaceLocation {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    XrSpaceLocationFlags    locationFlags;
+    XrPosef                 pose;
+} XrSpaceLocation;
+
+// XrSpaceVelocity extends XrSpaceLocation
+typedef struct XrSpaceVelocity {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    XrSpaceVelocityFlags    velocityFlags;
+    XrVector3f              linearVelocity;
+    XrVector3f              angularVelocity;
+} XrSpaceVelocity;
+
+typedef struct XrExtent2Df {
+    float    width;
+    float    height;
+} XrExtent2Df;
+
+typedef struct XrViewConfigurationProperties {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    XrViewConfigurationType    viewConfigurationType;
+    XrBool32                   fovMutable;
+} XrViewConfigurationProperties;
+
+typedef struct XrViewConfigurationView {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              recommendedImageRectWidth;
+    uint32_t              maxImageRectWidth;
+    uint32_t              recommendedImageRectHeight;
+    uint32_t              maxImageRectHeight;
+    uint32_t              recommendedSwapchainSampleCount;
+    uint32_t              maxSwapchainSampleCount;
+} XrViewConfigurationView;
+
+typedef struct XrSwapchainCreateInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSwapchainCreateFlags      createFlags;
+    XrSwapchainUsageFlags       usageFlags;
+    int64_t                     format;
+    uint32_t                    sampleCount;
+    uint32_t                    width;
+    uint32_t                    height;
+    uint32_t                    faceCount;
+    uint32_t                    arraySize;
+    uint32_t                    mipCount;
+} XrSwapchainCreateInfo;
+
+typedef struct XR_MAY_ALIAS XrSwapchainImageBaseHeader {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+} XrSwapchainImageBaseHeader;
+
+typedef struct XrSwapchainImageAcquireInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSwapchainImageAcquireInfo;
+
+typedef struct XrSwapchainImageWaitInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrDuration                  timeout;
+} XrSwapchainImageWaitInfo;
+
+typedef struct XrSwapchainImageReleaseInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSwapchainImageReleaseInfo;
+
+typedef struct XrSessionBeginInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrViewConfigurationType     primaryViewConfigurationType;
+} XrSessionBeginInfo;
+
+typedef struct XrFrameState {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrTime                predictedDisplayTime;
+    XrDuration            predictedDisplayPeriod;
+    XrBool32              shouldRender;
+} XrFrameState;
+
+typedef struct XrFrameWaitInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrFrameWaitInfo;
+
+typedef struct XrFrameBeginInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrFrameBeginInfo;
+
+typedef struct XR_MAY_ALIAS XrCompositionLayerBaseHeader {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCompositionLayerFlags     layerFlags;
+    XrSpace                     space;
+} XrCompositionLayerBaseHeader;
+
+typedef struct XrFrameEndInfo {
+    XrStructureType                               type;
+    const void* XR_MAY_ALIAS                      next;
+    XrTime                                        displayTime;
+    XrEnvironmentBlendMode                        environmentBlendMode;
+    uint32_t                                      layerCount;
+    const XrCompositionLayerBaseHeader* const*    layers;
+} XrFrameEndInfo;
+
+typedef struct XrViewState {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrViewStateFlags      viewStateFlags;
+} XrViewState;
+
+typedef struct XrViewLocateInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrViewConfigurationType     viewConfigurationType;
+    XrTime                      displayTime;
+    XrSpace                     space;
+} XrViewLocateInfo;
+
+typedef struct XrFovf {
+    float    angleLeft;
+    float    angleRight;
+    float    angleUp;
+    float    angleDown;
+} XrFovf;
+
+typedef struct XrView {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrPosef               pose;
+    XrFovf                fov;
+} XrView;
+
+typedef struct XrActionSetCreateInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    char                        actionSetName[XR_MAX_ACTION_SET_NAME_SIZE];
+    char                        localizedActionSetName[XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE];
+    uint32_t                    priority;
+} XrActionSetCreateInfo;
+
+typedef struct XrActionCreateInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    char                        actionName[XR_MAX_ACTION_NAME_SIZE];
+    XrActionType                actionType;
+    uint32_t                    countSubactionPaths;
+    const XrPath*               subactionPaths;
+    char                        localizedActionName[XR_MAX_LOCALIZED_ACTION_NAME_SIZE];
+} XrActionCreateInfo;
+
+typedef struct XrActionSuggestedBinding {
+    XrAction    action;
+    XrPath      binding;
+} XrActionSuggestedBinding;
+
+typedef struct XrInteractionProfileSuggestedBinding {
+    XrStructureType                    type;
+    const void* XR_MAY_ALIAS           next;
+    XrPath                             interactionProfile;
+    uint32_t                           countSuggestedBindings;
+    const XrActionSuggestedBinding*    suggestedBindings;
+} XrInteractionProfileSuggestedBinding;
+
+typedef struct XrSessionActionSetsAttachInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    countActionSets;
+    const XrActionSet*          actionSets;
+} XrSessionActionSetsAttachInfo;
+
+typedef struct XrInteractionProfileState {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrPath                interactionProfile;
+} XrInteractionProfileState;
+
+typedef struct XrActionStateGetInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAction                    action;
+    XrPath                      subactionPath;
+} XrActionStateGetInfo;
+
+typedef struct XrActionStateBoolean {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              currentState;
+    XrBool32              changedSinceLastSync;
+    XrTime                lastChangeTime;
+    XrBool32              isActive;
+} XrActionStateBoolean;
+
+typedef struct XrActionStateFloat {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    float                 currentState;
+    XrBool32              changedSinceLastSync;
+    XrTime                lastChangeTime;
+    XrBool32              isActive;
+} XrActionStateFloat;
+
+typedef struct XrVector2f {
+    float    x;
+    float    y;
+} XrVector2f;
+
+typedef struct XrActionStateVector2f {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrVector2f            currentState;
+    XrBool32              changedSinceLastSync;
+    XrTime                lastChangeTime;
+    XrBool32              isActive;
+} XrActionStateVector2f;
+
+typedef struct XrActionStatePose {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              isActive;
+} XrActionStatePose;
+
+typedef struct XrActiveActionSet {
+    XrActionSet    actionSet;
+    XrPath         subactionPath;
+} XrActiveActionSet;
+
+typedef struct XrActionsSyncInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    countActiveActionSets;
+    const XrActiveActionSet*    activeActionSets;
+} XrActionsSyncInfo;
+
+typedef struct XrBoundSourcesForActionEnumerateInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAction                    action;
+} XrBoundSourcesForActionEnumerateInfo;
+
+typedef struct XrInputSourceLocalizedNameGetInfo {
+    XrStructureType                    type;
+    const void* XR_MAY_ALIAS           next;
+    XrPath                             sourcePath;
+    XrInputSourceLocalizedNameFlags    whichComponents;
+} XrInputSourceLocalizedNameGetInfo;
+
+typedef struct XR_MAY_ALIAS XrHapticBaseHeader {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrHapticBaseHeader;
+
+typedef struct XrHapticActionInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAction                    action;
+    XrPath                      subactionPath;
+} XrHapticActionInfo;
+
+typedef struct XR_MAY_ALIAS XrBaseInStructure {
+    XrStructureType                    type;
+    const struct XrBaseInStructure*    next;
+} XrBaseInStructure;
+
+typedef struct XR_MAY_ALIAS XrBaseOutStructure {
+    XrStructureType               type;
+    struct XrBaseOutStructure*    next;
+} XrBaseOutStructure;
+
+typedef struct XrOffset2Di {
+    int32_t    x;
+    int32_t    y;
+} XrOffset2Di;
+
+typedef struct XrExtent2Di {
+    int32_t    width;
+    int32_t    height;
+} XrExtent2Di;
+
+typedef struct XrRect2Di {
+    XrOffset2Di    offset;
+    XrExtent2Di    extent;
+} XrRect2Di;
+
+typedef struct XrSwapchainSubImage {
+    XrSwapchain    swapchain;
+    XrRect2Di      imageRect;
+    uint32_t       imageArrayIndex;
+} XrSwapchainSubImage;
+
+typedef struct XrCompositionLayerProjectionView {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrPosef                     pose;
+    XrFovf                      fov;
+    XrSwapchainSubImage         subImage;
+} XrCompositionLayerProjectionView;
+
+typedef struct XrCompositionLayerProjection {
+    XrStructureType                            type;
+    const void* XR_MAY_ALIAS                   next;
+    XrCompositionLayerFlags                    layerFlags;
+    XrSpace                                    space;
+    uint32_t                                   viewCount;
+    const XrCompositionLayerProjectionView*    views;
+} XrCompositionLayerProjection;
+
+typedef struct XrCompositionLayerQuad {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCompositionLayerFlags     layerFlags;
+    XrSpace                     space;
+    XrEyeVisibility             eyeVisibility;
+    XrSwapchainSubImage         subImage;
+    XrPosef                     pose;
+    XrExtent2Df                 size;
+} XrCompositionLayerQuad;
+
+typedef struct XR_MAY_ALIAS XrEventDataBaseHeader {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrEventDataBaseHeader;
+
+typedef struct XrEventDataEventsLost {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    lostEventCount;
+} XrEventDataEventsLost;
+
+typedef struct XrEventDataInstanceLossPending {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      lossTime;
+} XrEventDataInstanceLossPending;
+
+typedef struct XrEventDataSessionStateChanged {
+     XrStructureType            type;
+    const void* XR_MAY_ALIAS    next;
+    XrSession                   session;
+    XrSessionState              state;
+    XrTime                      time;
+} XrEventDataSessionStateChanged;
+
+typedef struct XrEventDataReferenceSpaceChangePending {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSession                   session;
+    XrReferenceSpaceType        referenceSpaceType;
+    XrTime                      changeTime;
+    XrBool32                    poseValid;
+    XrPosef                     poseInPreviousSpace;
+} XrEventDataReferenceSpaceChangePending;
+
+typedef struct XrEventDataInteractionProfileChanged {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSession                   session;
+} XrEventDataInteractionProfileChanged;
+
+typedef struct XrHapticVibration {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrDuration                  duration;
+    float                       frequency;
+    float                       amplitude;
+} XrHapticVibration;
+
+typedef struct XrOffset2Df {
+    float    x;
+    float    y;
+} XrOffset2Df;
+
+typedef struct XrRect2Df {
+    XrOffset2Df    offset;
+    XrExtent2Df    extent;
+} XrRect2Df;
+
+typedef struct XrVector4f {
+    float    x;
+    float    y;
+    float    z;
+    float    w;
+} XrVector4f;
+
+typedef struct XrColor4f {
+    float    r;
+    float    g;
+    float    b;
+    float    a;
+} XrColor4f;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetInstanceProcAddr)(XrInstance instance, const char* name, PFN_xrVoidFunction* function);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateApiLayerProperties)(uint32_t propertyCapacityInput, uint32_t* propertyCountOutput, XrApiLayerProperties* properties);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateInstanceExtensionProperties)(const char* layerName, uint32_t propertyCapacityInput, uint32_t* propertyCountOutput, XrExtensionProperties* properties);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateInstance)(const XrInstanceCreateInfo* createInfo, XrInstance* instance);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyInstance)(XrInstance instance);
+typedef XrResult (XRAPI_PTR *PFN_xrGetInstanceProperties)(XrInstance instance, XrInstanceProperties* instanceProperties);
+typedef XrResult (XRAPI_PTR *PFN_xrPollEvent)(XrInstance instance, XrEventDataBuffer* eventData);
+typedef XrResult (XRAPI_PTR *PFN_xrResultToString)(XrInstance instance, XrResult value, char buffer[XR_MAX_RESULT_STRING_SIZE]);
+typedef XrResult (XRAPI_PTR *PFN_xrStructureTypeToString)(XrInstance instance, XrStructureType value, char buffer[XR_MAX_STRUCTURE_NAME_SIZE]);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSystem)(XrInstance instance, const XrSystemGetInfo* getInfo, XrSystemId* systemId);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSystemProperties)(XrInstance instance, XrSystemId systemId, XrSystemProperties* properties);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentBlendModes)(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t environmentBlendModeCapacityInput, uint32_t* environmentBlendModeCountOutput, XrEnvironmentBlendMode* environmentBlendModes);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSession)(XrInstance instance, const XrSessionCreateInfo* createInfo, XrSession* session);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySession)(XrSession session);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateReferenceSpaces)(XrSession session, uint32_t spaceCapacityInput, uint32_t* spaceCountOutput, XrReferenceSpaceType* spaces);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateReferenceSpace)(XrSession session, const XrReferenceSpaceCreateInfo* createInfo, XrSpace* space);
+typedef XrResult (XRAPI_PTR *PFN_xrGetReferenceSpaceBoundsRect)(XrSession session, XrReferenceSpaceType referenceSpaceType, XrExtent2Df* bounds);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateActionSpace)(XrSession session, const XrActionSpaceCreateInfo* createInfo, XrSpace* space);
+typedef XrResult (XRAPI_PTR *PFN_xrLocateSpace)(XrSpace space, XrSpace baseSpace, XrTime time, XrSpaceLocation* location);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpace)(XrSpace space);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViewConfigurations)(XrInstance instance, XrSystemId systemId, uint32_t viewConfigurationTypeCapacityInput, uint32_t* viewConfigurationTypeCountOutput, XrViewConfigurationType* viewConfigurationTypes);
+typedef XrResult (XRAPI_PTR *PFN_xrGetViewConfigurationProperties)(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, XrViewConfigurationProperties* configurationProperties);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViewConfigurationViews)(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t viewCapacityInput, uint32_t* viewCountOutput, XrViewConfigurationView* views);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSwapchainFormats)(XrSession session, uint32_t formatCapacityInput, uint32_t* formatCountOutput, int64_t* formats);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSwapchain)(XrSession session, const XrSwapchainCreateInfo* createInfo, XrSwapchain* swapchain);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySwapchain)(XrSwapchain swapchain);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSwapchainImages)(XrSwapchain swapchain, uint32_t imageCapacityInput, uint32_t* imageCountOutput, XrSwapchainImageBaseHeader* images);
+typedef XrResult (XRAPI_PTR *PFN_xrAcquireSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageAcquireInfo* acquireInfo, uint32_t* index);
+typedef XrResult (XRAPI_PTR *PFN_xrWaitSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageWaitInfo* waitInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrReleaseSwapchainImage)(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo* releaseInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrBeginSession)(XrSession session, const XrSessionBeginInfo* beginInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrEndSession)(XrSession session);
+typedef XrResult (XRAPI_PTR *PFN_xrRequestExitSession)(XrSession session);
+typedef XrResult (XRAPI_PTR *PFN_xrWaitFrame)(XrSession session, const XrFrameWaitInfo* frameWaitInfo, XrFrameState* frameState);
+typedef XrResult (XRAPI_PTR *PFN_xrBeginFrame)(XrSession session, const XrFrameBeginInfo* frameBeginInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrEndFrame)(XrSession session, const XrFrameEndInfo* frameEndInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrLocateViews)(XrSession session, const XrViewLocateInfo* viewLocateInfo, XrViewState* viewState, uint32_t viewCapacityInput, uint32_t* viewCountOutput, XrView* views);
+typedef XrResult (XRAPI_PTR *PFN_xrStringToPath)(XrInstance instance, const char* pathString, XrPath* path);
+typedef XrResult (XRAPI_PTR *PFN_xrPathToString)(XrInstance instance, XrPath path, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateActionSet)(XrInstance instance, const XrActionSetCreateInfo* createInfo, XrActionSet* actionSet);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyActionSet)(XrActionSet actionSet);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateAction)(XrActionSet actionSet, const XrActionCreateInfo* createInfo, XrAction* action);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyAction)(XrAction action);
+typedef XrResult (XRAPI_PTR *PFN_xrSuggestInteractionProfileBindings)(XrInstance instance, const XrInteractionProfileSuggestedBinding* suggestedBindings);
+typedef XrResult (XRAPI_PTR *PFN_xrAttachSessionActionSets)(XrSession session, const XrSessionActionSetsAttachInfo* attachInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrGetCurrentInteractionProfile)(XrSession session, XrPath topLevelUserPath, XrInteractionProfileState* interactionProfile);
+typedef XrResult (XRAPI_PTR *PFN_xrGetActionStateBoolean)(XrSession session, const XrActionStateGetInfo* getInfo, XrActionStateBoolean* state);
+typedef XrResult (XRAPI_PTR *PFN_xrGetActionStateFloat)(XrSession session, const XrActionStateGetInfo* getInfo, XrActionStateFloat* state);
+typedef XrResult (XRAPI_PTR *PFN_xrGetActionStateVector2f)(XrSession session, const XrActionStateGetInfo* getInfo, XrActionStateVector2f* state);
+typedef XrResult (XRAPI_PTR *PFN_xrGetActionStatePose)(XrSession session, const XrActionStateGetInfo* getInfo, XrActionStatePose* state);
+typedef XrResult (XRAPI_PTR *PFN_xrSyncActions)(XrSession session, const XrActionsSyncInfo* syncInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateBoundSourcesForAction)(XrSession session, const XrBoundSourcesForActionEnumerateInfo* enumerateInfo, uint32_t sourceCapacityInput, uint32_t* sourceCountOutput, XrPath* sources);
+typedef XrResult (XRAPI_PTR *PFN_xrGetInputSourceLocalizedName)(XrSession session, const XrInputSourceLocalizedNameGetInfo* getInfo, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrApplyHapticFeedback)(XrSession session, const XrHapticActionInfo* hapticActionInfo, const XrHapticBaseHeader* hapticFeedback);
+typedef XrResult (XRAPI_PTR *PFN_xrStopHapticFeedback)(XrSession session, const XrHapticActionInfo* hapticActionInfo);
+
+#ifndef XR_NO_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetInstanceProcAddr(
+    XrInstance                                  instance,
+    const char*                                 name,
+    PFN_xrVoidFunction*                         function);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateApiLayerProperties(
+    uint32_t                                    propertyCapacityInput,
+    uint32_t*                                   propertyCountOutput,
+    XrApiLayerProperties*                       properties);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateInstanceExtensionProperties(
+    const char*                                 layerName,
+    uint32_t                                    propertyCapacityInput,
+    uint32_t*                                   propertyCountOutput,
+    XrExtensionProperties*                      properties);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateInstance(
+    const XrInstanceCreateInfo*                 createInfo,
+    XrInstance*                                 instance);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyInstance(
+    XrInstance                                  instance);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetInstanceProperties(
+    XrInstance                                  instance,
+    XrInstanceProperties*                       instanceProperties);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPollEvent(
+    XrInstance                                  instance,
+    XrEventDataBuffer*                          eventData);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrResultToString(
+    XrInstance                                  instance,
+    XrResult                                    value,
+    char                                        buffer[XR_MAX_RESULT_STRING_SIZE]);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStructureTypeToString(
+    XrInstance                                  instance,
+    XrStructureType                             value,
+    char                                        buffer[XR_MAX_STRUCTURE_NAME_SIZE]);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSystem(
+    XrInstance                                  instance,
+    const XrSystemGetInfo*                      getInfo,
+    XrSystemId*                                 systemId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSystemProperties(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrSystemProperties*                         properties);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentBlendModes(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrViewConfigurationType                     viewConfigurationType,
+    uint32_t                                    environmentBlendModeCapacityInput,
+    uint32_t*                                   environmentBlendModeCountOutput,
+    XrEnvironmentBlendMode*                     environmentBlendModes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSession(
+    XrInstance                                  instance,
+    const XrSessionCreateInfo*                  createInfo,
+    XrSession*                                  session);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySession(
+    XrSession                                   session);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateReferenceSpaces(
+    XrSession                                   session,
+    uint32_t                                    spaceCapacityInput,
+    uint32_t*                                   spaceCountOutput,
+    XrReferenceSpaceType*                       spaces);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateReferenceSpace(
+    XrSession                                   session,
+    const XrReferenceSpaceCreateInfo*           createInfo,
+    XrSpace*                                    space);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetReferenceSpaceBoundsRect(
+    XrSession                                   session,
+    XrReferenceSpaceType                        referenceSpaceType,
+    XrExtent2Df*                                bounds);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateActionSpace(
+    XrSession                                   session,
+    const XrActionSpaceCreateInfo*              createInfo,
+    XrSpace*                                    space);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateSpace(
+    XrSpace                                     space,
+    XrSpace                                     baseSpace,
+    XrTime                                      time,
+    XrSpaceLocation*                            location);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpace(
+    XrSpace                                     space);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateViewConfigurations(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    viewConfigurationTypeCapacityInput,
+    uint32_t*                                   viewConfigurationTypeCountOutput,
+    XrViewConfigurationType*                    viewConfigurationTypes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetViewConfigurationProperties(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrViewConfigurationType                     viewConfigurationType,
+    XrViewConfigurationProperties*              configurationProperties);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateViewConfigurationViews(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrViewConfigurationType                     viewConfigurationType,
+    uint32_t                                    viewCapacityInput,
+    uint32_t*                                   viewCountOutput,
+    XrViewConfigurationView*                    views);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSwapchainFormats(
+    XrSession                                   session,
+    uint32_t                                    formatCapacityInput,
+    uint32_t*                                   formatCountOutput,
+    int64_t*                                    formats);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSwapchain(
+    XrSession                                   session,
+    const XrSwapchainCreateInfo*                createInfo,
+    XrSwapchain*                                swapchain);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySwapchain(
+    XrSwapchain                                 swapchain);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSwapchainImages(
+    XrSwapchain                                 swapchain,
+    uint32_t                                    imageCapacityInput,
+    uint32_t*                                   imageCountOutput,
+    XrSwapchainImageBaseHeader*                 images);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrAcquireSwapchainImage(
+    XrSwapchain                                 swapchain,
+    const XrSwapchainImageAcquireInfo*          acquireInfo,
+    uint32_t*                                   index);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrWaitSwapchainImage(
+    XrSwapchain                                 swapchain,
+    const XrSwapchainImageWaitInfo*             waitInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrReleaseSwapchainImage(
+    XrSwapchain                                 swapchain,
+    const XrSwapchainImageReleaseInfo*          releaseInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrBeginSession(
+    XrSession                                   session,
+    const XrSessionBeginInfo*                   beginInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEndSession(
+    XrSession                                   session);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestExitSession(
+    XrSession                                   session);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrWaitFrame(
+    XrSession                                   session,
+    const XrFrameWaitInfo*                      frameWaitInfo,
+    XrFrameState*                               frameState);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrBeginFrame(
+    XrSession                                   session,
+    const XrFrameBeginInfo*                     frameBeginInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEndFrame(
+    XrSession                                   session,
+    const XrFrameEndInfo*                       frameEndInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateViews(
+    XrSession                                   session,
+    const XrViewLocateInfo*                     viewLocateInfo,
+    XrViewState*                                viewState,
+    uint32_t                                    viewCapacityInput,
+    uint32_t*                                   viewCountOutput,
+    XrView*                                     views);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStringToPath(
+    XrInstance                                  instance,
+    const char*                                 pathString,
+    XrPath*                                     path);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPathToString(
+    XrInstance                                  instance,
+    XrPath                                      path,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    char*                                       buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateActionSet(
+    XrInstance                                  instance,
+    const XrActionSetCreateInfo*                createInfo,
+    XrActionSet*                                actionSet);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyActionSet(
+    XrActionSet                                 actionSet);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateAction(
+    XrActionSet                                 actionSet,
+    const XrActionCreateInfo*                   createInfo,
+    XrAction*                                   action);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyAction(
+    XrAction                                    action);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSuggestInteractionProfileBindings(
+    XrInstance                                  instance,
+    const XrInteractionProfileSuggestedBinding* suggestedBindings);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrAttachSessionActionSets(
+    XrSession                                   session,
+    const XrSessionActionSetsAttachInfo*        attachInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetCurrentInteractionProfile(
+    XrSession                                   session,
+    XrPath                                      topLevelUserPath,
+    XrInteractionProfileState*                  interactionProfile);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStateBoolean(
+    XrSession                                   session,
+    const XrActionStateGetInfo*                 getInfo,
+    XrActionStateBoolean*                       state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStateFloat(
+    XrSession                                   session,
+    const XrActionStateGetInfo*                 getInfo,
+    XrActionStateFloat*                         state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStateVector2f(
+    XrSession                                   session,
+    const XrActionStateGetInfo*                 getInfo,
+    XrActionStateVector2f*                      state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStatePose(
+    XrSession                                   session,
+    const XrActionStateGetInfo*                 getInfo,
+    XrActionStatePose*                          state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSyncActions(
+    XrSession                                   session,
+    const XrActionsSyncInfo*                    syncInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateBoundSourcesForAction(
+    XrSession                                   session,
+    const XrBoundSourcesForActionEnumerateInfo* enumerateInfo,
+    uint32_t                                    sourceCapacityInput,
+    uint32_t*                                   sourceCountOutput,
+    XrPath*                                     sources);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetInputSourceLocalizedName(
+    XrSession                                   session,
+    const XrInputSourceLocalizedNameGetInfo*    getInfo,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    char*                                       buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrApplyHapticFeedback(
+    XrSession                                   session,
+    const XrHapticActionInfo*                   hapticActionInfo,
+    const XrHapticBaseHeader*                   hapticFeedback);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStopHapticFeedback(
+    XrSession                                   session,
+    const XrHapticActionInfo*                   hapticActionInfo);
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_VERSION_1_1 is a preprocessor guard. Do not pass it to API calls.
+#define XR_VERSION_1_1 1
+// OpenXR 1.1 version number
+#define XR_API_VERSION_1_1 XR_MAKE_VERSION(1, 1, XR_VERSION_PATCH(XR_CURRENT_API_VERSION))
+
+#define XR_UUID_SIZE                      16
+typedef struct XrColor3f {
+    float    r;
+    float    g;
+    float    b;
+} XrColor3f;
+
+typedef struct XrExtent3Df {
+    float    width;
+    float    height;
+    float    depth;
+} XrExtent3Df;
+
+typedef struct XrSpheref {
+    XrPosef    center;
+    float      radius;
+} XrSpheref;
+
+typedef struct XrBoxf {
+    XrPosef        center;
+    XrExtent3Df    extents;
+} XrBoxf;
+
+typedef struct XrFrustumf {
+    XrPosef    pose;
+    XrFovf     fov;
+    float      nearZ;
+    float      farZ;
+} XrFrustumf;
+
+typedef struct XrUuid {
+    uint8_t    data[XR_UUID_SIZE];
+} XrUuid;
+
+typedef struct XrSpacesLocateInfo {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+    uint32_t                    spaceCount;
+    const XrSpace*              spaces;
+} XrSpacesLocateInfo;
+
+typedef struct XrSpaceLocationData {
+    XrSpaceLocationFlags    locationFlags;
+    XrPosef                 pose;
+} XrSpaceLocationData;
+
+typedef struct XrSpaceLocations {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    uint32_t                locationCount;
+    XrSpaceLocationData*    locations;
+} XrSpaceLocations;
+
+typedef struct XrSpaceVelocityData {
+    XrSpaceVelocityFlags    velocityFlags;
+    XrVector3f              linearVelocity;
+    XrVector3f              angularVelocity;
+} XrSpaceVelocityData;
+
+// XrSpaceVelocities extends XrSpaceLocations
+typedef struct XrSpaceVelocities {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    uint32_t                velocityCount;
+    XrSpaceVelocityData*    velocities;
+} XrSpaceVelocities;
+
+typedef XrResult (XRAPI_PTR *PFN_xrLocateSpaces)(XrSession session, const XrSpacesLocateInfo* locateInfo, XrSpaceLocations* spaceLocations);
+
+#ifndef XR_NO_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateSpaces(
+    XrSession                                   session,
+    const XrSpacesLocateInfo*                   locateInfo,
+    XrSpaceLocations*                           spaceLocations);
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_KHR_composition_layer_cube is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_composition_layer_cube 1
+#define XR_KHR_composition_layer_cube_SPEC_VERSION 8
+#define XR_KHR_COMPOSITION_LAYER_CUBE_EXTENSION_NAME "XR_KHR_composition_layer_cube"
+typedef struct XrCompositionLayerCubeKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCompositionLayerFlags     layerFlags;
+    XrSpace                     space;
+    XrEyeVisibility             eyeVisibility;
+    XrSwapchain                 swapchain;
+    uint32_t                    imageArrayIndex;
+    XrQuaternionf               orientation;
+} XrCompositionLayerCubeKHR;
+
+
+
+// XR_KHR_composition_layer_depth is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_composition_layer_depth 1
+#define XR_KHR_composition_layer_depth_SPEC_VERSION 6
+#define XR_KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME "XR_KHR_composition_layer_depth"
+// XrCompositionLayerDepthInfoKHR extends XrCompositionLayerProjectionView
+typedef struct XrCompositionLayerDepthInfoKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSwapchainSubImage         subImage;
+    float                       minDepth;
+    float                       maxDepth;
+    float                       nearZ;
+    float                       farZ;
+} XrCompositionLayerDepthInfoKHR;
+
+
+
+// XR_KHR_composition_layer_cylinder is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_composition_layer_cylinder 1
+#define XR_KHR_composition_layer_cylinder_SPEC_VERSION 4
+#define XR_KHR_COMPOSITION_LAYER_CYLINDER_EXTENSION_NAME "XR_KHR_composition_layer_cylinder"
+typedef struct XrCompositionLayerCylinderKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCompositionLayerFlags     layerFlags;
+    XrSpace                     space;
+    XrEyeVisibility             eyeVisibility;
+    XrSwapchainSubImage         subImage;
+    XrPosef                     pose;
+    float                       radius;
+    float                       centralAngle;
+    float                       aspectRatio;
+} XrCompositionLayerCylinderKHR;
+
+
+
+// XR_KHR_composition_layer_equirect is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_composition_layer_equirect 1
+#define XR_KHR_composition_layer_equirect_SPEC_VERSION 3
+#define XR_KHR_COMPOSITION_LAYER_EQUIRECT_EXTENSION_NAME "XR_KHR_composition_layer_equirect"
+typedef struct XrCompositionLayerEquirectKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCompositionLayerFlags     layerFlags;
+    XrSpace                     space;
+    XrEyeVisibility             eyeVisibility;
+    XrSwapchainSubImage         subImage;
+    XrPosef                     pose;
+    float                       radius;
+    XrVector2f                  scale;
+    XrVector2f                  bias;
+} XrCompositionLayerEquirectKHR;
+
+
+
+// XR_KHR_visibility_mask is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_visibility_mask 1
+#define XR_KHR_visibility_mask_SPEC_VERSION 2
+#define XR_KHR_VISIBILITY_MASK_EXTENSION_NAME "XR_KHR_visibility_mask"
+
+typedef enum XrVisibilityMaskTypeKHR {
+    XR_VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR = 1,
+    XR_VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR = 2,
+    XR_VISIBILITY_MASK_TYPE_LINE_LOOP_KHR = 3,
+    XR_VISIBILITY_MASK_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} XrVisibilityMaskTypeKHR;
+typedef struct XrVisibilityMaskKHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              vertexCapacityInput;
+    uint32_t              vertexCountOutput;
+    XrVector2f*           vertices;
+    uint32_t              indexCapacityInput;
+    uint32_t              indexCountOutput;
+    uint32_t*             indices;
+} XrVisibilityMaskKHR;
+
+typedef struct XrEventDataVisibilityMaskChangedKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSession                   session;
+    XrViewConfigurationType     viewConfigurationType;
+    uint32_t                    viewIndex;
+} XrEventDataVisibilityMaskChangedKHR;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetVisibilityMaskKHR)(XrSession session, XrViewConfigurationType viewConfigurationType, uint32_t viewIndex, XrVisibilityMaskTypeKHR visibilityMaskType, XrVisibilityMaskKHR* visibilityMask);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVisibilityMaskKHR(
+    XrSession                                   session,
+    XrViewConfigurationType                     viewConfigurationType,
+    uint32_t                                    viewIndex,
+    XrVisibilityMaskTypeKHR                     visibilityMaskType,
+    XrVisibilityMaskKHR*                        visibilityMask);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_KHR_composition_layer_color_scale_bias is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_composition_layer_color_scale_bias 1
+#define XR_KHR_composition_layer_color_scale_bias_SPEC_VERSION 5
+#define XR_KHR_COMPOSITION_LAYER_COLOR_SCALE_BIAS_EXTENSION_NAME "XR_KHR_composition_layer_color_scale_bias"
+// XrCompositionLayerColorScaleBiasKHR extends XrCompositionLayerBaseHeader
+typedef struct XrCompositionLayerColorScaleBiasKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrColor4f                   colorScale;
+    XrColor4f                   colorBias;
+} XrCompositionLayerColorScaleBiasKHR;
+
+
+
+// XR_KHR_loader_init is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_loader_init 1
+#define XR_KHR_loader_init_SPEC_VERSION   2
+#define XR_KHR_LOADER_INIT_EXTENSION_NAME "XR_KHR_loader_init"
+typedef struct XR_MAY_ALIAS XrLoaderInitInfoBaseHeaderKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrLoaderInitInfoBaseHeaderKHR;
+
+typedef XrResult (XRAPI_PTR *PFN_xrInitializeLoaderKHR)(const XrLoaderInitInfoBaseHeaderKHR* loaderInitInfo);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrInitializeLoaderKHR(
+    const XrLoaderInitInfoBaseHeaderKHR*        loaderInitInfo);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_KHR_composition_layer_equirect2 is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_composition_layer_equirect2 1
+#define XR_KHR_composition_layer_equirect2_SPEC_VERSION 1
+#define XR_KHR_COMPOSITION_LAYER_EQUIRECT2_EXTENSION_NAME "XR_KHR_composition_layer_equirect2"
+typedef struct XrCompositionLayerEquirect2KHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCompositionLayerFlags     layerFlags;
+    XrSpace                     space;
+    XrEyeVisibility             eyeVisibility;
+    XrSwapchainSubImage         subImage;
+    XrPosef                     pose;
+    float                       radius;
+    float                       centralHorizontalAngle;
+    float                       upperVerticalAngle;
+    float                       lowerVerticalAngle;
+} XrCompositionLayerEquirect2KHR;
+
+
+
+// XR_KHR_binding_modification is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_binding_modification 1
+#define XR_KHR_binding_modification_SPEC_VERSION 1
+#define XR_KHR_BINDING_MODIFICATION_EXTENSION_NAME "XR_KHR_binding_modification"
+typedef struct XR_MAY_ALIAS XrBindingModificationBaseHeaderKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrBindingModificationBaseHeaderKHR;
+
+// XrBindingModificationsKHR extends XrInteractionProfileSuggestedBinding
+typedef struct XrBindingModificationsKHR {
+    XrStructureType                                     type;
+    const void* XR_MAY_ALIAS                            next;
+    uint32_t                                            bindingModificationCount;
+    const XrBindingModificationBaseHeaderKHR* const*    bindingModifications;
+} XrBindingModificationsKHR;
+
+
+
+// XR_KHR_extended_struct_name_lengths is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_extended_struct_name_lengths 1
+#define XR_KHR_extended_struct_name_lengths_SPEC_VERSION 2
+#define XR_KHR_EXTENDED_STRUCT_NAME_LENGTHS_EXTENSION_NAME "XR_KHR_extended_struct_name_lengths"
+#define XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR 256
+typedef XrResult (XRAPI_PTR *PFN_xrStructureTypeToString2KHR)(XrInstance instance, XrStructureType value, char buffer[XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR]);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrStructureTypeToString2KHR(
+    XrInstance                                  instance,
+    XrStructureType                             value,
+    char                                        buffer[XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR]);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_KHR_swapchain_usage_input_attachment_bit is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_swapchain_usage_input_attachment_bit 1
+#define XR_KHR_swapchain_usage_input_attachment_bit_SPEC_VERSION 3
+#define XR_KHR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME "XR_KHR_swapchain_usage_input_attachment_bit"
+
+
+// XR_KHR_locate_spaces is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_locate_spaces 1
+#define XR_KHR_locate_spaces_SPEC_VERSION 1
+#define XR_KHR_LOCATE_SPACES_EXTENSION_NAME "XR_KHR_locate_spaces"
+typedef XrSpacesLocateInfo XrSpacesLocateInfoKHR;
+
+typedef XrSpaceLocationData XrSpaceLocationDataKHR;
+
+typedef XrSpaceLocations XrSpaceLocationsKHR;
+
+typedef XrSpaceVelocityData XrSpaceVelocityDataKHR;
+
+typedef XrSpaceVelocities XrSpaceVelocitiesKHR;
+
+typedef XrResult (XRAPI_PTR *PFN_xrLocateSpacesKHR)(XrSession session, const XrSpacesLocateInfo* locateInfo, XrSpaceLocations* spaceLocations);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateSpacesKHR(
+    XrSession                                   session,
+    const XrSpacesLocateInfo*                   locateInfo,
+    XrSpaceLocations*                           spaceLocations);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_KHR_maintenance1 is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_maintenance1 1
+#define XR_KHR_maintenance1_SPEC_VERSION  1
+#define XR_KHR_MAINTENANCE1_EXTENSION_NAME "XR_KHR_maintenance1"
+typedef XrColor3f XrColor3fKHR;
+
+typedef XrExtent3Df XrExtent3DfKHR;
+
+typedef XrSpheref XrSpherefKHR;
+
+typedef XrBoxf XrBoxfKHR;
+
+typedef XrFrustumf XrFrustumfKHR;
+
+
+
+// XR_KHR_generic_controller is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_generic_controller 1
+#define XR_KHR_generic_controller_SPEC_VERSION 1
+#define XR_KHR_GENERIC_CONTROLLER_EXTENSION_NAME "XR_KHR_generic_controller"
+
+
+// XR_KHR_extended_result_name_lengths is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_extended_result_name_lengths 1
+#define XR_KHR_extended_result_name_lengths_SPEC_VERSION 1
+#define XR_KHR_EXTENDED_RESULT_NAME_LENGTHS_EXTENSION_NAME "XR_KHR_extended_result_name_lengths"
+#define XR_MAX_RESULT_STRING_SIZE_EXTENDED_KHR 256
+typedef XrResult (XRAPI_PTR *PFN_xrResultToString2KHR)(XrInstance instance, XrResult value, char buffer[XR_MAX_RESULT_STRING_SIZE_EXTENDED_KHR]);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrResultToString2KHR(
+    XrInstance                                  instance,
+    XrResult                                    value,
+    char                                        buffer[XR_MAX_RESULT_STRING_SIZE_EXTENDED_KHR]);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_performance_settings is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_performance_settings 1
+#define XR_EXT_performance_settings_SPEC_VERSION 4
+#define XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME "XR_EXT_performance_settings"
+
+typedef enum XrPerfSettingsDomainEXT {
+    XR_PERF_SETTINGS_DOMAIN_CPU_EXT = 1,
+    XR_PERF_SETTINGS_DOMAIN_GPU_EXT = 2,
+    XR_PERF_SETTINGS_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrPerfSettingsDomainEXT;
+
+typedef enum XrPerfSettingsSubDomainEXT {
+    XR_PERF_SETTINGS_SUB_DOMAIN_COMPOSITING_EXT = 1,
+    XR_PERF_SETTINGS_SUB_DOMAIN_RENDERING_EXT = 2,
+    XR_PERF_SETTINGS_SUB_DOMAIN_THERMAL_EXT = 3,
+    XR_PERF_SETTINGS_SUB_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrPerfSettingsSubDomainEXT;
+
+typedef enum XrPerfSettingsLevelEXT {
+    XR_PERF_SETTINGS_LEVEL_POWER_SAVINGS_EXT = 0,
+    XR_PERF_SETTINGS_LEVEL_SUSTAINED_LOW_EXT = 25,
+    XR_PERF_SETTINGS_LEVEL_SUSTAINED_HIGH_EXT = 50,
+    XR_PERF_SETTINGS_LEVEL_BOOST_EXT = 75,
+    XR_PERF_SETTINGS_LEVEL_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrPerfSettingsLevelEXT;
+
+typedef enum XrPerfSettingsNotificationLevelEXT {
+    XR_PERF_SETTINGS_NOTIF_LEVEL_NORMAL_EXT = 0,
+    XR_PERF_SETTINGS_NOTIF_LEVEL_WARNING_EXT = 25,
+    XR_PERF_SETTINGS_NOTIF_LEVEL_IMPAIRED_EXT = 75,
+    XR_PERF_SETTINGS_NOTIFICATION_LEVEL_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrPerfSettingsNotificationLevelEXT;
+typedef struct XrEventDataPerfSettingsEXT {
+    XrStructureType                       type;
+    const void* XR_MAY_ALIAS              next;
+    XrPerfSettingsDomainEXT               domain;
+    XrPerfSettingsSubDomainEXT            subDomain;
+    XrPerfSettingsNotificationLevelEXT    fromLevel;
+    XrPerfSettingsNotificationLevelEXT    toLevel;
+} XrEventDataPerfSettingsEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrPerfSettingsSetPerformanceLevelEXT)(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsLevelEXT level);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrPerfSettingsSetPerformanceLevelEXT(
+    XrSession                                   session,
+    XrPerfSettingsDomainEXT                     domain,
+    XrPerfSettingsLevelEXT                      level);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_thermal_query is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_thermal_query 1
+#define XR_EXT_thermal_query_SPEC_VERSION 2
+#define XR_EXT_THERMAL_QUERY_EXTENSION_NAME "XR_EXT_thermal_query"
+typedef XrResult (XRAPI_PTR *PFN_xrThermalGetTemperatureTrendEXT)(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsNotificationLevelEXT* notificationLevel, float* tempHeadroom, float* tempSlope);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrThermalGetTemperatureTrendEXT(
+    XrSession                                   session,
+    XrPerfSettingsDomainEXT                     domain,
+    XrPerfSettingsNotificationLevelEXT*         notificationLevel,
+    float*                                      tempHeadroom,
+    float*                                      tempSlope);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_debug_utils is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_debug_utils 1
+XR_DEFINE_HANDLE(XrDebugUtilsMessengerEXT)
+#define XR_EXT_debug_utils_SPEC_VERSION   5
+#define XR_EXT_DEBUG_UTILS_EXTENSION_NAME "XR_EXT_debug_utils"
+typedef XrFlags64 XrDebugUtilsMessageSeverityFlagsEXT;
+
+// Flag bits for XrDebugUtilsMessageSeverityFlagsEXT
+static const XrDebugUtilsMessageSeverityFlagsEXT XR_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001;
+static const XrDebugUtilsMessageSeverityFlagsEXT XR_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010;
+static const XrDebugUtilsMessageSeverityFlagsEXT XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100;
+static const XrDebugUtilsMessageSeverityFlagsEXT XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000;
+
+typedef XrFlags64 XrDebugUtilsMessageTypeFlagsEXT;
+
+// Flag bits for XrDebugUtilsMessageTypeFlagsEXT
+static const XrDebugUtilsMessageTypeFlagsEXT XR_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001;
+static const XrDebugUtilsMessageTypeFlagsEXT XR_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002;
+static const XrDebugUtilsMessageTypeFlagsEXT XR_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004;
+static const XrDebugUtilsMessageTypeFlagsEXT XR_DEBUG_UTILS_MESSAGE_TYPE_CONFORMANCE_BIT_EXT = 0x00000008;
+
+typedef struct XrDebugUtilsObjectNameInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrObjectType                objectType;
+    uint64_t                    objectHandle;
+    const char*                 objectName;
+} XrDebugUtilsObjectNameInfoEXT;
+
+typedef struct XrDebugUtilsLabelEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    const char*                 labelName;
+} XrDebugUtilsLabelEXT;
+
+typedef struct XrDebugUtilsMessengerCallbackDataEXT {
+    XrStructureType                   type;
+    const void* XR_MAY_ALIAS          next;
+    const char*                       messageId;
+    const char*                       functionName;
+    const char*                       message;
+    uint32_t                          objectCount;
+    XrDebugUtilsObjectNameInfoEXT*    objects;
+    uint32_t                          sessionLabelCount;
+    XrDebugUtilsLabelEXT*             sessionLabels;
+} XrDebugUtilsMessengerCallbackDataEXT;
+
+typedef XrBool32 (XRAPI_PTR *PFN_xrDebugUtilsMessengerCallbackEXT)(
+            XrDebugUtilsMessageSeverityFlagsEXT              messageSeverity,
+            XrDebugUtilsMessageTypeFlagsEXT                  messageTypes,
+            const XrDebugUtilsMessengerCallbackDataEXT*      callbackData,
+            void*                                            userData);
+        
+
+// XrDebugUtilsMessengerCreateInfoEXT extends XrInstanceCreateInfo
+typedef struct XrDebugUtilsMessengerCreateInfoEXT {
+    XrStructureType                         type;
+    const void* XR_MAY_ALIAS                next;
+    XrDebugUtilsMessageSeverityFlagsEXT     messageSeverities;
+    XrDebugUtilsMessageTypeFlagsEXT         messageTypes;
+    PFN_xrDebugUtilsMessengerCallbackEXT    userCallback;
+    void* XR_MAY_ALIAS                      userData;
+} XrDebugUtilsMessengerCreateInfoEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSetDebugUtilsObjectNameEXT)(XrInstance instance, const XrDebugUtilsObjectNameInfoEXT* nameInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateDebugUtilsMessengerEXT)(XrInstance instance, const XrDebugUtilsMessengerCreateInfoEXT* createInfo, XrDebugUtilsMessengerEXT* messenger);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyDebugUtilsMessengerEXT)(XrDebugUtilsMessengerEXT messenger);
+typedef XrResult (XRAPI_PTR *PFN_xrSubmitDebugUtilsMessageEXT)(XrInstance instance, XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, XrDebugUtilsMessageTypeFlagsEXT messageTypes, const XrDebugUtilsMessengerCallbackDataEXT* callbackData);
+typedef XrResult (XRAPI_PTR *PFN_xrSessionBeginDebugUtilsLabelRegionEXT)(XrSession session, const XrDebugUtilsLabelEXT* labelInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrSessionEndDebugUtilsLabelRegionEXT)(XrSession session);
+typedef XrResult (XRAPI_PTR *PFN_xrSessionInsertDebugUtilsLabelEXT)(XrSession session, const XrDebugUtilsLabelEXT* labelInfo);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetDebugUtilsObjectNameEXT(
+    XrInstance                                  instance,
+    const XrDebugUtilsObjectNameInfoEXT*        nameInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateDebugUtilsMessengerEXT(
+    XrInstance                                  instance,
+    const XrDebugUtilsMessengerCreateInfoEXT*   createInfo,
+    XrDebugUtilsMessengerEXT*                   messenger);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyDebugUtilsMessengerEXT(
+    XrDebugUtilsMessengerEXT                    messenger);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSubmitDebugUtilsMessageEXT(
+    XrInstance                                  instance,
+    XrDebugUtilsMessageSeverityFlagsEXT         messageSeverity,
+    XrDebugUtilsMessageTypeFlagsEXT             messageTypes,
+    const XrDebugUtilsMessengerCallbackDataEXT* callbackData);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSessionBeginDebugUtilsLabelRegionEXT(
+    XrSession                                   session,
+    const XrDebugUtilsLabelEXT*                 labelInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSessionEndDebugUtilsLabelRegionEXT(
+    XrSession                                   session);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSessionInsertDebugUtilsLabelEXT(
+    XrSession                                   session,
+    const XrDebugUtilsLabelEXT*                 labelInfo);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_eye_gaze_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_eye_gaze_interaction 1
+#define XR_EXT_eye_gaze_interaction_SPEC_VERSION 2
+#define XR_EXT_EYE_GAZE_INTERACTION_EXTENSION_NAME "XR_EXT_eye_gaze_interaction"
+// XrSystemEyeGazeInteractionPropertiesEXT extends XrSystemProperties
+typedef struct XrSystemEyeGazeInteractionPropertiesEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsEyeGazeInteraction;
+} XrSystemEyeGazeInteractionPropertiesEXT;
+
+// XrEyeGazeSampleTimeEXT extends XrSpaceLocation
+typedef struct XrEyeGazeSampleTimeEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrTime                time;
+} XrEyeGazeSampleTimeEXT;
+
+
+
+// XR_EXTX_overlay is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXTX_overlay 1
+#define XR_EXTX_overlay_SPEC_VERSION      5
+#define XR_EXTX_OVERLAY_EXTENSION_NAME    "XR_EXTX_overlay"
+typedef XrFlags64 XrOverlaySessionCreateFlagsEXTX;
+
+// Flag bits for XrOverlaySessionCreateFlagsEXTX
+
+typedef XrFlags64 XrOverlayMainSessionFlagsEXTX;
+
+// Flag bits for XrOverlayMainSessionFlagsEXTX
+static const XrOverlayMainSessionFlagsEXTX XR_OVERLAY_MAIN_SESSION_ENABLED_COMPOSITION_LAYER_INFO_DEPTH_BIT_EXTX = 0x00000001;
+
+// XrSessionCreateInfoOverlayEXTX extends XrSessionCreateInfo
+typedef struct XrSessionCreateInfoOverlayEXTX {
+    XrStructureType                    type;
+    const void* XR_MAY_ALIAS           next;
+    XrOverlaySessionCreateFlagsEXTX    createFlags;
+    uint32_t                           sessionLayersPlacement;
+} XrSessionCreateInfoOverlayEXTX;
+
+typedef struct XrEventDataMainSessionVisibilityChangedEXTX {
+    XrStructureType                  type;
+    const void* XR_MAY_ALIAS         next;
+    XrBool32                         visible;
+    XrOverlayMainSessionFlagsEXTX    flags;
+} XrEventDataMainSessionVisibilityChangedEXTX;
+
+
+
+// XR_VARJO_quad_views is a preprocessor guard. Do not pass it to API calls.
+#define XR_VARJO_quad_views 1
+#define XR_VARJO_quad_views_SPEC_VERSION  2
+#define XR_VARJO_QUAD_VIEWS_EXTENSION_NAME "XR_VARJO_quad_views"
+
+
+// XR_MSFT_unbounded_reference_space is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_unbounded_reference_space 1
+#define XR_MSFT_unbounded_reference_space_SPEC_VERSION 1
+#define XR_MSFT_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME "XR_MSFT_unbounded_reference_space"
+
+
+// XR_MSFT_spatial_anchor is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_spatial_anchor 1
+XR_DEFINE_HANDLE(XrSpatialAnchorMSFT)
+#define XR_MSFT_spatial_anchor_SPEC_VERSION 2
+#define XR_MSFT_SPATIAL_ANCHOR_EXTENSION_NAME "XR_MSFT_spatial_anchor"
+typedef struct XrSpatialAnchorCreateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrPosef                     pose;
+    XrTime                      time;
+} XrSpatialAnchorCreateInfoMSFT;
+
+typedef struct XrSpatialAnchorSpaceCreateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialAnchorMSFT         anchor;
+    XrPosef                     poseInAnchorSpace;
+} XrSpatialAnchorSpaceCreateInfoMSFT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorMSFT)(XrSession session, const XrSpatialAnchorCreateInfoMSFT* createInfo, XrSpatialAnchorMSFT* anchor);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorSpaceMSFT)(XrSession session, const XrSpatialAnchorSpaceCreateInfoMSFT* createInfo, XrSpace* space);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorMSFT)(XrSpatialAnchorMSFT anchor);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorMSFT(
+    XrSession                                   session,
+    const XrSpatialAnchorCreateInfoMSFT*        createInfo,
+    XrSpatialAnchorMSFT*                        anchor);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorSpaceMSFT(
+    XrSession                                   session,
+    const XrSpatialAnchorSpaceCreateInfoMSFT*   createInfo,
+    XrSpace*                                    space);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialAnchorMSFT(
+    XrSpatialAnchorMSFT                         anchor);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_composition_layer_image_layout is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_composition_layer_image_layout 1
+#define XR_FB_composition_layer_image_layout_SPEC_VERSION 1
+#define XR_FB_COMPOSITION_LAYER_IMAGE_LAYOUT_EXTENSION_NAME "XR_FB_composition_layer_image_layout"
+typedef XrFlags64 XrCompositionLayerImageLayoutFlagsFB;
+
+// Flag bits for XrCompositionLayerImageLayoutFlagsFB
+static const XrCompositionLayerImageLayoutFlagsFB XR_COMPOSITION_LAYER_IMAGE_LAYOUT_VERTICAL_FLIP_BIT_FB = 0x00000001;
+
+// XrCompositionLayerImageLayoutFB extends XrCompositionLayerBaseHeader
+typedef struct XrCompositionLayerImageLayoutFB {
+    XrStructureType                         type;
+    void* XR_MAY_ALIAS                      next;
+    XrCompositionLayerImageLayoutFlagsFB    flags;
+} XrCompositionLayerImageLayoutFB;
+
+
+
+// XR_FB_composition_layer_alpha_blend is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_composition_layer_alpha_blend 1
+#define XR_FB_composition_layer_alpha_blend_SPEC_VERSION 3
+#define XR_FB_COMPOSITION_LAYER_ALPHA_BLEND_EXTENSION_NAME "XR_FB_composition_layer_alpha_blend"
+
+typedef enum XrBlendFactorFB {
+    XR_BLEND_FACTOR_ZERO_FB = 0,
+    XR_BLEND_FACTOR_ONE_FB = 1,
+    XR_BLEND_FACTOR_SRC_ALPHA_FB = 2,
+    XR_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA_FB = 3,
+    XR_BLEND_FACTOR_DST_ALPHA_FB = 4,
+    XR_BLEND_FACTOR_ONE_MINUS_DST_ALPHA_FB = 5,
+    XR_BLEND_FACTOR_MAX_ENUM_FB = 0x7FFFFFFF
+} XrBlendFactorFB;
+typedef XrFlags64 XrCompositionLayerSecureContentFlagsFB;
+
+// Flag bits for XrCompositionLayerSecureContentFlagsFB
+static const XrCompositionLayerSecureContentFlagsFB XR_COMPOSITION_LAYER_SECURE_CONTENT_EXCLUDE_LAYER_BIT_FB = 0x00000001;
+static const XrCompositionLayerSecureContentFlagsFB XR_COMPOSITION_LAYER_SECURE_CONTENT_REPLACE_LAYER_BIT_FB = 0x00000002;
+
+// XrCompositionLayerAlphaBlendFB extends XrCompositionLayerBaseHeader
+typedef struct XrCompositionLayerAlphaBlendFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBlendFactorFB       srcFactorColor;
+    XrBlendFactorFB       dstFactorColor;
+    XrBlendFactorFB       srcFactorAlpha;
+    XrBlendFactorFB       dstFactorAlpha;
+} XrCompositionLayerAlphaBlendFB;
+
+
+
+// XR_MND_headless is a preprocessor guard. Do not pass it to API calls.
+#define XR_MND_headless 1
+#define XR_MND_headless_SPEC_VERSION      3
+#define XR_MND_HEADLESS_EXTENSION_NAME    "XR_MND_headless"
+
+
+// XR_OCULUS_android_session_state_enable is a preprocessor guard. Do not pass it to API calls.
+#define XR_OCULUS_android_session_state_enable 1
+#define XR_OCULUS_android_session_state_enable_SPEC_VERSION 1
+#define XR_OCULUS_ANDROID_SESSION_STATE_ENABLE_EXTENSION_NAME "XR_OCULUS_android_session_state_enable"
+
+
+// XR_EXT_view_configuration_depth_range is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_view_configuration_depth_range 1
+#define XR_EXT_view_configuration_depth_range_SPEC_VERSION 1
+#define XR_EXT_VIEW_CONFIGURATION_DEPTH_RANGE_EXTENSION_NAME "XR_EXT_view_configuration_depth_range"
+// XrViewConfigurationDepthRangeEXT extends XrViewConfigurationView
+typedef struct XrViewConfigurationDepthRangeEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    float                 recommendedNearZ;
+    float                 minNearZ;
+    float                 recommendedFarZ;
+    float                 maxFarZ;
+} XrViewConfigurationDepthRangeEXT;
+
+
+
+// XR_EXT_conformance_automation is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_conformance_automation 1
+#define XR_EXT_conformance_automation_SPEC_VERSION 3
+#define XR_EXT_CONFORMANCE_AUTOMATION_EXTENSION_NAME "XR_EXT_conformance_automation"
+typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceActiveEXT)(XrSession session, XrPath interactionProfile, XrPath topLevelPath, XrBool32 isActive);
+typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceStateBoolEXT)(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrBool32 state);
+typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceStateFloatEXT)(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, float state);
+typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceStateVector2fEXT)(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrVector2f state);
+typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceLocationEXT)(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrSpace space, XrPosef pose);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceActiveEXT(
+    XrSession                                   session,
+    XrPath                                      interactionProfile,
+    XrPath                                      topLevelPath,
+    XrBool32                                    isActive);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceStateBoolEXT(
+    XrSession                                   session,
+    XrPath                                      topLevelPath,
+    XrPath                                      inputSourcePath,
+    XrBool32                                    state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceStateFloatEXT(
+    XrSession                                   session,
+    XrPath                                      topLevelPath,
+    XrPath                                      inputSourcePath,
+    float                                       state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceStateVector2fEXT(
+    XrSession                                   session,
+    XrPath                                      topLevelPath,
+    XrPath                                      inputSourcePath,
+    XrVector2f                                  state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetInputDeviceLocationEXT(
+    XrSession                                   session,
+    XrPath                                      topLevelPath,
+    XrPath                                      inputSourcePath,
+    XrSpace                                     space,
+    XrPosef                                     pose);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_MSFT_spatial_graph_bridge is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_spatial_graph_bridge 1
+XR_DEFINE_HANDLE(XrSpatialGraphNodeBindingMSFT)
+#define XR_GUID_SIZE_MSFT                 16
+#define XR_MSFT_spatial_graph_bridge_SPEC_VERSION 2
+#define XR_MSFT_SPATIAL_GRAPH_BRIDGE_EXTENSION_NAME "XR_MSFT_spatial_graph_bridge"
+
+typedef enum XrSpatialGraphNodeTypeMSFT {
+    XR_SPATIAL_GRAPH_NODE_TYPE_STATIC_MSFT = 1,
+    XR_SPATIAL_GRAPH_NODE_TYPE_DYNAMIC_MSFT = 2,
+    XR_SPATIAL_GRAPH_NODE_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrSpatialGraphNodeTypeMSFT;
+typedef struct XrSpatialGraphNodeSpaceCreateInfoMSFT {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrSpatialGraphNodeTypeMSFT    nodeType;
+    uint8_t                       nodeId[XR_GUID_SIZE_MSFT];
+    XrPosef                       pose;
+} XrSpatialGraphNodeSpaceCreateInfoMSFT;
+
+typedef struct XrSpatialGraphStaticNodeBindingCreateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrPosef                     poseInSpace;
+    XrTime                      time;
+} XrSpatialGraphStaticNodeBindingCreateInfoMSFT;
+
+typedef struct XrSpatialGraphNodeBindingPropertiesGetInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpatialGraphNodeBindingPropertiesGetInfoMSFT;
+
+typedef struct XrSpatialGraphNodeBindingPropertiesMSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint8_t               nodeId[XR_GUID_SIZE_MSFT];
+    XrPosef               poseInNodeSpace;
+} XrSpatialGraphNodeBindingPropertiesMSFT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialGraphNodeSpaceMSFT)(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT* createInfo, XrSpace* space);
+typedef XrResult (XRAPI_PTR *PFN_xrTryCreateSpatialGraphStaticNodeBindingMSFT)(XrSession session, const XrSpatialGraphStaticNodeBindingCreateInfoMSFT* createInfo, XrSpatialGraphNodeBindingMSFT* nodeBinding);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialGraphNodeBindingMSFT)(XrSpatialGraphNodeBindingMSFT nodeBinding);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialGraphNodeBindingPropertiesMSFT)(XrSpatialGraphNodeBindingMSFT nodeBinding, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT* getInfo, XrSpatialGraphNodeBindingPropertiesMSFT* properties);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialGraphNodeSpaceMSFT(
+    XrSession                                   session,
+    const XrSpatialGraphNodeSpaceCreateInfoMSFT* createInfo,
+    XrSpace*                                    space);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrTryCreateSpatialGraphStaticNodeBindingMSFT(
+    XrSession                                   session,
+    const XrSpatialGraphStaticNodeBindingCreateInfoMSFT* createInfo,
+    XrSpatialGraphNodeBindingMSFT*              nodeBinding);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialGraphNodeBindingMSFT(
+    XrSpatialGraphNodeBindingMSFT               nodeBinding);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialGraphNodeBindingPropertiesMSFT(
+    XrSpatialGraphNodeBindingMSFT               nodeBinding,
+    const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT* getInfo,
+    XrSpatialGraphNodeBindingPropertiesMSFT*    properties);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_MSFT_hand_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_hand_interaction 1
+#define XR_MSFT_hand_interaction_SPEC_VERSION 1
+#define XR_MSFT_HAND_INTERACTION_EXTENSION_NAME "XR_MSFT_hand_interaction"
+
+
+// XR_EXT_hand_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_hand_tracking 1
+
+#define XR_HAND_JOINT_COUNT_EXT 26
+
+XR_DEFINE_HANDLE(XrHandTrackerEXT)
+#define XR_EXT_hand_tracking_SPEC_VERSION 4
+#define XR_EXT_HAND_TRACKING_EXTENSION_NAME "XR_EXT_hand_tracking"
+
+typedef enum XrHandEXT {
+    XR_HAND_LEFT_EXT = 1,
+    XR_HAND_RIGHT_EXT = 2,
+    XR_HAND_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrHandEXT;
+
+typedef enum XrHandJointEXT {
+    XR_HAND_JOINT_PALM_EXT = 0,
+    XR_HAND_JOINT_WRIST_EXT = 1,
+    XR_HAND_JOINT_THUMB_METACARPAL_EXT = 2,
+    XR_HAND_JOINT_THUMB_PROXIMAL_EXT = 3,
+    XR_HAND_JOINT_THUMB_DISTAL_EXT = 4,
+    XR_HAND_JOINT_THUMB_TIP_EXT = 5,
+    XR_HAND_JOINT_INDEX_METACARPAL_EXT = 6,
+    XR_HAND_JOINT_INDEX_PROXIMAL_EXT = 7,
+    XR_HAND_JOINT_INDEX_INTERMEDIATE_EXT = 8,
+    XR_HAND_JOINT_INDEX_DISTAL_EXT = 9,
+    XR_HAND_JOINT_INDEX_TIP_EXT = 10,
+    XR_HAND_JOINT_MIDDLE_METACARPAL_EXT = 11,
+    XR_HAND_JOINT_MIDDLE_PROXIMAL_EXT = 12,
+    XR_HAND_JOINT_MIDDLE_INTERMEDIATE_EXT = 13,
+    XR_HAND_JOINT_MIDDLE_DISTAL_EXT = 14,
+    XR_HAND_JOINT_MIDDLE_TIP_EXT = 15,
+    XR_HAND_JOINT_RING_METACARPAL_EXT = 16,
+    XR_HAND_JOINT_RING_PROXIMAL_EXT = 17,
+    XR_HAND_JOINT_RING_INTERMEDIATE_EXT = 18,
+    XR_HAND_JOINT_RING_DISTAL_EXT = 19,
+    XR_HAND_JOINT_RING_TIP_EXT = 20,
+    XR_HAND_JOINT_LITTLE_METACARPAL_EXT = 21,
+    XR_HAND_JOINT_LITTLE_PROXIMAL_EXT = 22,
+    XR_HAND_JOINT_LITTLE_INTERMEDIATE_EXT = 23,
+    XR_HAND_JOINT_LITTLE_DISTAL_EXT = 24,
+    XR_HAND_JOINT_LITTLE_TIP_EXT = 25,
+    XR_HAND_JOINT_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrHandJointEXT;
+
+typedef enum XrHandJointSetEXT {
+    XR_HAND_JOINT_SET_DEFAULT_EXT = 0,
+    XR_HAND_JOINT_SET_HAND_WITH_FOREARM_ULTRALEAP = 1000149000,
+    XR_HAND_JOINT_SET_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrHandJointSetEXT;
+// XrSystemHandTrackingPropertiesEXT extends XrSystemProperties
+typedef struct XrSystemHandTrackingPropertiesEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsHandTracking;
+} XrSystemHandTrackingPropertiesEXT;
+
+typedef struct XrHandTrackerCreateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrHandEXT                   hand;
+    XrHandJointSetEXT           handJointSet;
+} XrHandTrackerCreateInfoEXT;
+
+typedef struct XrHandJointsLocateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+} XrHandJointsLocateInfoEXT;
+
+typedef struct XrHandJointLocationEXT {
+    XrSpaceLocationFlags    locationFlags;
+    XrPosef                 pose;
+    float                   radius;
+} XrHandJointLocationEXT;
+
+typedef struct XrHandJointVelocityEXT {
+    XrSpaceVelocityFlags    velocityFlags;
+    XrVector3f              linearVelocity;
+    XrVector3f              angularVelocity;
+} XrHandJointVelocityEXT;
+
+typedef struct XrHandJointLocationsEXT {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    XrBool32                   isActive;
+    uint32_t                   jointCount;
+    XrHandJointLocationEXT*    jointLocations;
+} XrHandJointLocationsEXT;
+
+// XrHandJointVelocitiesEXT extends XrHandJointLocationsEXT
+typedef struct XrHandJointVelocitiesEXT {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    uint32_t                   jointCount;
+    XrHandJointVelocityEXT*    jointVelocities;
+} XrHandJointVelocitiesEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateHandTrackerEXT)(XrSession session, const XrHandTrackerCreateInfoEXT* createInfo, XrHandTrackerEXT* handTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyHandTrackerEXT)(XrHandTrackerEXT handTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrLocateHandJointsEXT)(XrHandTrackerEXT handTracker, const XrHandJointsLocateInfoEXT* locateInfo, XrHandJointLocationsEXT* locations);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateHandTrackerEXT(
+    XrSession                                   session,
+    const XrHandTrackerCreateInfoEXT*           createInfo,
+    XrHandTrackerEXT*                           handTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyHandTrackerEXT(
+    XrHandTrackerEXT                            handTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateHandJointsEXT(
+    XrHandTrackerEXT                            handTracker,
+    const XrHandJointsLocateInfoEXT*            locateInfo,
+    XrHandJointLocationsEXT*                    locations);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_MSFT_hand_tracking_mesh is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_hand_tracking_mesh 1
+#define XR_MSFT_hand_tracking_mesh_SPEC_VERSION 4
+#define XR_MSFT_HAND_TRACKING_MESH_EXTENSION_NAME "XR_MSFT_hand_tracking_mesh"
+
+typedef enum XrHandPoseTypeMSFT {
+    XR_HAND_POSE_TYPE_TRACKED_MSFT = 0,
+    XR_HAND_POSE_TYPE_REFERENCE_OPEN_PALM_MSFT = 1,
+    XR_HAND_POSE_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrHandPoseTypeMSFT;
+// XrSystemHandTrackingMeshPropertiesMSFT extends XrSystemProperties
+typedef struct XrSystemHandTrackingMeshPropertiesMSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsHandTrackingMesh;
+    uint32_t              maxHandMeshIndexCount;
+    uint32_t              maxHandMeshVertexCount;
+} XrSystemHandTrackingMeshPropertiesMSFT;
+
+typedef struct XrHandMeshSpaceCreateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrHandPoseTypeMSFT          handPoseType;
+    XrPosef                     poseInHandMeshSpace;
+} XrHandMeshSpaceCreateInfoMSFT;
+
+typedef struct XrHandMeshUpdateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      time;
+    XrHandPoseTypeMSFT          handPoseType;
+} XrHandMeshUpdateInfoMSFT;
+
+typedef struct XrHandMeshIndexBufferMSFT {
+    uint32_t     indexBufferKey;
+    uint32_t     indexCapacityInput;
+    uint32_t     indexCountOutput;
+    uint32_t*    indices;
+} XrHandMeshIndexBufferMSFT;
+
+typedef struct XrHandMeshVertexMSFT {
+    XrVector3f    position;
+    XrVector3f    normal;
+} XrHandMeshVertexMSFT;
+
+typedef struct XrHandMeshVertexBufferMSFT {
+    XrTime                   vertexUpdateTime;
+    uint32_t                 vertexCapacityInput;
+    uint32_t                 vertexCountOutput;
+    XrHandMeshVertexMSFT*    vertices;
+} XrHandMeshVertexBufferMSFT;
+
+typedef struct XrHandMeshMSFT {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    XrBool32                      isActive;
+    XrBool32                      indexBufferChanged;
+    XrBool32                      vertexBufferChanged;
+    XrHandMeshIndexBufferMSFT     indexBuffer;
+    XrHandMeshVertexBufferMSFT    vertexBuffer;
+} XrHandMeshMSFT;
+
+// XrHandPoseTypeInfoMSFT extends XrHandTrackerCreateInfoEXT
+typedef struct XrHandPoseTypeInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrHandPoseTypeMSFT          handPoseType;
+} XrHandPoseTypeInfoMSFT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateHandMeshSpaceMSFT)(XrHandTrackerEXT handTracker, const XrHandMeshSpaceCreateInfoMSFT* createInfo, XrSpace* space);
+typedef XrResult (XRAPI_PTR *PFN_xrUpdateHandMeshMSFT)(XrHandTrackerEXT handTracker, const XrHandMeshUpdateInfoMSFT* updateInfo, XrHandMeshMSFT* handMesh);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateHandMeshSpaceMSFT(
+    XrHandTrackerEXT                            handTracker,
+    const XrHandMeshSpaceCreateInfoMSFT*        createInfo,
+    XrSpace*                                    space);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUpdateHandMeshMSFT(
+    XrHandTrackerEXT                            handTracker,
+    const XrHandMeshUpdateInfoMSFT*             updateInfo,
+    XrHandMeshMSFT*                             handMesh);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_MSFT_secondary_view_configuration is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_secondary_view_configuration 1
+#define XR_MSFT_secondary_view_configuration_SPEC_VERSION 1
+#define XR_MSFT_SECONDARY_VIEW_CONFIGURATION_EXTENSION_NAME "XR_MSFT_secondary_view_configuration"
+// XrSecondaryViewConfigurationSessionBeginInfoMSFT extends XrSessionBeginInfo
+typedef struct XrSecondaryViewConfigurationSessionBeginInfoMSFT {
+    XrStructureType                   type;
+    const void* XR_MAY_ALIAS          next;
+    uint32_t                          viewConfigurationCount;
+    const XrViewConfigurationType*    enabledViewConfigurationTypes;
+} XrSecondaryViewConfigurationSessionBeginInfoMSFT;
+
+typedef struct XrSecondaryViewConfigurationStateMSFT {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    XrViewConfigurationType    viewConfigurationType;
+    XrBool32                   active;
+} XrSecondaryViewConfigurationStateMSFT;
+
+// XrSecondaryViewConfigurationFrameStateMSFT extends XrFrameState
+typedef struct XrSecondaryViewConfigurationFrameStateMSFT {
+    XrStructureType                           type;
+    void* XR_MAY_ALIAS                        next;
+    uint32_t                                  viewConfigurationCount;
+    XrSecondaryViewConfigurationStateMSFT*    viewConfigurationStates;
+} XrSecondaryViewConfigurationFrameStateMSFT;
+
+typedef struct XrSecondaryViewConfigurationLayerInfoMSFT {
+    XrStructureType                               type;
+    const void* XR_MAY_ALIAS                      next;
+    XrViewConfigurationType                       viewConfigurationType;
+    XrEnvironmentBlendMode                        environmentBlendMode;
+    uint32_t                                      layerCount;
+    const XrCompositionLayerBaseHeader* const*    layers;
+} XrSecondaryViewConfigurationLayerInfoMSFT;
+
+// XrSecondaryViewConfigurationFrameEndInfoMSFT extends XrFrameEndInfo
+typedef struct XrSecondaryViewConfigurationFrameEndInfoMSFT {
+    XrStructureType                                     type;
+    const void* XR_MAY_ALIAS                            next;
+    uint32_t                                            viewConfigurationCount;
+    const XrSecondaryViewConfigurationLayerInfoMSFT*    viewConfigurationLayersInfo;
+} XrSecondaryViewConfigurationFrameEndInfoMSFT;
+
+// XrSecondaryViewConfigurationSwapchainCreateInfoMSFT extends XrSwapchainCreateInfo
+typedef struct XrSecondaryViewConfigurationSwapchainCreateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrViewConfigurationType     viewConfigurationType;
+} XrSecondaryViewConfigurationSwapchainCreateInfoMSFT;
+
+
+
+// XR_MSFT_first_person_observer is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_first_person_observer 1
+#define XR_MSFT_first_person_observer_SPEC_VERSION 1
+#define XR_MSFT_FIRST_PERSON_OBSERVER_EXTENSION_NAME "XR_MSFT_first_person_observer"
+
+
+// XR_MSFT_controller_model is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_controller_model 1
+
+#define XR_NULL_CONTROLLER_MODEL_KEY_MSFT 0
+
+XR_DEFINE_ATOM(XrControllerModelKeyMSFT)
+#define XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT 64
+#define XR_MSFT_controller_model_SPEC_VERSION 2
+#define XR_MSFT_CONTROLLER_MODEL_EXTENSION_NAME "XR_MSFT_controller_model"
+typedef struct XrControllerModelKeyStateMSFT {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    XrControllerModelKeyMSFT    modelKey;
+} XrControllerModelKeyStateMSFT;
+
+typedef struct XrControllerModelNodePropertiesMSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    char                  parentNodeName[XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT];
+    char                  nodeName[XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT];
+} XrControllerModelNodePropertiesMSFT;
+
+typedef struct XrControllerModelPropertiesMSFT {
+    XrStructureType                         type;
+    void* XR_MAY_ALIAS                      next;
+    uint32_t                                nodeCapacityInput;
+    uint32_t                                nodeCountOutput;
+    XrControllerModelNodePropertiesMSFT*    nodeProperties;
+} XrControllerModelPropertiesMSFT;
+
+typedef struct XrControllerModelNodeStateMSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrPosef               nodePose;
+} XrControllerModelNodeStateMSFT;
+
+typedef struct XrControllerModelStateMSFT {
+    XrStructureType                    type;
+    void* XR_MAY_ALIAS                 next;
+    uint32_t                           nodeCapacityInput;
+    uint32_t                           nodeCountOutput;
+    XrControllerModelNodeStateMSFT*    nodeStates;
+} XrControllerModelStateMSFT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetControllerModelKeyMSFT)(XrSession session, XrPath topLevelUserPath, XrControllerModelKeyStateMSFT* controllerModelKeyState);
+typedef XrResult (XRAPI_PTR *PFN_xrLoadControllerModelMSFT)(XrSession session, XrControllerModelKeyMSFT modelKey, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, uint8_t* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetControllerModelPropertiesMSFT)(XrSession session, XrControllerModelKeyMSFT modelKey, XrControllerModelPropertiesMSFT* properties);
+typedef XrResult (XRAPI_PTR *PFN_xrGetControllerModelStateMSFT)(XrSession session, XrControllerModelKeyMSFT modelKey, XrControllerModelStateMSFT* state);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetControllerModelKeyMSFT(
+    XrSession                                   session,
+    XrPath                                      topLevelUserPath,
+    XrControllerModelKeyStateMSFT*              controllerModelKeyState);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLoadControllerModelMSFT(
+    XrSession                                   session,
+    XrControllerModelKeyMSFT                    modelKey,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    uint8_t*                                    buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetControllerModelPropertiesMSFT(
+    XrSession                                   session,
+    XrControllerModelKeyMSFT                    modelKey,
+    XrControllerModelPropertiesMSFT*            properties);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetControllerModelStateMSFT(
+    XrSession                                   session,
+    XrControllerModelKeyMSFT                    modelKey,
+    XrControllerModelStateMSFT*                 state);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_win32_appcontainer_compatible is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_win32_appcontainer_compatible 1
+#define XR_EXT_win32_appcontainer_compatible_SPEC_VERSION 1
+#define XR_EXT_WIN32_APPCONTAINER_COMPATIBLE_EXTENSION_NAME "XR_EXT_win32_appcontainer_compatible"
+
+
+// XR_EPIC_view_configuration_fov is a preprocessor guard. Do not pass it to API calls.
+#define XR_EPIC_view_configuration_fov 1
+#define XR_EPIC_view_configuration_fov_SPEC_VERSION 2
+#define XR_EPIC_VIEW_CONFIGURATION_FOV_EXTENSION_NAME "XR_EPIC_view_configuration_fov"
+// XrViewConfigurationViewFovEPIC extends XrViewConfigurationView
+typedef struct XrViewConfigurationViewFovEPIC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrFovf                      recommendedFov;
+    XrFovf                      maxMutableFov;
+} XrViewConfigurationViewFovEPIC;
+
+
+
+// XR_MSFT_composition_layer_reprojection is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_composition_layer_reprojection 1
+#define XR_MSFT_composition_layer_reprojection_SPEC_VERSION 1
+#define XR_MSFT_COMPOSITION_LAYER_REPROJECTION_EXTENSION_NAME "XR_MSFT_composition_layer_reprojection"
+
+typedef enum XrReprojectionModeMSFT {
+    XR_REPROJECTION_MODE_DEPTH_MSFT = 1,
+    XR_REPROJECTION_MODE_PLANAR_FROM_DEPTH_MSFT = 2,
+    XR_REPROJECTION_MODE_PLANAR_MANUAL_MSFT = 3,
+    XR_REPROJECTION_MODE_ORIENTATION_ONLY_MSFT = 4,
+    XR_REPROJECTION_MODE_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrReprojectionModeMSFT;
+// XrCompositionLayerReprojectionInfoMSFT extends XrCompositionLayerProjection
+typedef struct XrCompositionLayerReprojectionInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrReprojectionModeMSFT      reprojectionMode;
+} XrCompositionLayerReprojectionInfoMSFT;
+
+// XrCompositionLayerReprojectionPlaneOverrideMSFT extends XrCompositionLayerProjection
+typedef struct XrCompositionLayerReprojectionPlaneOverrideMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrVector3f                  position;
+    XrVector3f                  normal;
+    XrVector3f                  velocity;
+} XrCompositionLayerReprojectionPlaneOverrideMSFT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateReprojectionModesMSFT)(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t modeCapacityInput, uint32_t* modeCountOutput, XrReprojectionModeMSFT* modes);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateReprojectionModesMSFT(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrViewConfigurationType                     viewConfigurationType,
+    uint32_t                                    modeCapacityInput,
+    uint32_t*                                   modeCountOutput,
+    XrReprojectionModeMSFT*                     modes);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_HUAWEI_controller_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_HUAWEI_controller_interaction 1
+#define XR_HUAWEI_controller_interaction_SPEC_VERSION 1
+#define XR_HUAWEI_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HUAWEI_controller_interaction"
+
+
+// XR_FB_swapchain_update_state is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_swapchain_update_state 1
+#define XR_FB_swapchain_update_state_SPEC_VERSION 3
+#define XR_FB_SWAPCHAIN_UPDATE_STATE_EXTENSION_NAME "XR_FB_swapchain_update_state"
+typedef struct XR_MAY_ALIAS XrSwapchainStateBaseHeaderFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+} XrSwapchainStateBaseHeaderFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrUpdateSwapchainFB)(XrSwapchain swapchain, const XrSwapchainStateBaseHeaderFB* state);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSwapchainStateFB)(XrSwapchain swapchain, XrSwapchainStateBaseHeaderFB* state);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSwapchainFB(
+    XrSwapchain                                 swapchain,
+    const XrSwapchainStateBaseHeaderFB*         state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSwapchainStateFB(
+    XrSwapchain                                 swapchain,
+    XrSwapchainStateBaseHeaderFB*               state);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_composition_layer_secure_content is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_composition_layer_secure_content 1
+#define XR_FB_composition_layer_secure_content_SPEC_VERSION 1
+#define XR_FB_COMPOSITION_LAYER_SECURE_CONTENT_EXTENSION_NAME "XR_FB_composition_layer_secure_content"
+// XrCompositionLayerSecureContentFB extends XrCompositionLayerBaseHeader
+typedef struct XrCompositionLayerSecureContentFB {
+    XrStructureType                           type;
+    const void* XR_MAY_ALIAS                  next;
+    XrCompositionLayerSecureContentFlagsFB    flags;
+} XrCompositionLayerSecureContentFB;
+
+
+
+// XR_FB_body_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_body_tracking 1
+XR_DEFINE_HANDLE(XrBodyTrackerFB)
+#define XR_FB_body_tracking_SPEC_VERSION  1
+#define XR_FB_BODY_TRACKING_EXTENSION_NAME "XR_FB_body_tracking"
+
+typedef enum XrBodyJointFB {
+    XR_BODY_JOINT_ROOT_FB = 0,
+    XR_BODY_JOINT_HIPS_FB = 1,
+    XR_BODY_JOINT_SPINE_LOWER_FB = 2,
+    XR_BODY_JOINT_SPINE_MIDDLE_FB = 3,
+    XR_BODY_JOINT_SPINE_UPPER_FB = 4,
+    XR_BODY_JOINT_CHEST_FB = 5,
+    XR_BODY_JOINT_NECK_FB = 6,
+    XR_BODY_JOINT_HEAD_FB = 7,
+    XR_BODY_JOINT_LEFT_SHOULDER_FB = 8,
+    XR_BODY_JOINT_LEFT_SCAPULA_FB = 9,
+    XR_BODY_JOINT_LEFT_ARM_UPPER_FB = 10,
+    XR_BODY_JOINT_LEFT_ARM_LOWER_FB = 11,
+    XR_BODY_JOINT_LEFT_HAND_WRIST_TWIST_FB = 12,
+    XR_BODY_JOINT_RIGHT_SHOULDER_FB = 13,
+    XR_BODY_JOINT_RIGHT_SCAPULA_FB = 14,
+    XR_BODY_JOINT_RIGHT_ARM_UPPER_FB = 15,
+    XR_BODY_JOINT_RIGHT_ARM_LOWER_FB = 16,
+    XR_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_FB = 17,
+    XR_BODY_JOINT_LEFT_HAND_PALM_FB = 18,
+    XR_BODY_JOINT_LEFT_HAND_WRIST_FB = 19,
+    XR_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_FB = 20,
+    XR_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_FB = 21,
+    XR_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_FB = 22,
+    XR_BODY_JOINT_LEFT_HAND_THUMB_TIP_FB = 23,
+    XR_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_FB = 24,
+    XR_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_FB = 25,
+    XR_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_FB = 26,
+    XR_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_FB = 27,
+    XR_BODY_JOINT_LEFT_HAND_INDEX_TIP_FB = 28,
+    XR_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_FB = 29,
+    XR_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_FB = 30,
+    XR_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_FB = 31,
+    XR_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_FB = 32,
+    XR_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_FB = 33,
+    XR_BODY_JOINT_LEFT_HAND_RING_METACARPAL_FB = 34,
+    XR_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_FB = 35,
+    XR_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_FB = 36,
+    XR_BODY_JOINT_LEFT_HAND_RING_DISTAL_FB = 37,
+    XR_BODY_JOINT_LEFT_HAND_RING_TIP_FB = 38,
+    XR_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_FB = 39,
+    XR_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_FB = 40,
+    XR_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_FB = 41,
+    XR_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_FB = 42,
+    XR_BODY_JOINT_LEFT_HAND_LITTLE_TIP_FB = 43,
+    XR_BODY_JOINT_RIGHT_HAND_PALM_FB = 44,
+    XR_BODY_JOINT_RIGHT_HAND_WRIST_FB = 45,
+    XR_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_FB = 46,
+    XR_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_FB = 47,
+    XR_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_FB = 48,
+    XR_BODY_JOINT_RIGHT_HAND_THUMB_TIP_FB = 49,
+    XR_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_FB = 50,
+    XR_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_FB = 51,
+    XR_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_FB = 52,
+    XR_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_FB = 53,
+    XR_BODY_JOINT_RIGHT_HAND_INDEX_TIP_FB = 54,
+    XR_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_FB = 55,
+    XR_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_FB = 56,
+    XR_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_FB = 57,
+    XR_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_FB = 58,
+    XR_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_FB = 59,
+    XR_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_FB = 60,
+    XR_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_FB = 61,
+    XR_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_FB = 62,
+    XR_BODY_JOINT_RIGHT_HAND_RING_DISTAL_FB = 63,
+    XR_BODY_JOINT_RIGHT_HAND_RING_TIP_FB = 64,
+    XR_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_FB = 65,
+    XR_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_FB = 66,
+    XR_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_FB = 67,
+    XR_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_FB = 68,
+    XR_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_FB = 69,
+    XR_BODY_JOINT_COUNT_FB = 70,
+    XR_BODY_JOINT_NONE_FB = -1,
+    XR_BODY_JOINT_MAX_ENUM_FB = 0x7FFFFFFF
+} XrBodyJointFB;
+
+typedef enum XrBodyJointSetFB {
+    XR_BODY_JOINT_SET_DEFAULT_FB = 0,
+    XR_BODY_JOINT_SET_FULL_BODY_META = 1000274000,
+    XR_BODY_JOINT_SET_MAX_ENUM_FB = 0x7FFFFFFF
+} XrBodyJointSetFB;
+typedef struct XrBodyJointLocationFB {
+    XrSpaceLocationFlags    locationFlags;
+    XrPosef                 pose;
+} XrBodyJointLocationFB;
+
+// XrSystemBodyTrackingPropertiesFB extends XrSystemProperties
+typedef struct XrSystemBodyTrackingPropertiesFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsBodyTracking;
+} XrSystemBodyTrackingPropertiesFB;
+
+typedef struct XrBodyTrackerCreateInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBodyJointSetFB            bodyJointSet;
+} XrBodyTrackerCreateInfoFB;
+
+typedef struct XrBodySkeletonJointFB {
+    int32_t    joint;
+    int32_t    parentJoint;
+    XrPosef    pose;
+} XrBodySkeletonJointFB;
+
+typedef struct XrBodySkeletonFB {
+    XrStructureType           type;
+    void* XR_MAY_ALIAS        next;
+    uint32_t                  jointCount;
+    XrBodySkeletonJointFB*    joints;
+} XrBodySkeletonFB;
+
+typedef struct XrBodyJointsLocateInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+} XrBodyJointsLocateInfoFB;
+
+typedef struct XrBodyJointLocationsFB {
+    XrStructureType           type;
+    void* XR_MAY_ALIAS        next;
+    XrBool32                  isActive;
+    float                     confidence;
+    uint32_t                  jointCount;
+    XrBodyJointLocationFB*    jointLocations;
+    uint32_t                  skeletonChangedCount;
+    XrTime                    time;
+} XrBodyJointLocationsFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateBodyTrackerFB)(XrSession session, const XrBodyTrackerCreateInfoFB* createInfo, XrBodyTrackerFB* bodyTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyBodyTrackerFB)(XrBodyTrackerFB bodyTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrLocateBodyJointsFB)(XrBodyTrackerFB bodyTracker, const XrBodyJointsLocateInfoFB* locateInfo, XrBodyJointLocationsFB* locations);
+typedef XrResult (XRAPI_PTR *PFN_xrGetBodySkeletonFB)(XrBodyTrackerFB bodyTracker, XrBodySkeletonFB* skeleton);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateBodyTrackerFB(
+    XrSession                                   session,
+    const XrBodyTrackerCreateInfoFB*            createInfo,
+    XrBodyTrackerFB*                            bodyTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyBodyTrackerFB(
+    XrBodyTrackerFB                             bodyTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateBodyJointsFB(
+    XrBodyTrackerFB                             bodyTracker,
+    const XrBodyJointsLocateInfoFB*             locateInfo,
+    XrBodyJointLocationsFB*                     locations);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetBodySkeletonFB(
+    XrBodyTrackerFB                             bodyTracker,
+    XrBodySkeletonFB*                           skeleton);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_dpad_binding is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_dpad_binding 1
+#define XR_EXT_dpad_binding_SPEC_VERSION  1
+#define XR_EXT_DPAD_BINDING_EXTENSION_NAME "XR_EXT_dpad_binding"
+typedef struct XrInteractionProfileDpadBindingEXT {
+    XrStructureType              type;
+    const void* XR_MAY_ALIAS     next;
+    XrPath                       binding;
+    XrActionSet                  actionSet;
+    float                        forceThreshold;
+    float                        forceThresholdReleased;
+    float                        centerRegion;
+    float                        wedgeAngle;
+    XrBool32                     isSticky;
+    const XrHapticBaseHeader*    onHaptic;
+    const XrHapticBaseHeader*    offHaptic;
+} XrInteractionProfileDpadBindingEXT;
+
+
+
+// XR_VALVE_analog_threshold is a preprocessor guard. Do not pass it to API calls.
+#define XR_VALVE_analog_threshold 1
+#define XR_VALVE_analog_threshold_SPEC_VERSION 2
+#define XR_VALVE_ANALOG_THRESHOLD_EXTENSION_NAME "XR_VALVE_analog_threshold"
+typedef struct XrInteractionProfileAnalogThresholdVALVE {
+    XrStructureType              type;
+    const void* XR_MAY_ALIAS     next;
+    XrAction                     action;
+    XrPath                       binding;
+    float                        onThreshold;
+    float                        offThreshold;
+    const XrHapticBaseHeader*    onHaptic;
+    const XrHapticBaseHeader*    offHaptic;
+} XrInteractionProfileAnalogThresholdVALVE;
+
+
+
+// XR_EXT_hand_joints_motion_range is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_hand_joints_motion_range 1
+#define XR_EXT_hand_joints_motion_range_SPEC_VERSION 1
+#define XR_EXT_HAND_JOINTS_MOTION_RANGE_EXTENSION_NAME "XR_EXT_hand_joints_motion_range"
+
+typedef enum XrHandJointsMotionRangeEXT {
+    XR_HAND_JOINTS_MOTION_RANGE_UNOBSTRUCTED_EXT = 1,
+    XR_HAND_JOINTS_MOTION_RANGE_CONFORMING_TO_CONTROLLER_EXT = 2,
+    XR_HAND_JOINTS_MOTION_RANGE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrHandJointsMotionRangeEXT;
+// XrHandJointsMotionRangeInfoEXT extends XrHandJointsLocateInfoEXT
+typedef struct XrHandJointsMotionRangeInfoEXT {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrHandJointsMotionRangeEXT    handJointsMotionRange;
+} XrHandJointsMotionRangeInfoEXT;
+
+
+
+// XR_EXT_samsung_odyssey_controller is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_samsung_odyssey_controller 1
+#define XR_EXT_samsung_odyssey_controller_SPEC_VERSION 1
+#define XR_EXT_SAMSUNG_ODYSSEY_CONTROLLER_EXTENSION_NAME "XR_EXT_samsung_odyssey_controller"
+
+
+// XR_EXT_hp_mixed_reality_controller is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_hp_mixed_reality_controller 1
+#define XR_EXT_hp_mixed_reality_controller_SPEC_VERSION 1
+#define XR_EXT_HP_MIXED_REALITY_CONTROLLER_EXTENSION_NAME "XR_EXT_hp_mixed_reality_controller"
+
+
+// XR_MND_swapchain_usage_input_attachment_bit is a preprocessor guard. Do not pass it to API calls.
+#define XR_MND_swapchain_usage_input_attachment_bit 1
+#define XR_MND_swapchain_usage_input_attachment_bit_SPEC_VERSION 2
+#define XR_MND_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME "XR_MND_swapchain_usage_input_attachment_bit"
+
+
+// XR_MSFT_scene_understanding is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_scene_understanding 1
+
+            XR_DEFINE_HANDLE(XrSceneMSFT)
+
+
+            XR_DEFINE_HANDLE(XrSceneObserverMSFT)
+
+#define XR_MSFT_scene_understanding_SPEC_VERSION 2
+#define XR_MSFT_SCENE_UNDERSTANDING_EXTENSION_NAME "XR_MSFT_scene_understanding"
+
+typedef enum XrSceneComputeFeatureMSFT {
+    XR_SCENE_COMPUTE_FEATURE_PLANE_MSFT = 1,
+    XR_SCENE_COMPUTE_FEATURE_PLANE_MESH_MSFT = 2,
+    XR_SCENE_COMPUTE_FEATURE_VISUAL_MESH_MSFT = 3,
+    XR_SCENE_COMPUTE_FEATURE_COLLIDER_MESH_MSFT = 4,
+    XR_SCENE_COMPUTE_FEATURE_SERIALIZE_SCENE_MSFT = 1000098000,
+    XR_SCENE_COMPUTE_FEATURE_MARKER_MSFT = 1000147000,
+    XR_SCENE_COMPUTE_FEATURE_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrSceneComputeFeatureMSFT;
+
+typedef enum XrSceneComputeConsistencyMSFT {
+    XR_SCENE_COMPUTE_CONSISTENCY_SNAPSHOT_COMPLETE_MSFT = 1,
+    XR_SCENE_COMPUTE_CONSISTENCY_SNAPSHOT_INCOMPLETE_FAST_MSFT = 2,
+    XR_SCENE_COMPUTE_CONSISTENCY_OCCLUSION_OPTIMIZED_MSFT = 3,
+    XR_SCENE_COMPUTE_CONSISTENCY_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrSceneComputeConsistencyMSFT;
+
+typedef enum XrMeshComputeLodMSFT {
+    XR_MESH_COMPUTE_LOD_COARSE_MSFT = 1,
+    XR_MESH_COMPUTE_LOD_MEDIUM_MSFT = 2,
+    XR_MESH_COMPUTE_LOD_FINE_MSFT = 3,
+    XR_MESH_COMPUTE_LOD_UNLIMITED_MSFT = 4,
+    XR_MESH_COMPUTE_LOD_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrMeshComputeLodMSFT;
+
+typedef enum XrSceneComponentTypeMSFT {
+    XR_SCENE_COMPONENT_TYPE_INVALID_MSFT = -1,
+    XR_SCENE_COMPONENT_TYPE_OBJECT_MSFT = 1,
+    XR_SCENE_COMPONENT_TYPE_PLANE_MSFT = 2,
+    XR_SCENE_COMPONENT_TYPE_VISUAL_MESH_MSFT = 3,
+    XR_SCENE_COMPONENT_TYPE_COLLIDER_MESH_MSFT = 4,
+    XR_SCENE_COMPONENT_TYPE_SERIALIZED_SCENE_FRAGMENT_MSFT = 1000098000,
+    XR_SCENE_COMPONENT_TYPE_MARKER_MSFT = 1000147000,
+    XR_SCENE_COMPONENT_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrSceneComponentTypeMSFT;
+
+typedef enum XrSceneObjectTypeMSFT {
+    XR_SCENE_OBJECT_TYPE_UNCATEGORIZED_MSFT = -1,
+    XR_SCENE_OBJECT_TYPE_BACKGROUND_MSFT = 1,
+    XR_SCENE_OBJECT_TYPE_WALL_MSFT = 2,
+    XR_SCENE_OBJECT_TYPE_FLOOR_MSFT = 3,
+    XR_SCENE_OBJECT_TYPE_CEILING_MSFT = 4,
+    XR_SCENE_OBJECT_TYPE_PLATFORM_MSFT = 5,
+    XR_SCENE_OBJECT_TYPE_INFERRED_MSFT = 6,
+    XR_SCENE_OBJECT_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrSceneObjectTypeMSFT;
+
+typedef enum XrScenePlaneAlignmentTypeMSFT {
+    XR_SCENE_PLANE_ALIGNMENT_TYPE_NON_ORTHOGONAL_MSFT = 0,
+    XR_SCENE_PLANE_ALIGNMENT_TYPE_HORIZONTAL_MSFT = 1,
+    XR_SCENE_PLANE_ALIGNMENT_TYPE_VERTICAL_MSFT = 2,
+    XR_SCENE_PLANE_ALIGNMENT_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrScenePlaneAlignmentTypeMSFT;
+
+typedef enum XrSceneComputeStateMSFT {
+    XR_SCENE_COMPUTE_STATE_NONE_MSFT = 0,
+    XR_SCENE_COMPUTE_STATE_UPDATING_MSFT = 1,
+    XR_SCENE_COMPUTE_STATE_COMPLETED_MSFT = 2,
+    XR_SCENE_COMPUTE_STATE_COMPLETED_WITH_ERROR_MSFT = 3,
+    XR_SCENE_COMPUTE_STATE_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrSceneComputeStateMSFT;
+typedef struct XrUuidMSFT {
+    uint8_t    bytes[16];
+} XrUuidMSFT;
+
+typedef struct XrSceneObserverCreateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSceneObserverCreateInfoMSFT;
+
+typedef struct XrSceneCreateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSceneCreateInfoMSFT;
+
+typedef struct XrSceneSphereBoundMSFT {
+    XrVector3f    center;
+    float         radius;
+} XrSceneSphereBoundMSFT;
+
+typedef struct XrSceneOrientedBoxBoundMSFT {
+    XrPosef       pose;
+    XrVector3f    extents;
+} XrSceneOrientedBoxBoundMSFT;
+
+typedef struct XrSceneFrustumBoundMSFT {
+    XrPosef    pose;
+    XrFovf     fov;
+    float      farDistance;
+} XrSceneFrustumBoundMSFT;
+
+typedef struct XrSceneBoundsMSFT {
+    XrSpace                               space;
+    XrTime                                time;
+    uint32_t                              sphereCount;
+    const XrSceneSphereBoundMSFT*         spheres;
+    uint32_t                              boxCount;
+    const XrSceneOrientedBoxBoundMSFT*    boxes;
+    uint32_t                              frustumCount;
+    const XrSceneFrustumBoundMSFT*        frustums;
+} XrSceneBoundsMSFT;
+
+typedef struct XrNewSceneComputeInfoMSFT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    uint32_t                            requestedFeatureCount;
+    const XrSceneComputeFeatureMSFT*    requestedFeatures;
+    XrSceneComputeConsistencyMSFT       consistency;
+    XrSceneBoundsMSFT                   bounds;
+} XrNewSceneComputeInfoMSFT;
+
+// XrVisualMeshComputeLodInfoMSFT extends XrNewSceneComputeInfoMSFT
+typedef struct XrVisualMeshComputeLodInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrMeshComputeLodMSFT        lod;
+} XrVisualMeshComputeLodInfoMSFT;
+
+typedef struct XrSceneComponentMSFT {
+    XrSceneComponentTypeMSFT    componentType;
+    XrUuidMSFT                  id;
+    XrUuidMSFT                  parentId;
+    XrTime                      updateTime;
+} XrSceneComponentMSFT;
+
+typedef struct XrSceneComponentsMSFT {
+    XrStructureType          type;
+    void* XR_MAY_ALIAS       next;
+    uint32_t                 componentCapacityInput;
+    uint32_t                 componentCountOutput;
+    XrSceneComponentMSFT*    components;
+} XrSceneComponentsMSFT;
+
+typedef struct XrSceneComponentsGetInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSceneComponentTypeMSFT    componentType;
+} XrSceneComponentsGetInfoMSFT;
+
+typedef struct XrSceneComponentLocationMSFT {
+    XrSpaceLocationFlags    flags;
+    XrPosef                 pose;
+} XrSceneComponentLocationMSFT;
+
+typedef struct XrSceneComponentLocationsMSFT {
+    XrStructureType                  type;
+    void* XR_MAY_ALIAS               next;
+    uint32_t                         locationCount;
+    XrSceneComponentLocationMSFT*    locations;
+} XrSceneComponentLocationsMSFT;
+
+typedef struct XrSceneComponentsLocateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+    uint32_t                    componentIdCount;
+    const XrUuidMSFT*           componentIds;
+} XrSceneComponentsLocateInfoMSFT;
+
+typedef struct XrSceneObjectMSFT {
+    XrSceneObjectTypeMSFT    objectType;
+} XrSceneObjectMSFT;
+
+// XrSceneObjectsMSFT extends XrSceneComponentsMSFT
+typedef struct XrSceneObjectsMSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              sceneObjectCount;
+    XrSceneObjectMSFT*    sceneObjects;
+} XrSceneObjectsMSFT;
+
+// XrSceneComponentParentFilterInfoMSFT extends XrSceneComponentsGetInfoMSFT
+typedef struct XrSceneComponentParentFilterInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrUuidMSFT                  parentId;
+} XrSceneComponentParentFilterInfoMSFT;
+
+// XrSceneObjectTypesFilterInfoMSFT extends XrSceneComponentsGetInfoMSFT
+typedef struct XrSceneObjectTypesFilterInfoMSFT {
+    XrStructureType                 type;
+    const void* XR_MAY_ALIAS        next;
+    uint32_t                        objectTypeCount;
+    const XrSceneObjectTypeMSFT*    objectTypes;
+} XrSceneObjectTypesFilterInfoMSFT;
+
+typedef struct XrScenePlaneMSFT {
+    XrScenePlaneAlignmentTypeMSFT    alignment;
+    XrExtent2Df                      size;
+    uint64_t                         meshBufferId;
+    XrBool32                         supportsIndicesUint16;
+} XrScenePlaneMSFT;
+
+// XrScenePlanesMSFT extends XrSceneComponentsMSFT
+typedef struct XrScenePlanesMSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              scenePlaneCount;
+    XrScenePlaneMSFT*     scenePlanes;
+} XrScenePlanesMSFT;
+
+// XrScenePlaneAlignmentFilterInfoMSFT extends XrSceneComponentsGetInfoMSFT
+typedef struct XrScenePlaneAlignmentFilterInfoMSFT {
+    XrStructureType                         type;
+    const void* XR_MAY_ALIAS                next;
+    uint32_t                                alignmentCount;
+    const XrScenePlaneAlignmentTypeMSFT*    alignments;
+} XrScenePlaneAlignmentFilterInfoMSFT;
+
+typedef struct XrSceneMeshMSFT {
+    uint64_t    meshBufferId;
+    XrBool32    supportsIndicesUint16;
+} XrSceneMeshMSFT;
+
+// XrSceneMeshesMSFT extends XrSceneComponentsMSFT
+typedef struct XrSceneMeshesMSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              sceneMeshCount;
+    XrSceneMeshMSFT*      sceneMeshes;
+} XrSceneMeshesMSFT;
+
+typedef struct XrSceneMeshBuffersGetInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint64_t                    meshBufferId;
+} XrSceneMeshBuffersGetInfoMSFT;
+
+typedef struct XrSceneMeshBuffersMSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+} XrSceneMeshBuffersMSFT;
+
+// XrSceneMeshVertexBufferMSFT extends XrSceneMeshBuffersMSFT
+typedef struct XrSceneMeshVertexBufferMSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              vertexCapacityInput;
+    uint32_t              vertexCountOutput;
+    XrVector3f*           vertices;
+} XrSceneMeshVertexBufferMSFT;
+
+// XrSceneMeshIndicesUint32MSFT extends XrSceneMeshBuffersMSFT
+typedef struct XrSceneMeshIndicesUint32MSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              indexCapacityInput;
+    uint32_t              indexCountOutput;
+    uint32_t*             indices;
+} XrSceneMeshIndicesUint32MSFT;
+
+// XrSceneMeshIndicesUint16MSFT extends XrSceneMeshBuffersMSFT
+typedef struct XrSceneMeshIndicesUint16MSFT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              indexCapacityInput;
+    uint32_t              indexCountOutput;
+    uint16_t*             indices;
+} XrSceneMeshIndicesUint16MSFT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSceneComputeFeaturesMSFT)(XrInstance instance, XrSystemId systemId, uint32_t featureCapacityInput, uint32_t* featureCountOutput, XrSceneComputeFeatureMSFT* features);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneObserverMSFT)(XrSession session, const XrSceneObserverCreateInfoMSFT* createInfo, XrSceneObserverMSFT* sceneObserver);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneObserverMSFT)(XrSceneObserverMSFT sceneObserver);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneMSFT)(XrSceneObserverMSFT sceneObserver, const XrSceneCreateInfoMSFT* createInfo, XrSceneMSFT* scene);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneMSFT)(XrSceneMSFT scene);
+typedef XrResult (XRAPI_PTR *PFN_xrComputeNewSceneMSFT)(XrSceneObserverMSFT sceneObserver, const XrNewSceneComputeInfoMSFT* computeInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSceneComputeStateMSFT)(XrSceneObserverMSFT sceneObserver, XrSceneComputeStateMSFT* state);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSceneComponentsMSFT)(XrSceneMSFT scene, const XrSceneComponentsGetInfoMSFT* getInfo, XrSceneComponentsMSFT* components);
+typedef XrResult (XRAPI_PTR *PFN_xrLocateSceneComponentsMSFT)(XrSceneMSFT scene, const XrSceneComponentsLocateInfoMSFT* locateInfo, XrSceneComponentLocationsMSFT* locations);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSceneMeshBuffersMSFT)(XrSceneMSFT scene, const XrSceneMeshBuffersGetInfoMSFT* getInfo, XrSceneMeshBuffersMSFT* buffers);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSceneComputeFeaturesMSFT(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    featureCapacityInput,
+    uint32_t*                                   featureCountOutput,
+    XrSceneComputeFeatureMSFT*                  features);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSceneObserverMSFT(
+    XrSession                                   session,
+    const XrSceneObserverCreateInfoMSFT*        createInfo,
+    XrSceneObserverMSFT*                        sceneObserver);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySceneObserverMSFT(
+    XrSceneObserverMSFT                         sceneObserver);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSceneMSFT(
+    XrSceneObserverMSFT                         sceneObserver,
+    const XrSceneCreateInfoMSFT*                createInfo,
+    XrSceneMSFT*                                scene);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySceneMSFT(
+    XrSceneMSFT                                 scene);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrComputeNewSceneMSFT(
+    XrSceneObserverMSFT                         sceneObserver,
+    const XrNewSceneComputeInfoMSFT*            computeInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSceneComputeStateMSFT(
+    XrSceneObserverMSFT                         sceneObserver,
+    XrSceneComputeStateMSFT*                    state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSceneComponentsMSFT(
+    XrSceneMSFT                                 scene,
+    const XrSceneComponentsGetInfoMSFT*         getInfo,
+    XrSceneComponentsMSFT*                      components);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateSceneComponentsMSFT(
+    XrSceneMSFT                                 scene,
+    const XrSceneComponentsLocateInfoMSFT*      locateInfo,
+    XrSceneComponentLocationsMSFT*              locations);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSceneMeshBuffersMSFT(
+    XrSceneMSFT                                 scene,
+    const XrSceneMeshBuffersGetInfoMSFT*        getInfo,
+    XrSceneMeshBuffersMSFT*                     buffers);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_MSFT_scene_understanding_serialization is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_scene_understanding_serialization 1
+#define XR_MSFT_scene_understanding_serialization_SPEC_VERSION 2
+#define XR_MSFT_SCENE_UNDERSTANDING_SERIALIZATION_EXTENSION_NAME "XR_MSFT_scene_understanding_serialization"
+typedef struct XrSerializedSceneFragmentDataGetInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrUuidMSFT                  sceneFragmentId;
+} XrSerializedSceneFragmentDataGetInfoMSFT;
+
+typedef struct XrDeserializeSceneFragmentMSFT {
+    uint32_t          bufferSize;
+    const uint8_t*    buffer;
+} XrDeserializeSceneFragmentMSFT;
+
+typedef struct XrSceneDeserializeInfoMSFT {
+    XrStructureType                          type;
+    const void* XR_MAY_ALIAS                 next;
+    uint32_t                                 fragmentCount;
+    const XrDeserializeSceneFragmentMSFT*    fragments;
+} XrSceneDeserializeInfoMSFT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrDeserializeSceneMSFT)(XrSceneObserverMSFT sceneObserver, const XrSceneDeserializeInfoMSFT* deserializeInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSerializedSceneFragmentDataMSFT)(XrSceneMSFT scene, const XrSerializedSceneFragmentDataGetInfoMSFT* getInfo, uint32_t countInput, uint32_t* readOutput, uint8_t* buffer);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrDeserializeSceneMSFT(
+    XrSceneObserverMSFT                         sceneObserver,
+    const XrSceneDeserializeInfoMSFT*           deserializeInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSerializedSceneFragmentDataMSFT(
+    XrSceneMSFT                                 scene,
+    const XrSerializedSceneFragmentDataGetInfoMSFT* getInfo,
+    uint32_t                                    countInput,
+    uint32_t*                                   readOutput,
+    uint8_t*                                    buffer);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_display_refresh_rate is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_display_refresh_rate 1
+#define XR_FB_display_refresh_rate_SPEC_VERSION 1
+#define XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME "XR_FB_display_refresh_rate"
+typedef struct XrEventDataDisplayRefreshRateChangedFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       fromDisplayRefreshRate;
+    float                       toDisplayRefreshRate;
+} XrEventDataDisplayRefreshRateChangedFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateDisplayRefreshRatesFB)(XrSession session, uint32_t displayRefreshRateCapacityInput, uint32_t* displayRefreshRateCountOutput, float* displayRefreshRates);
+typedef XrResult (XRAPI_PTR *PFN_xrGetDisplayRefreshRateFB)(XrSession session, float* displayRefreshRate);
+typedef XrResult (XRAPI_PTR *PFN_xrRequestDisplayRefreshRateFB)(XrSession session, float displayRefreshRate);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateDisplayRefreshRatesFB(
+    XrSession                                   session,
+    uint32_t                                    displayRefreshRateCapacityInput,
+    uint32_t*                                   displayRefreshRateCountOutput,
+    float*                                      displayRefreshRates);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetDisplayRefreshRateFB(
+    XrSession                                   session,
+    float*                                      displayRefreshRate);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestDisplayRefreshRateFB(
+    XrSession                                   session,
+    float                                       displayRefreshRate);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_HTC_vive_cosmos_controller_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_HTC_vive_cosmos_controller_interaction 1
+#define XR_HTC_vive_cosmos_controller_interaction_SPEC_VERSION 1
+#define XR_HTC_VIVE_COSMOS_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_cosmos_controller_interaction"
+
+
+// XR_HTCX_vive_tracker_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_HTCX_vive_tracker_interaction 1
+#define XR_HTCX_vive_tracker_interaction_SPEC_VERSION 3
+#define XR_HTCX_VIVE_TRACKER_INTERACTION_EXTENSION_NAME "XR_HTCX_vive_tracker_interaction"
+typedef struct XrViveTrackerPathsHTCX {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrPath                persistentPath;
+    XrPath                rolePath;
+} XrViveTrackerPathsHTCX;
+
+typedef struct XrEventDataViveTrackerConnectedHTCX {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrViveTrackerPathsHTCX*     paths;
+} XrEventDataViveTrackerConnectedHTCX;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViveTrackerPathsHTCX)(XrInstance instance, uint32_t pathCapacityInput, uint32_t* pathCountOutput, XrViveTrackerPathsHTCX* paths);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateViveTrackerPathsHTCX(
+    XrInstance                                  instance,
+    uint32_t                                    pathCapacityInput,
+    uint32_t*                                   pathCountOutput,
+    XrViveTrackerPathsHTCX*                     paths);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_HTC_facial_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_HTC_facial_tracking 1
+
+#define XR_FACIAL_EXPRESSION_EYE_COUNT_HTC 14
+
+
+#define XR_FACIAL_EXPRESSION_LIP_COUNT_HTC 37
+
+XR_DEFINE_HANDLE(XrFacialTrackerHTC)
+#define XR_HTC_facial_tracking_SPEC_VERSION 3
+#define XR_HTC_FACIAL_TRACKING_EXTENSION_NAME "XR_HTC_facial_tracking"
+
+typedef enum XrEyeExpressionHTC {
+    XR_EYE_EXPRESSION_LEFT_BLINK_HTC = 0,
+    XR_EYE_EXPRESSION_LEFT_WIDE_HTC = 1,
+    XR_EYE_EXPRESSION_RIGHT_BLINK_HTC = 2,
+    XR_EYE_EXPRESSION_RIGHT_WIDE_HTC = 3,
+    XR_EYE_EXPRESSION_LEFT_SQUEEZE_HTC = 4,
+    XR_EYE_EXPRESSION_RIGHT_SQUEEZE_HTC = 5,
+    XR_EYE_EXPRESSION_LEFT_DOWN_HTC = 6,
+    XR_EYE_EXPRESSION_RIGHT_DOWN_HTC = 7,
+    XR_EYE_EXPRESSION_LEFT_OUT_HTC = 8,
+    XR_EYE_EXPRESSION_RIGHT_IN_HTC = 9,
+    XR_EYE_EXPRESSION_LEFT_IN_HTC = 10,
+    XR_EYE_EXPRESSION_RIGHT_OUT_HTC = 11,
+    XR_EYE_EXPRESSION_LEFT_UP_HTC = 12,
+    XR_EYE_EXPRESSION_RIGHT_UP_HTC = 13,
+    XR_EYE_EXPRESSION_MAX_ENUM_HTC = 0x7FFFFFFF
+} XrEyeExpressionHTC;
+
+typedef enum XrLipExpressionHTC {
+    XR_LIP_EXPRESSION_JAW_RIGHT_HTC = 0,
+    XR_LIP_EXPRESSION_JAW_LEFT_HTC = 1,
+    XR_LIP_EXPRESSION_JAW_FORWARD_HTC = 2,
+    XR_LIP_EXPRESSION_JAW_OPEN_HTC = 3,
+    XR_LIP_EXPRESSION_MOUTH_APE_SHAPE_HTC = 4,
+    XR_LIP_EXPRESSION_MOUTH_UPPER_RIGHT_HTC = 5,
+    XR_LIP_EXPRESSION_MOUTH_UPPER_LEFT_HTC = 6,
+    XR_LIP_EXPRESSION_MOUTH_LOWER_RIGHT_HTC = 7,
+    XR_LIP_EXPRESSION_MOUTH_LOWER_LEFT_HTC = 8,
+    XR_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC = 9,
+    XR_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC = 10,
+    XR_LIP_EXPRESSION_MOUTH_POUT_HTC = 11,
+    XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC = 12,
+    XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC = 13,
+    XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC = 14,
+    XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC = 15,
+    XR_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC = 16,
+    XR_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC = 17,
+    XR_LIP_EXPRESSION_CHEEK_SUCK_HTC = 18,
+    XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC = 19,
+    XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC = 20,
+    XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC = 21,
+    XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNLEFT_HTC = 22,
+    XR_LIP_EXPRESSION_MOUTH_UPPER_INSIDE_HTC = 23,
+    XR_LIP_EXPRESSION_MOUTH_LOWER_INSIDE_HTC = 24,
+    XR_LIP_EXPRESSION_MOUTH_LOWER_OVERLAY_HTC = 25,
+    XR_LIP_EXPRESSION_TONGUE_LONGSTEP1_HTC = 26,
+    XR_LIP_EXPRESSION_TONGUE_LEFT_HTC = 27,
+    XR_LIP_EXPRESSION_TONGUE_RIGHT_HTC = 28,
+    XR_LIP_EXPRESSION_TONGUE_UP_HTC = 29,
+    XR_LIP_EXPRESSION_TONGUE_DOWN_HTC = 30,
+    XR_LIP_EXPRESSION_TONGUE_ROLL_HTC = 31,
+    XR_LIP_EXPRESSION_TONGUE_LONGSTEP2_HTC = 32,
+    XR_LIP_EXPRESSION_TONGUE_UPRIGHT_MORPH_HTC = 33,
+    XR_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC = 34,
+    XR_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC = 35,
+    XR_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC = 36,
+    XR_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC = XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC,
+    XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC = XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC,
+    XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC = XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC,
+    XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC = XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC,
+    XR_LIP_EXPRESSION_MAX_ENUM_HTC = 0x7FFFFFFF
+} XrLipExpressionHTC;
+
+typedef enum XrFacialTrackingTypeHTC {
+    XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC = 1,
+    XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC = 2,
+    XR_FACIAL_TRACKING_TYPE_MAX_ENUM_HTC = 0x7FFFFFFF
+} XrFacialTrackingTypeHTC;
+// XrSystemFacialTrackingPropertiesHTC extends XrSystemProperties
+typedef struct XrSystemFacialTrackingPropertiesHTC {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportEyeFacialTracking;
+    XrBool32              supportLipFacialTracking;
+} XrSystemFacialTrackingPropertiesHTC;
+
+typedef struct XrFacialExpressionsHTC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    isActive;
+    XrTime                      sampleTime;
+    uint32_t                    expressionCount;
+    float*                      expressionWeightings;
+} XrFacialExpressionsHTC;
+
+typedef struct XrFacialTrackerCreateInfoHTC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrFacialTrackingTypeHTC     facialTrackingType;
+} XrFacialTrackerCreateInfoHTC;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateFacialTrackerHTC)(XrSession session, const XrFacialTrackerCreateInfoHTC* createInfo, XrFacialTrackerHTC* facialTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyFacialTrackerHTC)(XrFacialTrackerHTC facialTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrGetFacialExpressionsHTC)(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC* facialExpressions);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateFacialTrackerHTC(
+    XrSession                                   session,
+    const XrFacialTrackerCreateInfoHTC*         createInfo,
+    XrFacialTrackerHTC*                         facialTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFacialTrackerHTC(
+    XrFacialTrackerHTC                          facialTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetFacialExpressionsHTC(
+    XrFacialTrackerHTC                          facialTracker,
+    XrFacialExpressionsHTC*                     facialExpressions);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_HTC_vive_focus3_controller_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_HTC_vive_focus3_controller_interaction 1
+#define XR_HTC_vive_focus3_controller_interaction_SPEC_VERSION 2
+#define XR_HTC_VIVE_FOCUS3_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_focus3_controller_interaction"
+
+
+// XR_HTC_hand_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_HTC_hand_interaction 1
+#define XR_HTC_hand_interaction_SPEC_VERSION 1
+#define XR_HTC_HAND_INTERACTION_EXTENSION_NAME "XR_HTC_hand_interaction"
+
+
+// XR_HTC_vive_wrist_tracker_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_HTC_vive_wrist_tracker_interaction 1
+#define XR_HTC_vive_wrist_tracker_interaction_SPEC_VERSION 1
+#define XR_HTC_VIVE_WRIST_TRACKER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_wrist_tracker_interaction"
+
+
+// XR_FB_color_space is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_color_space 1
+#define XR_FB_color_space_SPEC_VERSION    3
+#define XR_FB_COLOR_SPACE_EXTENSION_NAME  "XR_FB_color_space"
+
+typedef enum XrColorSpaceFB {
+    XR_COLOR_SPACE_UNMANAGED_FB = 0,
+    XR_COLOR_SPACE_REC2020_FB = 1,
+    XR_COLOR_SPACE_REC709_FB = 2,
+    XR_COLOR_SPACE_RIFT_CV1_FB = 3,
+    XR_COLOR_SPACE_RIFT_S_FB = 4,
+    XR_COLOR_SPACE_QUEST_FB = 5,
+    XR_COLOR_SPACE_P3_FB = 6,
+    XR_COLOR_SPACE_ADOBE_RGB_FB = 7,
+    XR_COLOR_SPACE_MAX_ENUM_FB = 0x7FFFFFFF
+} XrColorSpaceFB;
+// XrSystemColorSpacePropertiesFB extends XrSystemProperties
+typedef struct XrSystemColorSpacePropertiesFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrColorSpaceFB        colorSpace;
+} XrSystemColorSpacePropertiesFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateColorSpacesFB)(XrSession session, uint32_t colorSpaceCapacityInput, uint32_t* colorSpaceCountOutput, XrColorSpaceFB* colorSpaces);
+typedef XrResult (XRAPI_PTR *PFN_xrSetColorSpaceFB)(XrSession session, const XrColorSpaceFB colorSpace);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateColorSpacesFB(
+    XrSession                                   session,
+    uint32_t                                    colorSpaceCapacityInput,
+    uint32_t*                                   colorSpaceCountOutput,
+    XrColorSpaceFB*                             colorSpaces);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetColorSpaceFB(
+    XrSession                                   session,
+    const XrColorSpaceFB                        colorSpace);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_hand_tracking_mesh is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_hand_tracking_mesh 1
+#define XR_FB_hand_tracking_mesh_SPEC_VERSION 3
+#define XR_FB_HAND_TRACKING_MESH_EXTENSION_NAME "XR_FB_hand_tracking_mesh"
+typedef struct XrVector4sFB {
+    int16_t    x;
+    int16_t    y;
+    int16_t    z;
+    int16_t    w;
+} XrVector4sFB;
+
+typedef struct XrHandTrackingMeshFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              jointCapacityInput;
+    uint32_t              jointCountOutput;
+    XrPosef*              jointBindPoses;
+    float*                jointRadii;
+    XrHandJointEXT*       jointParents;
+    uint32_t              vertexCapacityInput;
+    uint32_t              vertexCountOutput;
+    XrVector3f*           vertexPositions;
+    XrVector3f*           vertexNormals;
+    XrVector2f*           vertexUVs;
+    XrVector4sFB*         vertexBlendIndices;
+    XrVector4f*           vertexBlendWeights;
+    uint32_t              indexCapacityInput;
+    uint32_t              indexCountOutput;
+    int16_t*              indices;
+} XrHandTrackingMeshFB;
+
+// XrHandTrackingScaleFB extends XrHandJointLocationsEXT
+typedef struct XrHandTrackingScaleFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    float                 sensorOutput;
+    float                 currentOutput;
+    XrBool32              overrideHandScale;
+    float                 overrideValueInput;
+} XrHandTrackingScaleFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetHandMeshFB)(XrHandTrackerEXT handTracker, XrHandTrackingMeshFB* mesh);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetHandMeshFB(
+    XrHandTrackerEXT                            handTracker,
+    XrHandTrackingMeshFB*                       mesh);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_hand_tracking_aim is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_hand_tracking_aim 1
+#define XR_FB_hand_tracking_aim_SPEC_VERSION 2
+#define XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME "XR_FB_hand_tracking_aim"
+typedef XrFlags64 XrHandTrackingAimFlagsFB;
+
+// Flag bits for XrHandTrackingAimFlagsFB
+static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_COMPUTED_BIT_FB = 0x00000001;
+static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_VALID_BIT_FB = 0x00000002;
+static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_INDEX_PINCHING_BIT_FB = 0x00000004;
+static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_MIDDLE_PINCHING_BIT_FB = 0x00000008;
+static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_RING_PINCHING_BIT_FB = 0x00000010;
+static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_LITTLE_PINCHING_BIT_FB = 0x00000020;
+static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_SYSTEM_GESTURE_BIT_FB = 0x00000040;
+static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_DOMINANT_HAND_BIT_FB = 0x00000080;
+static const XrHandTrackingAimFlagsFB XR_HAND_TRACKING_AIM_MENU_PRESSED_BIT_FB = 0x00000100;
+
+// XrHandTrackingAimStateFB extends XrHandJointLocationsEXT
+typedef struct XrHandTrackingAimStateFB {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    XrHandTrackingAimFlagsFB    status;
+    XrPosef                     aimPose;
+    float                       pinchStrengthIndex;
+    float                       pinchStrengthMiddle;
+    float                       pinchStrengthRing;
+    float                       pinchStrengthLittle;
+} XrHandTrackingAimStateFB;
+
+
+
+// XR_FB_hand_tracking_capsules is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_hand_tracking_capsules 1
+#define XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB 2
+#define XR_HAND_TRACKING_CAPSULE_COUNT_FB 19
+#define XR_FB_hand_tracking_capsules_SPEC_VERSION 3
+#define XR_FB_HAND_TRACKING_CAPSULES_EXTENSION_NAME "XR_FB_hand_tracking_capsules"
+#define XR_FB_HAND_TRACKING_CAPSULE_POINT_COUNT XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB
+#define XR_FB_HAND_TRACKING_CAPSULE_COUNT XR_HAND_TRACKING_CAPSULE_COUNT_FB
+typedef struct XrHandCapsuleFB {
+    XrVector3f        points[XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB];
+    float             radius;
+    XrHandJointEXT    joint;
+} XrHandCapsuleFB;
+
+// XrHandTrackingCapsulesStateFB extends XrHandJointLocationsEXT
+typedef struct XrHandTrackingCapsulesStateFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrHandCapsuleFB       capsules[XR_HAND_TRACKING_CAPSULE_COUNT_FB];
+} XrHandTrackingCapsulesStateFB;
+
+
+
+// XR_FB_spatial_entity is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_spatial_entity 1
+XR_DEFINE_ATOM(XrAsyncRequestIdFB)
+#define XR_FB_spatial_entity_SPEC_VERSION 3
+#define XR_FB_SPATIAL_ENTITY_EXTENSION_NAME "XR_FB_spatial_entity"
+
+typedef enum XrSpaceComponentTypeFB {
+    XR_SPACE_COMPONENT_TYPE_LOCATABLE_FB = 0,
+    XR_SPACE_COMPONENT_TYPE_STORABLE_FB = 1,
+    XR_SPACE_COMPONENT_TYPE_SHARABLE_FB = 2,
+    XR_SPACE_COMPONENT_TYPE_BOUNDED_2D_FB = 3,
+    XR_SPACE_COMPONENT_TYPE_BOUNDED_3D_FB = 4,
+    XR_SPACE_COMPONENT_TYPE_SEMANTIC_LABELS_FB = 5,
+    XR_SPACE_COMPONENT_TYPE_ROOM_LAYOUT_FB = 6,
+    XR_SPACE_COMPONENT_TYPE_SPACE_CONTAINER_FB = 7,
+    XR_SPACE_COMPONENT_TYPE_TRIANGLE_MESH_META = 1000269000,
+    XR_SPACE_COMPONENT_TYPE_ROOM_MESH_META = 1000553000,
+    XR_SPACE_COMPONENT_TYPE_MAX_ENUM_FB = 0x7FFFFFFF
+} XrSpaceComponentTypeFB;
+// XrSystemSpatialEntityPropertiesFB extends XrSystemProperties
+typedef struct XrSystemSpatialEntityPropertiesFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    supportsSpatialEntity;
+} XrSystemSpatialEntityPropertiesFB;
+
+typedef struct XrSpatialAnchorCreateInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrPosef                     poseInSpace;
+    XrTime                      time;
+} XrSpatialAnchorCreateInfoFB;
+
+typedef struct XrSpaceComponentStatusSetInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpaceComponentTypeFB      componentType;
+    XrBool32                    enabled;
+    XrDuration                  timeout;
+} XrSpaceComponentStatusSetInfoFB;
+
+typedef struct XrSpaceComponentStatusFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              enabled;
+    XrBool32              changePending;
+} XrSpaceComponentStatusFB;
+
+typedef XrUuid XrUuidEXT;
+
+typedef struct XrEventDataSpatialAnchorCreateCompleteFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+    XrSpace                     space;
+    XrUuidEXT                   uuid;
+} XrEventDataSpatialAnchorCreateCompleteFB;
+
+typedef struct XrEventDataSpaceSetStatusCompleteFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+    XrSpace                     space;
+    XrUuidEXT                   uuid;
+    XrSpaceComponentTypeFB      componentType;
+    XrBool32                    enabled;
+} XrEventDataSpaceSetStatusCompleteFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFB)(XrSession session, const XrSpatialAnchorCreateInfoFB* info, XrAsyncRequestIdFB* requestId);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceUuidFB)(XrSpace space, XrUuidEXT* uuid);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpaceSupportedComponentsFB)(XrSpace space, uint32_t componentTypeCapacityInput, uint32_t* componentTypeCountOutput, XrSpaceComponentTypeFB* componentTypes);
+typedef XrResult (XRAPI_PTR *PFN_xrSetSpaceComponentStatusFB)(XrSpace space, const XrSpaceComponentStatusSetInfoFB* info, XrAsyncRequestIdFB* requestId);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceComponentStatusFB)(XrSpace space, XrSpaceComponentTypeFB componentType, XrSpaceComponentStatusFB* status);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorFB(
+    XrSession                                   session,
+    const XrSpatialAnchorCreateInfoFB*          info,
+    XrAsyncRequestIdFB*                         requestId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceUuidFB(
+    XrSpace                                     space,
+    XrUuidEXT*                                  uuid);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpaceSupportedComponentsFB(
+    XrSpace                                     space,
+    uint32_t                                    componentTypeCapacityInput,
+    uint32_t*                                   componentTypeCountOutput,
+    XrSpaceComponentTypeFB*                     componentTypes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetSpaceComponentStatusFB(
+    XrSpace                                     space,
+    const XrSpaceComponentStatusSetInfoFB*      info,
+    XrAsyncRequestIdFB*                         requestId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceComponentStatusFB(
+    XrSpace                                     space,
+    XrSpaceComponentTypeFB                      componentType,
+    XrSpaceComponentStatusFB*                   status);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_foveation is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_foveation 1
+XR_DEFINE_HANDLE(XrFoveationProfileFB)
+#define XR_FB_foveation_SPEC_VERSION      1
+#define XR_FB_FOVEATION_EXTENSION_NAME    "XR_FB_foveation"
+typedef XrFlags64 XrSwapchainCreateFoveationFlagsFB;
+
+// Flag bits for XrSwapchainCreateFoveationFlagsFB
+static const XrSwapchainCreateFoveationFlagsFB XR_SWAPCHAIN_CREATE_FOVEATION_SCALED_BIN_BIT_FB = 0x00000001;
+static const XrSwapchainCreateFoveationFlagsFB XR_SWAPCHAIN_CREATE_FOVEATION_FRAGMENT_DENSITY_MAP_BIT_FB = 0x00000002;
+
+typedef XrFlags64 XrSwapchainStateFoveationFlagsFB;
+
+// Flag bits for XrSwapchainStateFoveationFlagsFB
+
+typedef struct XrFoveationProfileCreateInfoFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+} XrFoveationProfileCreateInfoFB;
+
+// XrSwapchainCreateInfoFoveationFB extends XrSwapchainCreateInfo
+typedef struct XrSwapchainCreateInfoFoveationFB {
+    XrStructureType                      type;
+    void* XR_MAY_ALIAS                   next;
+    XrSwapchainCreateFoveationFlagsFB    flags;
+} XrSwapchainCreateInfoFoveationFB;
+
+typedef struct XrSwapchainStateFoveationFB {
+    XrStructureType                     type;
+    void* XR_MAY_ALIAS                  next;
+    XrSwapchainStateFoveationFlagsFB    flags;
+    XrFoveationProfileFB                profile;
+} XrSwapchainStateFoveationFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateFoveationProfileFB)(XrSession session, const XrFoveationProfileCreateInfoFB* createInfo, XrFoveationProfileFB* profile);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyFoveationProfileFB)(XrFoveationProfileFB profile);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateFoveationProfileFB(
+    XrSession                                   session,
+    const XrFoveationProfileCreateInfoFB*       createInfo,
+    XrFoveationProfileFB*                       profile);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFoveationProfileFB(
+    XrFoveationProfileFB                        profile);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_foveation_configuration is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_foveation_configuration 1
+#define XR_FB_foveation_configuration_SPEC_VERSION 1
+#define XR_FB_FOVEATION_CONFIGURATION_EXTENSION_NAME "XR_FB_foveation_configuration"
+
+typedef enum XrFoveationLevelFB {
+    XR_FOVEATION_LEVEL_NONE_FB = 0,
+    XR_FOVEATION_LEVEL_LOW_FB = 1,
+    XR_FOVEATION_LEVEL_MEDIUM_FB = 2,
+    XR_FOVEATION_LEVEL_HIGH_FB = 3,
+    XR_FOVEATION_LEVEL_MAX_ENUM_FB = 0x7FFFFFFF
+} XrFoveationLevelFB;
+
+typedef enum XrFoveationDynamicFB {
+    XR_FOVEATION_DYNAMIC_DISABLED_FB = 0,
+    XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_FB = 1,
+    XR_FOVEATION_DYNAMIC_MAX_ENUM_FB = 0x7FFFFFFF
+} XrFoveationDynamicFB;
+// XrFoveationLevelProfileCreateInfoFB extends XrFoveationProfileCreateInfoFB
+typedef struct XrFoveationLevelProfileCreateInfoFB {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    XrFoveationLevelFB      level;
+    float                   verticalOffset;
+    XrFoveationDynamicFB    dynamic;
+} XrFoveationLevelProfileCreateInfoFB;
+
+
+
+// XR_FB_keyboard_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_keyboard_tracking 1
+#define XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB 128
+#define XR_FB_keyboard_tracking_SPEC_VERSION 1
+#define XR_FB_KEYBOARD_TRACKING_EXTENSION_NAME "XR_FB_keyboard_tracking"
+typedef XrFlags64 XrKeyboardTrackingFlagsFB;
+
+// Flag bits for XrKeyboardTrackingFlagsFB
+static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_EXISTS_BIT_FB = 0x00000001;
+static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_LOCAL_BIT_FB = 0x00000002;
+static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_REMOTE_BIT_FB = 0x00000004;
+static const XrKeyboardTrackingFlagsFB XR_KEYBOARD_TRACKING_CONNECTED_BIT_FB = 0x00000008;
+
+typedef XrFlags64 XrKeyboardTrackingQueryFlagsFB;
+
+// Flag bits for XrKeyboardTrackingQueryFlagsFB
+static const XrKeyboardTrackingQueryFlagsFB XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB = 0x00000002;
+static const XrKeyboardTrackingQueryFlagsFB XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB = 0x00000004;
+
+// XrSystemKeyboardTrackingPropertiesFB extends XrSystemProperties
+typedef struct XrSystemKeyboardTrackingPropertiesFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsKeyboardTracking;
+} XrSystemKeyboardTrackingPropertiesFB;
+
+typedef struct XrKeyboardTrackingDescriptionFB {
+    uint64_t                     trackedKeyboardId;
+    XrVector3f                   size;
+    XrKeyboardTrackingFlagsFB    flags;
+    char                         name[XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB];
+} XrKeyboardTrackingDescriptionFB;
+
+typedef struct XrKeyboardSpaceCreateInfoFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint64_t              trackedKeyboardId;
+} XrKeyboardSpaceCreateInfoFB;
+
+typedef struct XrKeyboardTrackingQueryFB {
+    XrStructureType                   type;
+    void* XR_MAY_ALIAS                next;
+    XrKeyboardTrackingQueryFlagsFB    flags;
+} XrKeyboardTrackingQueryFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrQuerySystemTrackedKeyboardFB)(XrSession session, const XrKeyboardTrackingQueryFB* queryInfo, XrKeyboardTrackingDescriptionFB* keyboard);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateKeyboardSpaceFB)(XrSession session, const XrKeyboardSpaceCreateInfoFB* createInfo, XrSpace* keyboardSpace);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrQuerySystemTrackedKeyboardFB(
+    XrSession                                   session,
+    const XrKeyboardTrackingQueryFB*            queryInfo,
+    XrKeyboardTrackingDescriptionFB*            keyboard);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateKeyboardSpaceFB(
+    XrSession                                   session,
+    const XrKeyboardSpaceCreateInfoFB*          createInfo,
+    XrSpace*                                    keyboardSpace);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_triangle_mesh is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_triangle_mesh 1
+XR_DEFINE_HANDLE(XrTriangleMeshFB)
+#define XR_FB_triangle_mesh_SPEC_VERSION  2
+#define XR_FB_TRIANGLE_MESH_EXTENSION_NAME "XR_FB_triangle_mesh"
+
+typedef enum XrWindingOrderFB {
+    XR_WINDING_ORDER_UNKNOWN_FB = 0,
+    XR_WINDING_ORDER_CW_FB = 1,
+    XR_WINDING_ORDER_CCW_FB = 2,
+    XR_WINDING_ORDER_MAX_ENUM_FB = 0x7FFFFFFF
+} XrWindingOrderFB;
+typedef XrFlags64 XrTriangleMeshFlagsFB;
+
+// Flag bits for XrTriangleMeshFlagsFB
+static const XrTriangleMeshFlagsFB XR_TRIANGLE_MESH_MUTABLE_BIT_FB = 0x00000001;
+
+typedef struct XrTriangleMeshCreateInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTriangleMeshFlagsFB       flags;
+    XrWindingOrderFB            windingOrder;
+    uint32_t                    vertexCount;
+    const XrVector3f*           vertexBuffer;
+    uint32_t                    triangleCount;
+    const uint32_t*             indexBuffer;
+} XrTriangleMeshCreateInfoFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateTriangleMeshFB)(XrSession session, const XrTriangleMeshCreateInfoFB* createInfo, XrTriangleMeshFB* outTriangleMesh);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyTriangleMeshFB)(XrTriangleMeshFB mesh);
+typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshGetVertexBufferFB)(XrTriangleMeshFB mesh, XrVector3f** outVertexBuffer);
+typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshGetIndexBufferFB)(XrTriangleMeshFB mesh, uint32_t** outIndexBuffer);
+typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshBeginUpdateFB)(XrTriangleMeshFB mesh);
+typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshEndUpdateFB)(XrTriangleMeshFB mesh, uint32_t vertexCount, uint32_t triangleCount);
+typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshBeginVertexBufferUpdateFB)(XrTriangleMeshFB mesh, uint32_t* outVertexCount);
+typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshEndVertexBufferUpdateFB)(XrTriangleMeshFB mesh);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateTriangleMeshFB(
+    XrSession                                   session,
+    const XrTriangleMeshCreateInfoFB*           createInfo,
+    XrTriangleMeshFB*                           outTriangleMesh);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyTriangleMeshFB(
+    XrTriangleMeshFB                            mesh);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshGetVertexBufferFB(
+    XrTriangleMeshFB                            mesh,
+    XrVector3f**                                outVertexBuffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshGetIndexBufferFB(
+    XrTriangleMeshFB                            mesh,
+    uint32_t**                                  outIndexBuffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshBeginUpdateFB(
+    XrTriangleMeshFB                            mesh);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshEndUpdateFB(
+    XrTriangleMeshFB                            mesh,
+    uint32_t                                    vertexCount,
+    uint32_t                                    triangleCount);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshBeginVertexBufferUpdateFB(
+    XrTriangleMeshFB                            mesh,
+    uint32_t*                                   outVertexCount);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrTriangleMeshEndVertexBufferUpdateFB(
+    XrTriangleMeshFB                            mesh);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_passthrough is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_passthrough 1
+XR_DEFINE_HANDLE(XrPassthroughFB)
+XR_DEFINE_HANDLE(XrPassthroughLayerFB)
+XR_DEFINE_HANDLE(XrGeometryInstanceFB)
+#define XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB 256
+#define XR_FB_passthrough_SPEC_VERSION    5
+#define XR_FB_PASSTHROUGH_EXTENSION_NAME  "XR_FB_passthrough"
+
+typedef enum XrPassthroughLayerPurposeFB {
+    XR_PASSTHROUGH_LAYER_PURPOSE_RECONSTRUCTION_FB = 0,
+    XR_PASSTHROUGH_LAYER_PURPOSE_PROJECTED_FB = 1,
+    XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_HANDS_FB = 1000203001,
+    XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_MASKED_HANDS_FB = 1000203002,
+    XR_PASSTHROUGH_LAYER_PURPOSE_MAX_ENUM_FB = 0x7FFFFFFF
+} XrPassthroughLayerPurposeFB;
+typedef XrFlags64 XrPassthroughCapabilityFlagsFB;
+
+// Flag bits for XrPassthroughCapabilityFlagsFB
+static const XrPassthroughCapabilityFlagsFB XR_PASSTHROUGH_CAPABILITY_BIT_FB = 0x00000001;
+static const XrPassthroughCapabilityFlagsFB XR_PASSTHROUGH_CAPABILITY_COLOR_BIT_FB = 0x00000002;
+static const XrPassthroughCapabilityFlagsFB XR_PASSTHROUGH_CAPABILITY_LAYER_DEPTH_BIT_FB = 0x00000004;
+
+typedef XrFlags64 XrPassthroughFlagsFB;
+
+// Flag bits for XrPassthroughFlagsFB
+static const XrPassthroughFlagsFB XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB = 0x00000001;
+static const XrPassthroughFlagsFB XR_PASSTHROUGH_LAYER_DEPTH_BIT_FB = 0x00000002;
+
+typedef XrFlags64 XrPassthroughStateChangedFlagsFB;
+
+// Flag bits for XrPassthroughStateChangedFlagsFB
+static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_REINIT_REQUIRED_BIT_FB = 0x00000001;
+static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_NON_RECOVERABLE_ERROR_BIT_FB = 0x00000002;
+static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_RECOVERABLE_ERROR_BIT_FB = 0x00000004;
+static const XrPassthroughStateChangedFlagsFB XR_PASSTHROUGH_STATE_CHANGED_RESTORED_ERROR_BIT_FB = 0x00000008;
+
+// XrSystemPassthroughPropertiesFB extends XrSystemProperties
+typedef struct XrSystemPassthroughPropertiesFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    supportsPassthrough;
+} XrSystemPassthroughPropertiesFB;
+
+// XrSystemPassthroughProperties2FB extends XrSystemProperties
+typedef struct XrSystemPassthroughProperties2FB {
+    XrStructureType                   type;
+    const void* XR_MAY_ALIAS          next;
+    XrPassthroughCapabilityFlagsFB    capabilities;
+} XrSystemPassthroughProperties2FB;
+
+typedef struct XrPassthroughCreateInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrPassthroughFlagsFB        flags;
+} XrPassthroughCreateInfoFB;
+
+typedef struct XrPassthroughLayerCreateInfoFB {
+    XrStructureType                type;
+    const void* XR_MAY_ALIAS       next;
+    XrPassthroughFB                passthrough;
+    XrPassthroughFlagsFB           flags;
+    XrPassthroughLayerPurposeFB    purpose;
+} XrPassthroughLayerCreateInfoFB;
+
+typedef struct XrCompositionLayerPassthroughFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCompositionLayerFlags     flags;
+    XrSpace                     space;
+    XrPassthroughLayerFB        layerHandle;
+} XrCompositionLayerPassthroughFB;
+
+typedef struct XrGeometryInstanceCreateInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrPassthroughLayerFB        layer;
+    XrTriangleMeshFB            mesh;
+    XrSpace                     baseSpace;
+    XrPosef                     pose;
+    XrVector3f                  scale;
+} XrGeometryInstanceCreateInfoFB;
+
+typedef struct XrGeometryInstanceTransformFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+    XrPosef                     pose;
+    XrVector3f                  scale;
+} XrGeometryInstanceTransformFB;
+
+typedef struct XrPassthroughStyleFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       textureOpacityFactor;
+    XrColor4f                   edgeColor;
+} XrPassthroughStyleFB;
+
+// XrPassthroughColorMapMonoToRgbaFB extends XrPassthroughStyleFB
+typedef struct XrPassthroughColorMapMonoToRgbaFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrColor4f                   textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB];
+} XrPassthroughColorMapMonoToRgbaFB;
+
+// XrPassthroughColorMapMonoToMonoFB extends XrPassthroughStyleFB
+typedef struct XrPassthroughColorMapMonoToMonoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint8_t                     textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB];
+} XrPassthroughColorMapMonoToMonoFB;
+
+// XrPassthroughBrightnessContrastSaturationFB extends XrPassthroughStyleFB
+typedef struct XrPassthroughBrightnessContrastSaturationFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       brightness;
+    float                       contrast;
+    float                       saturation;
+} XrPassthroughBrightnessContrastSaturationFB;
+
+typedef struct XrEventDataPassthroughStateChangedFB {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrPassthroughStateChangedFlagsFB    flags;
+} XrEventDataPassthroughStateChangedFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughFB)(XrSession session, const XrPassthroughCreateInfoFB* createInfo, XrPassthroughFB* outPassthrough);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughFB)(XrPassthroughFB passthrough);
+typedef XrResult (XRAPI_PTR *PFN_xrPassthroughStartFB)(XrPassthroughFB passthrough);
+typedef XrResult (XRAPI_PTR *PFN_xrPassthroughPauseFB)(XrPassthroughFB passthrough);
+typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughLayerFB)(XrSession session, const XrPassthroughLayerCreateInfoFB* createInfo, XrPassthroughLayerFB* outLayer);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughLayerFB)(XrPassthroughLayerFB layer);
+typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerPauseFB)(XrPassthroughLayerFB layer);
+typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerResumeFB)(XrPassthroughLayerFB layer);
+typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerSetStyleFB)(XrPassthroughLayerFB layer, const XrPassthroughStyleFB* style);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateGeometryInstanceFB)(XrSession session, const XrGeometryInstanceCreateInfoFB* createInfo, XrGeometryInstanceFB* outGeometryInstance);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyGeometryInstanceFB)(XrGeometryInstanceFB instance);
+typedef XrResult (XRAPI_PTR *PFN_xrGeometryInstanceSetTransformFB)(XrGeometryInstanceFB instance, const XrGeometryInstanceTransformFB* transformation);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughFB(
+    XrSession                                   session,
+    const XrPassthroughCreateInfoFB*            createInfo,
+    XrPassthroughFB*                            outPassthrough);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughFB(
+    XrPassthroughFB                             passthrough);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughStartFB(
+    XrPassthroughFB                             passthrough);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughPauseFB(
+    XrPassthroughFB                             passthrough);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughLayerFB(
+    XrSession                                   session,
+    const XrPassthroughLayerCreateInfoFB*       createInfo,
+    XrPassthroughLayerFB*                       outLayer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughLayerFB(
+    XrPassthroughLayerFB                        layer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerPauseFB(
+    XrPassthroughLayerFB                        layer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerResumeFB(
+    XrPassthroughLayerFB                        layer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerSetStyleFB(
+    XrPassthroughLayerFB                        layer,
+    const XrPassthroughStyleFB*                 style);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateGeometryInstanceFB(
+    XrSession                                   session,
+    const XrGeometryInstanceCreateInfoFB*       createInfo,
+    XrGeometryInstanceFB*                       outGeometryInstance);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyGeometryInstanceFB(
+    XrGeometryInstanceFB                        instance);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGeometryInstanceSetTransformFB(
+    XrGeometryInstanceFB                        instance,
+    const XrGeometryInstanceTransformFB*        transformation);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_render_model is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_render_model 1
+
+#define XR_NULL_RENDER_MODEL_KEY_FB 0
+
+XR_DEFINE_ATOM(XrRenderModelKeyFB)
+#define XR_MAX_RENDER_MODEL_NAME_SIZE_FB  64
+#define XR_FB_render_model_SPEC_VERSION   4
+#define XR_FB_RENDER_MODEL_EXTENSION_NAME "XR_FB_render_model"
+typedef XrFlags64 XrRenderModelFlagsFB;
+
+// Flag bits for XrRenderModelFlagsFB
+static const XrRenderModelFlagsFB XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_1_BIT_FB = 0x00000001;
+static const XrRenderModelFlagsFB XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_2_BIT_FB = 0x00000002;
+
+typedef struct XrRenderModelPathInfoFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrPath                path;
+} XrRenderModelPathInfoFB;
+
+typedef struct XrRenderModelPropertiesFB {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    uint32_t                vendorId;
+    char                    modelName[XR_MAX_RENDER_MODEL_NAME_SIZE_FB];
+    XrRenderModelKeyFB      modelKey;
+    uint32_t                modelVersion;
+    XrRenderModelFlagsFB    flags;
+} XrRenderModelPropertiesFB;
+
+typedef struct XrRenderModelBufferFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              bufferCapacityInput;
+    uint32_t              bufferCountOutput;
+    uint8_t*              buffer;
+} XrRenderModelBufferFB;
+
+typedef struct XrRenderModelLoadInfoFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrRenderModelKeyFB    modelKey;
+} XrRenderModelLoadInfoFB;
+
+// XrSystemRenderModelPropertiesFB extends XrSystemProperties
+typedef struct XrSystemRenderModelPropertiesFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsRenderModelLoading;
+} XrSystemRenderModelPropertiesFB;
+
+// XrRenderModelCapabilitiesRequestFB extends XrRenderModelPropertiesFB
+typedef struct XrRenderModelCapabilitiesRequestFB {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    XrRenderModelFlagsFB    flags;
+} XrRenderModelCapabilitiesRequestFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateRenderModelPathsFB)(XrSession session, uint32_t pathCapacityInput, uint32_t* pathCountOutput, XrRenderModelPathInfoFB* paths);
+typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelPropertiesFB)(XrSession session, XrPath path, XrRenderModelPropertiesFB* properties);
+typedef XrResult (XRAPI_PTR *PFN_xrLoadRenderModelFB)(XrSession session, const XrRenderModelLoadInfoFB* info, XrRenderModelBufferFB* buffer);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateRenderModelPathsFB(
+    XrSession                                   session,
+    uint32_t                                    pathCapacityInput,
+    uint32_t*                                   pathCountOutput,
+    XrRenderModelPathInfoFB*                    paths);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelPropertiesFB(
+    XrSession                                   session,
+    XrPath                                      path,
+    XrRenderModelPropertiesFB*                  properties);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLoadRenderModelFB(
+    XrSession                                   session,
+    const XrRenderModelLoadInfoFB*              info,
+    XrRenderModelBufferFB*                      buffer);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_VARJO_foveated_rendering is a preprocessor guard. Do not pass it to API calls.
+#define XR_VARJO_foveated_rendering 1
+#define XR_VARJO_foveated_rendering_SPEC_VERSION 3
+#define XR_VARJO_FOVEATED_RENDERING_EXTENSION_NAME "XR_VARJO_foveated_rendering"
+// XrViewLocateFoveatedRenderingVARJO extends XrViewLocateInfo
+typedef struct XrViewLocateFoveatedRenderingVARJO {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    foveatedRenderingActive;
+} XrViewLocateFoveatedRenderingVARJO;
+
+// XrFoveatedViewConfigurationViewVARJO extends XrViewConfigurationView
+typedef struct XrFoveatedViewConfigurationViewVARJO {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              foveatedRenderingActive;
+} XrFoveatedViewConfigurationViewVARJO;
+
+// XrSystemFoveatedRenderingPropertiesVARJO extends XrSystemProperties
+typedef struct XrSystemFoveatedRenderingPropertiesVARJO {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsFoveatedRendering;
+} XrSystemFoveatedRenderingPropertiesVARJO;
+
+
+
+// XR_VARJO_composition_layer_depth_test is a preprocessor guard. Do not pass it to API calls.
+#define XR_VARJO_composition_layer_depth_test 1
+#define XR_VARJO_composition_layer_depth_test_SPEC_VERSION 2
+#define XR_VARJO_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME "XR_VARJO_composition_layer_depth_test"
+// XrCompositionLayerDepthTestVARJO extends XrCompositionLayerProjection
+typedef struct XrCompositionLayerDepthTestVARJO {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       depthTestRangeNearZ;
+    float                       depthTestRangeFarZ;
+} XrCompositionLayerDepthTestVARJO;
+
+
+
+// XR_VARJO_environment_depth_estimation is a preprocessor guard. Do not pass it to API calls.
+#define XR_VARJO_environment_depth_estimation 1
+#define XR_VARJO_environment_depth_estimation_SPEC_VERSION 1
+#define XR_VARJO_ENVIRONMENT_DEPTH_ESTIMATION_EXTENSION_NAME "XR_VARJO_environment_depth_estimation"
+typedef XrResult (XRAPI_PTR *PFN_xrSetEnvironmentDepthEstimationVARJO)(XrSession session, XrBool32 enabled);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetEnvironmentDepthEstimationVARJO(
+    XrSession                                   session,
+    XrBool32                                    enabled);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_VARJO_marker_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_VARJO_marker_tracking 1
+#define XR_VARJO_marker_tracking_SPEC_VERSION 1
+#define XR_VARJO_MARKER_TRACKING_EXTENSION_NAME "XR_VARJO_marker_tracking"
+// XrSystemMarkerTrackingPropertiesVARJO extends XrSystemProperties
+typedef struct XrSystemMarkerTrackingPropertiesVARJO {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsMarkerTracking;
+} XrSystemMarkerTrackingPropertiesVARJO;
+
+typedef struct XrEventDataMarkerTrackingUpdateVARJO {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint64_t                    markerId;
+    XrBool32                    isActive;
+    XrBool32                    isPredicted;
+    XrTime                      time;
+} XrEventDataMarkerTrackingUpdateVARJO;
+
+typedef struct XrMarkerSpaceCreateInfoVARJO {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint64_t                    markerId;
+    XrPosef                     poseInMarkerSpace;
+} XrMarkerSpaceCreateInfoVARJO;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingVARJO)(XrSession session, XrBool32 enabled);
+typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingTimeoutVARJO)(XrSession session, uint64_t markerId, XrDuration timeout);
+typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingPredictionVARJO)(XrSession session, uint64_t markerId, XrBool32 enable);
+typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerSizeVARJO)(XrSession session, uint64_t markerId, XrExtent2Df* size);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateMarkerSpaceVARJO)(XrSession session, const XrMarkerSpaceCreateInfoVARJO* createInfo, XrSpace* space);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetMarkerTrackingVARJO(
+    XrSession                                   session,
+    XrBool32                                    enabled);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetMarkerTrackingTimeoutVARJO(
+    XrSession                                   session,
+    uint64_t                                    markerId,
+    XrDuration                                  timeout);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetMarkerTrackingPredictionVARJO(
+    XrSession                                   session,
+    uint64_t                                    markerId,
+    XrBool32                                    enable);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerSizeVARJO(
+    XrSession                                   session,
+    uint64_t                                    markerId,
+    XrExtent2Df*                                size);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateMarkerSpaceVARJO(
+    XrSession                                   session,
+    const XrMarkerSpaceCreateInfoVARJO*         createInfo,
+    XrSpace*                                    space);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_VARJO_view_offset is a preprocessor guard. Do not pass it to API calls.
+#define XR_VARJO_view_offset 1
+#define XR_VARJO_view_offset_SPEC_VERSION 1
+#define XR_VARJO_VIEW_OFFSET_EXTENSION_NAME "XR_VARJO_view_offset"
+typedef XrResult (XRAPI_PTR *PFN_xrSetViewOffsetVARJO)(XrSession session, float offset);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetViewOffsetVARJO(
+    XrSession                                   session,
+    float                                       offset);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_VARJO_xr4_controller_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_VARJO_xr4_controller_interaction 1
+#define XR_VARJO_xr4_controller_interaction_SPEC_VERSION 2
+#define XR_VARJO_XR4_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_VARJO_xr4_controller_interaction"
+
+
+// XR_ML_ml2_controller_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_ml2_controller_interaction 1
+#define XR_ML_ml2_controller_interaction_SPEC_VERSION 1
+#define XR_ML_ML2_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_ML_ml2_controller_interaction"
+
+
+// XR_ML_frame_end_info is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_frame_end_info 1
+#define XR_ML_frame_end_info_SPEC_VERSION 1
+#define XR_ML_FRAME_END_INFO_EXTENSION_NAME "XR_ML_frame_end_info"
+typedef XrFlags64 XrFrameEndInfoFlagsML;
+
+// Flag bits for XrFrameEndInfoFlagsML
+static const XrFrameEndInfoFlagsML XR_FRAME_END_INFO_PROTECTED_BIT_ML = 0x00000001;
+static const XrFrameEndInfoFlagsML XR_FRAME_END_INFO_VIGNETTE_BIT_ML = 0x00000002;
+
+// XrFrameEndInfoML extends XrFrameEndInfo
+typedef struct XrFrameEndInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       focusDistance;
+    XrFrameEndInfoFlagsML       flags;
+} XrFrameEndInfoML;
+
+
+
+// XR_ML_global_dimmer is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_global_dimmer 1
+#define XR_ML_global_dimmer_SPEC_VERSION  1
+#define XR_ML_GLOBAL_DIMMER_EXTENSION_NAME "XR_ML_global_dimmer"
+typedef XrFlags64 XrGlobalDimmerFrameEndInfoFlagsML;
+
+// Flag bits for XrGlobalDimmerFrameEndInfoFlagsML
+static const XrGlobalDimmerFrameEndInfoFlagsML XR_GLOBAL_DIMMER_FRAME_END_INFO_ENABLED_BIT_ML = 0x00000001;
+
+// XrGlobalDimmerFrameEndInfoML extends XrFrameEndInfo
+typedef struct XrGlobalDimmerFrameEndInfoML {
+    XrStructureType                      type;
+    const void* XR_MAY_ALIAS             next;
+    float                                dimmerValue;
+    XrGlobalDimmerFrameEndInfoFlagsML    flags;
+} XrGlobalDimmerFrameEndInfoML;
+
+
+
+// XR_ML_marker_understanding is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_marker_understanding 1
+XR_DEFINE_ATOM(XrMarkerML)
+XR_DEFINE_HANDLE(XrMarkerDetectorML)
+#define XR_ML_marker_understanding_SPEC_VERSION 1
+#define XR_ML_MARKER_UNDERSTANDING_EXTENSION_NAME "XR_ML_marker_understanding"
+
+typedef enum XrMarkerDetectorProfileML {
+    XR_MARKER_DETECTOR_PROFILE_DEFAULT_ML = 0,
+    XR_MARKER_DETECTOR_PROFILE_SPEED_ML = 1,
+    XR_MARKER_DETECTOR_PROFILE_ACCURACY_ML = 2,
+    XR_MARKER_DETECTOR_PROFILE_SMALL_TARGETS_ML = 3,
+    XR_MARKER_DETECTOR_PROFILE_LARGE_FOV_ML = 4,
+    XR_MARKER_DETECTOR_PROFILE_CUSTOM_ML = 5,
+    XR_MARKER_DETECTOR_PROFILE_MAX_ENUM_ML = 0x7FFFFFFF
+} XrMarkerDetectorProfileML;
+
+typedef enum XrMarkerTypeML {
+    XR_MARKER_TYPE_ARUCO_ML = 0,
+    XR_MARKER_TYPE_APRIL_TAG_ML = 1,
+    XR_MARKER_TYPE_QR_ML = 2,
+    XR_MARKER_TYPE_EAN_13_ML = 3,
+    XR_MARKER_TYPE_UPC_A_ML = 4,
+    XR_MARKER_TYPE_CODE_128_ML = 5,
+    XR_MARKER_TYPE_MAX_ENUM_ML = 0x7FFFFFFF
+} XrMarkerTypeML;
+
+typedef enum XrMarkerArucoDictML {
+    XR_MARKER_ARUCO_DICT_4X4_50_ML = 0,
+    XR_MARKER_ARUCO_DICT_4X4_100_ML = 1,
+    XR_MARKER_ARUCO_DICT_4X4_250_ML = 2,
+    XR_MARKER_ARUCO_DICT_4X4_1000_ML = 3,
+    XR_MARKER_ARUCO_DICT_5X5_50_ML = 4,
+    XR_MARKER_ARUCO_DICT_5X5_100_ML = 5,
+    XR_MARKER_ARUCO_DICT_5X5_250_ML = 6,
+    XR_MARKER_ARUCO_DICT_5X5_1000_ML = 7,
+    XR_MARKER_ARUCO_DICT_6X6_50_ML = 8,
+    XR_MARKER_ARUCO_DICT_6X6_100_ML = 9,
+    XR_MARKER_ARUCO_DICT_6X6_250_ML = 10,
+    XR_MARKER_ARUCO_DICT_6X6_1000_ML = 11,
+    XR_MARKER_ARUCO_DICT_7X7_50_ML = 12,
+    XR_MARKER_ARUCO_DICT_7X7_100_ML = 13,
+    XR_MARKER_ARUCO_DICT_7X7_250_ML = 14,
+    XR_MARKER_ARUCO_DICT_7X7_1000_ML = 15,
+    XR_MARKER_ARUCO_DICT_MAX_ENUM_ML = 0x7FFFFFFF
+} XrMarkerArucoDictML;
+
+typedef enum XrMarkerAprilTagDictML {
+    XR_MARKER_APRIL_TAG_DICT_16H5_ML = 0,
+    XR_MARKER_APRIL_TAG_DICT_25H9_ML = 1,
+    XR_MARKER_APRIL_TAG_DICT_36H10_ML = 2,
+    XR_MARKER_APRIL_TAG_DICT_36H11_ML = 3,
+    XR_MARKER_APRIL_TAG_DICT_MAX_ENUM_ML = 0x7FFFFFFF
+} XrMarkerAprilTagDictML;
+
+typedef enum XrMarkerDetectorFpsML {
+    XR_MARKER_DETECTOR_FPS_LOW_ML = 0,
+    XR_MARKER_DETECTOR_FPS_MEDIUM_ML = 1,
+    XR_MARKER_DETECTOR_FPS_HIGH_ML = 2,
+    XR_MARKER_DETECTOR_FPS_MAX_ML = 3,
+    XR_MARKER_DETECTOR_FPS_MAX_ENUM_ML = 0x7FFFFFFF
+} XrMarkerDetectorFpsML;
+
+typedef enum XrMarkerDetectorResolutionML {
+    XR_MARKER_DETECTOR_RESOLUTION_LOW_ML = 0,
+    XR_MARKER_DETECTOR_RESOLUTION_MEDIUM_ML = 1,
+    XR_MARKER_DETECTOR_RESOLUTION_HIGH_ML = 2,
+    XR_MARKER_DETECTOR_RESOLUTION_MAX_ENUM_ML = 0x7FFFFFFF
+} XrMarkerDetectorResolutionML;
+
+typedef enum XrMarkerDetectorCameraML {
+    XR_MARKER_DETECTOR_CAMERA_RGB_CAMERA_ML = 0,
+    XR_MARKER_DETECTOR_CAMERA_WORLD_CAMERAS_ML = 1,
+    XR_MARKER_DETECTOR_CAMERA_MAX_ENUM_ML = 0x7FFFFFFF
+} XrMarkerDetectorCameraML;
+
+typedef enum XrMarkerDetectorCornerRefineMethodML {
+    XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_NONE_ML = 0,
+    XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_SUBPIX_ML = 1,
+    XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_CONTOUR_ML = 2,
+    XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_APRIL_TAG_ML = 3,
+    XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_MAX_ENUM_ML = 0x7FFFFFFF
+} XrMarkerDetectorCornerRefineMethodML;
+
+typedef enum XrMarkerDetectorFullAnalysisIntervalML {
+    XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MAX_ML = 0,
+    XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_FAST_ML = 1,
+    XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MEDIUM_ML = 2,
+    XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_SLOW_ML = 3,
+    XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MAX_ENUM_ML = 0x7FFFFFFF
+} XrMarkerDetectorFullAnalysisIntervalML;
+
+typedef enum XrMarkerDetectorStatusML {
+    XR_MARKER_DETECTOR_STATUS_PENDING_ML = 0,
+    XR_MARKER_DETECTOR_STATUS_READY_ML = 1,
+    XR_MARKER_DETECTOR_STATUS_ERROR_ML = 2,
+    XR_MARKER_DETECTOR_STATUS_MAX_ENUM_ML = 0x7FFFFFFF
+} XrMarkerDetectorStatusML;
+// XrSystemMarkerUnderstandingPropertiesML extends XrSystemProperties
+typedef struct XrSystemMarkerUnderstandingPropertiesML {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsMarkerUnderstanding;
+} XrSystemMarkerUnderstandingPropertiesML;
+
+typedef struct XrMarkerDetectorCreateInfoML {
+    XrStructureType              type;
+    const void* XR_MAY_ALIAS     next;
+    XrMarkerDetectorProfileML    profile;
+    XrMarkerTypeML               markerType;
+} XrMarkerDetectorCreateInfoML;
+
+// XrMarkerDetectorArucoInfoML extends XrMarkerDetectorCreateInfoML
+typedef struct XrMarkerDetectorArucoInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrMarkerArucoDictML         arucoDict;
+} XrMarkerDetectorArucoInfoML;
+
+// XrMarkerDetectorSizeInfoML extends XrMarkerDetectorCreateInfoML
+typedef struct XrMarkerDetectorSizeInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       markerLength;
+} XrMarkerDetectorSizeInfoML;
+
+// XrMarkerDetectorAprilTagInfoML extends XrMarkerDetectorCreateInfoML
+typedef struct XrMarkerDetectorAprilTagInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrMarkerAprilTagDictML      aprilTagDict;
+} XrMarkerDetectorAprilTagInfoML;
+
+// XrMarkerDetectorCustomProfileInfoML extends XrMarkerDetectorCreateInfoML
+typedef struct XrMarkerDetectorCustomProfileInfoML {
+    XrStructureType                           type;
+    const void* XR_MAY_ALIAS                  next;
+    XrMarkerDetectorFpsML                     fpsHint;
+    XrMarkerDetectorResolutionML              resolutionHint;
+    XrMarkerDetectorCameraML                  cameraHint;
+    XrMarkerDetectorCornerRefineMethodML      cornerRefineMethod;
+    XrBool32                                  useEdgeRefinement;
+    XrMarkerDetectorFullAnalysisIntervalML    fullAnalysisIntervalHint;
+} XrMarkerDetectorCustomProfileInfoML;
+
+typedef struct XrMarkerDetectorSnapshotInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrMarkerDetectorSnapshotInfoML;
+
+typedef struct XrMarkerDetectorStateML {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    XrMarkerDetectorStatusML    state;
+} XrMarkerDetectorStateML;
+
+typedef struct XrMarkerSpaceCreateInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrMarkerDetectorML          markerDetector;
+    XrMarkerML                  marker;
+    XrPosef                     poseInMarkerSpace;
+} XrMarkerSpaceCreateInfoML;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateMarkerDetectorML)(XrSession session, const XrMarkerDetectorCreateInfoML* createInfo, XrMarkerDetectorML* markerDetector);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyMarkerDetectorML)(XrMarkerDetectorML markerDetector);
+typedef XrResult (XRAPI_PTR *PFN_xrSnapshotMarkerDetectorML)(XrMarkerDetectorML markerDetector, XrMarkerDetectorSnapshotInfoML* snapshotInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerDetectorStateML)(XrMarkerDetectorML markerDetector, XrMarkerDetectorStateML* state);
+typedef XrResult (XRAPI_PTR *PFN_xrGetMarkersML)(XrMarkerDetectorML markerDetector, uint32_t markerCapacityInput, uint32_t* markerCountOutput, XrMarkerML* markers);
+typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerReprojectionErrorML)(XrMarkerDetectorML markerDetector, XrMarkerML marker, float* reprojectionErrorMeters);
+typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerLengthML)(XrMarkerDetectorML markerDetector, XrMarkerML marker, float* meters);
+typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerNumberML)(XrMarkerDetectorML markerDetector, XrMarkerML marker, uint64_t* number);
+typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerStringML)(XrMarkerDetectorML markerDetector, XrMarkerML marker, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateMarkerSpaceML)(XrSession session, const XrMarkerSpaceCreateInfoML* createInfo, XrSpace* space);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateMarkerDetectorML(
+    XrSession                                   session,
+    const XrMarkerDetectorCreateInfoML*         createInfo,
+    XrMarkerDetectorML*                         markerDetector);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyMarkerDetectorML(
+    XrMarkerDetectorML                          markerDetector);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSnapshotMarkerDetectorML(
+    XrMarkerDetectorML                          markerDetector,
+    XrMarkerDetectorSnapshotInfoML*             snapshotInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerDetectorStateML(
+    XrMarkerDetectorML                          markerDetector,
+    XrMarkerDetectorStateML*                    state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkersML(
+    XrMarkerDetectorML                          markerDetector,
+    uint32_t                                    markerCapacityInput,
+    uint32_t*                                   markerCountOutput,
+    XrMarkerML*                                 markers);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerReprojectionErrorML(
+    XrMarkerDetectorML                          markerDetector,
+    XrMarkerML                                  marker,
+    float*                                      reprojectionErrorMeters);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerLengthML(
+    XrMarkerDetectorML                          markerDetector,
+    XrMarkerML                                  marker,
+    float*                                      meters);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerNumberML(
+    XrMarkerDetectorML                          markerDetector,
+    XrMarkerML                                  marker,
+    uint64_t*                                   number);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerStringML(
+    XrMarkerDetectorML                          markerDetector,
+    XrMarkerML                                  marker,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    char*                                       buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateMarkerSpaceML(
+    XrSession                                   session,
+    const XrMarkerSpaceCreateInfoML*            createInfo,
+    XrSpace*                                    space);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ML_localization_map is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_localization_map 1
+XR_DEFINE_HANDLE(XrExportedLocalizationMapML)
+#define XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML 64
+#define XR_ML_localization_map_SPEC_VERSION 1
+#define XR_ML_LOCALIZATION_MAP_EXTENSION_NAME "XR_ML_localization_map"
+
+typedef enum XrLocalizationMapStateML {
+    XR_LOCALIZATION_MAP_STATE_NOT_LOCALIZED_ML = 0,
+    XR_LOCALIZATION_MAP_STATE_LOCALIZED_ML = 1,
+    XR_LOCALIZATION_MAP_STATE_LOCALIZATION_PENDING_ML = 2,
+    XR_LOCALIZATION_MAP_STATE_LOCALIZATION_SLEEPING_BEFORE_RETRY_ML = 3,
+    XR_LOCALIZATION_MAP_STATE_MAX_ENUM_ML = 0x7FFFFFFF
+} XrLocalizationMapStateML;
+
+typedef enum XrLocalizationMapTypeML {
+    XR_LOCALIZATION_MAP_TYPE_ON_DEVICE_ML = 0,
+    XR_LOCALIZATION_MAP_TYPE_CLOUD_ML = 1,
+    XR_LOCALIZATION_MAP_TYPE_MAX_ENUM_ML = 0x7FFFFFFF
+} XrLocalizationMapTypeML;
+
+typedef enum XrLocalizationMapConfidenceML {
+    XR_LOCALIZATION_MAP_CONFIDENCE_POOR_ML = 0,
+    XR_LOCALIZATION_MAP_CONFIDENCE_FAIR_ML = 1,
+    XR_LOCALIZATION_MAP_CONFIDENCE_GOOD_ML = 2,
+    XR_LOCALIZATION_MAP_CONFIDENCE_EXCELLENT_ML = 3,
+    XR_LOCALIZATION_MAP_CONFIDENCE_MAX_ENUM_ML = 0x7FFFFFFF
+} XrLocalizationMapConfidenceML;
+typedef XrFlags64 XrLocalizationMapErrorFlagsML;
+
+// Flag bits for XrLocalizationMapErrorFlagsML
+static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_UNKNOWN_BIT_ML = 0x00000001;
+static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_OUT_OF_MAPPED_AREA_BIT_ML = 0x00000002;
+static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_LOW_FEATURE_COUNT_BIT_ML = 0x00000004;
+static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_EXCESSIVE_MOTION_BIT_ML = 0x00000008;
+static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_LOW_LIGHT_BIT_ML = 0x00000010;
+static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_HEADPOSE_BIT_ML = 0x00000020;
+
+typedef struct XrLocalizationMapML {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    char                       name[XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML];
+    XrUuidEXT                  mapUuid;
+    XrLocalizationMapTypeML    mapType;
+} XrLocalizationMapML;
+
+typedef struct XrEventDataLocalizationChangedML {
+     XrStructureType                 type;
+    const void* XR_MAY_ALIAS         next;
+    XrSession                        session;
+    XrLocalizationMapStateML         state;
+    XrLocalizationMapML              map;
+    XrLocalizationMapConfidenceML    confidence;
+    XrLocalizationMapErrorFlagsML    errorFlags;
+} XrEventDataLocalizationChangedML;
+
+typedef struct XrLocalizationMapQueryInfoBaseHeaderML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrLocalizationMapQueryInfoBaseHeaderML;
+
+typedef struct XrMapLocalizationRequestInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrUuidEXT                   mapUuid;
+} XrMapLocalizationRequestInfoML;
+
+typedef struct XrLocalizationMapImportInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    size;
+    char*                       data;
+} XrLocalizationMapImportInfoML;
+
+typedef struct XrLocalizationEnableEventsInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    enabled;
+} XrLocalizationEnableEventsInfoML;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnableLocalizationEventsML)(XrSession session, const XrLocalizationEnableEventsInfoML * info);
+typedef XrResult (XRAPI_PTR *PFN_xrQueryLocalizationMapsML)(XrSession session, const XrLocalizationMapQueryInfoBaseHeaderML* queryInfo, uint32_t mapCapacityInput, uint32_t * mapCountOutput, XrLocalizationMapML* maps);
+typedef XrResult (XRAPI_PTR *PFN_xrRequestMapLocalizationML)(XrSession session, const XrMapLocalizationRequestInfoML* requestInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrImportLocalizationMapML)(XrSession session, const XrLocalizationMapImportInfoML* importInfo, XrUuidEXT* mapUuid);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateExportedLocalizationMapML)(XrSession session, const XrUuidEXT* mapUuid, XrExportedLocalizationMapML* map);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyExportedLocalizationMapML)(XrExportedLocalizationMapML map);
+typedef XrResult (XRAPI_PTR *PFN_xrGetExportedLocalizationMapDataML)(XrExportedLocalizationMapML map, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnableLocalizationEventsML(
+    XrSession                                   session,
+    const XrLocalizationEnableEventsInfoML *    info);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrQueryLocalizationMapsML(
+    XrSession                                   session,
+    const XrLocalizationMapQueryInfoBaseHeaderML* queryInfo,
+    uint32_t                                    mapCapacityInput,
+    uint32_t *                                  mapCountOutput,
+    XrLocalizationMapML*                        maps);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestMapLocalizationML(
+    XrSession                                   session,
+    const XrMapLocalizationRequestInfoML*       requestInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrImportLocalizationMapML(
+    XrSession                                   session,
+    const XrLocalizationMapImportInfoML*        importInfo,
+    XrUuidEXT*                                  mapUuid);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateExportedLocalizationMapML(
+    XrSession                                   session,
+    const XrUuidEXT*                            mapUuid,
+    XrExportedLocalizationMapML*                map);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyExportedLocalizationMapML(
+    XrExportedLocalizationMapML                 map);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetExportedLocalizationMapDataML(
+    XrExportedLocalizationMapML                 map,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    char*                                       buffer);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ML_spatial_anchors is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_spatial_anchors 1
+XR_DEFINE_OPAQUE_64(XrFutureEXT)
+#define XR_ML_spatial_anchors_SPEC_VERSION 1
+#define XR_ML_SPATIAL_ANCHORS_EXTENSION_NAME "XR_ML_spatial_anchors"
+
+typedef enum XrSpatialAnchorConfidenceML {
+    XR_SPATIAL_ANCHOR_CONFIDENCE_LOW_ML = 0,
+    XR_SPATIAL_ANCHOR_CONFIDENCE_MEDIUM_ML = 1,
+    XR_SPATIAL_ANCHOR_CONFIDENCE_HIGH_ML = 2,
+    XR_SPATIAL_ANCHOR_CONFIDENCE_MAX_ENUM_ML = 0x7FFFFFFF
+} XrSpatialAnchorConfidenceML;
+typedef struct XR_MAY_ALIAS XrSpatialAnchorsCreateInfoBaseHeaderML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpatialAnchorsCreateInfoBaseHeaderML;
+
+typedef struct XrSpatialAnchorsCreateInfoFromPoseML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrPosef                     poseInBaseSpace;
+    XrTime                      time;
+} XrSpatialAnchorsCreateInfoFromPoseML;
+
+typedef struct XrCreateSpatialAnchorsCompletionML {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrResult              futureResult;
+    uint32_t              spaceCount;
+    XrSpace*              spaces;
+} XrCreateSpatialAnchorsCompletionML;
+
+typedef struct XrSpatialAnchorStateML {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    XrSpatialAnchorConfidenceML    confidence;
+} XrSpatialAnchorStateML;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorsAsyncML)(XrSession session, const XrSpatialAnchorsCreateInfoBaseHeaderML* createInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorsCompleteML)(XrSession session, XrFutureEXT future, XrCreateSpatialAnchorsCompletionML* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialAnchorStateML)(XrSpace anchor, XrSpatialAnchorStateML* state);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorsAsyncML(
+    XrSession                                   session,
+    const XrSpatialAnchorsCreateInfoBaseHeaderML* createInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorsCompleteML(
+    XrSession                                   session,
+    XrFutureEXT                                 future,
+    XrCreateSpatialAnchorsCompletionML*         completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialAnchorStateML(
+    XrSpace                                     anchor,
+    XrSpatialAnchorStateML*                     state);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ML_spatial_anchors_storage is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_spatial_anchors_storage 1
+XR_DEFINE_HANDLE(XrSpatialAnchorsStorageML)
+#define XR_ML_spatial_anchors_storage_SPEC_VERSION 1
+#define XR_ML_SPATIAL_ANCHORS_STORAGE_EXTENSION_NAME "XR_ML_spatial_anchors_storage"
+typedef struct XrSpatialAnchorsCreateStorageInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpatialAnchorsCreateStorageInfoML;
+
+typedef struct XR_MAY_ALIAS XrSpatialAnchorsQueryInfoBaseHeaderML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpatialAnchorsQueryInfoBaseHeaderML;
+
+typedef struct XrSpatialAnchorsQueryInfoRadiusML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrVector3f                  center;
+    XrTime                      time;
+    float                       radius;
+} XrSpatialAnchorsQueryInfoRadiusML;
+
+typedef struct XrSpatialAnchorsQueryCompletionML {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrResult              futureResult;
+    uint32_t              uuidCapacityInput;
+    uint32_t              uuidCountOutput;
+    XrUuidEXT*            uuids;
+} XrSpatialAnchorsQueryCompletionML;
+
+typedef struct XrSpatialAnchorsCreateInfoFromUuidsML {
+    XrStructureType              type;
+    const void* XR_MAY_ALIAS     next;
+    XrSpatialAnchorsStorageML    storage;
+    uint32_t                     uuidCount;
+    const XrUuidEXT*             uuids;
+} XrSpatialAnchorsCreateInfoFromUuidsML;
+
+typedef struct XrSpatialAnchorsPublishInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    anchorCount;
+    const XrSpace*              anchors;
+    uint64_t                    expiration;
+} XrSpatialAnchorsPublishInfoML;
+
+typedef struct XrSpatialAnchorsPublishCompletionML {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrResult              futureResult;
+    uint32_t              uuidCount;
+    XrUuidEXT*            uuids;
+} XrSpatialAnchorsPublishCompletionML;
+
+typedef struct XrSpatialAnchorsDeleteInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    uuidCount;
+    const XrUuidEXT*            uuids;
+} XrSpatialAnchorsDeleteInfoML;
+
+typedef struct XrSpatialAnchorsDeleteCompletionML {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrResult              futureResult;
+} XrSpatialAnchorsDeleteCompletionML;
+
+typedef struct XrSpatialAnchorsUpdateExpirationInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    uuidCount;
+    const XrUuidEXT*            uuids;
+    uint64_t                    expiration;
+} XrSpatialAnchorsUpdateExpirationInfoML;
+
+typedef struct XrSpatialAnchorsUpdateExpirationCompletionML {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrResult              futureResult;
+} XrSpatialAnchorsUpdateExpirationCompletionML;
+
+typedef struct XrSpatialAnchorCompletionResultML {
+    XrUuidEXT    uuid;
+    XrResult     result;
+} XrSpatialAnchorCompletionResultML;
+
+// XrSpatialAnchorsPublishCompletionDetailsML extends XrSpatialAnchorsPublishCompletionML
+typedef struct XrSpatialAnchorsPublishCompletionDetailsML {
+    XrStructureType                       type;
+    void* XR_MAY_ALIAS                    next;
+    uint32_t                              resultCount;
+    XrSpatialAnchorCompletionResultML*    results;
+} XrSpatialAnchorsPublishCompletionDetailsML;
+
+// XrSpatialAnchorsDeleteCompletionDetailsML extends XrSpatialAnchorsDeleteCompletionML
+typedef struct XrSpatialAnchorsDeleteCompletionDetailsML {
+    XrStructureType                       type;
+    void* XR_MAY_ALIAS                    next;
+    uint32_t                              resultCount;
+    XrSpatialAnchorCompletionResultML*    results;
+} XrSpatialAnchorsDeleteCompletionDetailsML;
+
+// XrSpatialAnchorsUpdateExpirationCompletionDetailsML extends XrSpatialAnchorsUpdateExpirationCompletionML
+typedef struct XrSpatialAnchorsUpdateExpirationCompletionDetailsML {
+    XrStructureType                       type;
+    void* XR_MAY_ALIAS                    next;
+    uint32_t                              resultCount;
+    XrSpatialAnchorCompletionResultML*    results;
+} XrSpatialAnchorsUpdateExpirationCompletionDetailsML;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorsStorageML)(XrSession session, const XrSpatialAnchorsCreateStorageInfoML* createInfo, XrSpatialAnchorsStorageML* storage);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorsStorageML)(XrSpatialAnchorsStorageML storage);
+typedef XrResult (XRAPI_PTR *PFN_xrQuerySpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsQueryInfoBaseHeaderML* queryInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrQuerySpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsQueryCompletionML* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrPublishSpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsPublishInfoML* publishInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrPublishSpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsPublishCompletionML* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrDeleteSpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsDeleteInfoML* deleteInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrDeleteSpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsDeleteCompletionML* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrUpdateSpatialAnchorsExpirationAsyncML)(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsUpdateExpirationInfoML* updateInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrUpdateSpatialAnchorsExpirationCompleteML)(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsUpdateExpirationCompletionML* completion);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorsStorageML(
+    XrSession                                   session,
+    const XrSpatialAnchorsCreateStorageInfoML*  createInfo,
+    XrSpatialAnchorsStorageML*                  storage);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialAnchorsStorageML(
+    XrSpatialAnchorsStorageML                   storage);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrQuerySpatialAnchorsAsyncML(
+    XrSpatialAnchorsStorageML                   storage,
+    const XrSpatialAnchorsQueryInfoBaseHeaderML* queryInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrQuerySpatialAnchorsCompleteML(
+    XrSpatialAnchorsStorageML                   storage,
+    XrFutureEXT                                 future,
+    XrSpatialAnchorsQueryCompletionML*          completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPublishSpatialAnchorsAsyncML(
+    XrSpatialAnchorsStorageML                   storage,
+    const XrSpatialAnchorsPublishInfoML*        publishInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPublishSpatialAnchorsCompleteML(
+    XrSpatialAnchorsStorageML                   storage,
+    XrFutureEXT                                 future,
+    XrSpatialAnchorsPublishCompletionML*        completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDeleteSpatialAnchorsAsyncML(
+    XrSpatialAnchorsStorageML                   storage,
+    const XrSpatialAnchorsDeleteInfoML*         deleteInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDeleteSpatialAnchorsCompleteML(
+    XrSpatialAnchorsStorageML                   storage,
+    XrFutureEXT                                 future,
+    XrSpatialAnchorsDeleteCompletionML*         completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSpatialAnchorsExpirationAsyncML(
+    XrSpatialAnchorsStorageML                   storage,
+    const XrSpatialAnchorsUpdateExpirationInfoML* updateInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSpatialAnchorsExpirationCompleteML(
+    XrSpatialAnchorsStorageML                   storage,
+    XrFutureEXT                                 future,
+    XrSpatialAnchorsUpdateExpirationCompletionML* completion);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_MSFT_spatial_anchor_persistence is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_spatial_anchor_persistence 1
+XR_DEFINE_HANDLE(XrSpatialAnchorStoreConnectionMSFT)
+#define XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT 256
+#define XR_MSFT_spatial_anchor_persistence_SPEC_VERSION 2
+#define XR_MSFT_SPATIAL_ANCHOR_PERSISTENCE_EXTENSION_NAME "XR_MSFT_spatial_anchor_persistence"
+typedef struct XrSpatialAnchorPersistenceNameMSFT {
+    char    name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT];
+} XrSpatialAnchorPersistenceNameMSFT;
+
+typedef struct XrSpatialAnchorPersistenceInfoMSFT {
+    XrStructureType                       type;
+    const void* XR_MAY_ALIAS              next;
+    XrSpatialAnchorPersistenceNameMSFT    spatialAnchorPersistenceName;
+    XrSpatialAnchorMSFT                   spatialAnchor;
+} XrSpatialAnchorPersistenceInfoMSFT;
+
+typedef struct XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT {
+    XrStructureType                       type;
+    const void* XR_MAY_ALIAS              next;
+    XrSpatialAnchorStoreConnectionMSFT    spatialAnchorStore;
+    XrSpatialAnchorPersistenceNameMSFT    spatialAnchorPersistenceName;
+} XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorStoreConnectionMSFT)(XrSession session, XrSpatialAnchorStoreConnectionMSFT* spatialAnchorStore);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorStoreConnectionMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore);
+typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceInfoMSFT* spatialAnchorPersistenceInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePersistedSpatialAnchorNamesMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, uint32_t spatialAnchorNameCapacityInput, uint32_t* spatialAnchorNameCountOutput, XrSpatialAnchorPersistenceNameMSFT* spatialAnchorNames);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFromPersistedNameMSFT)(XrSession session, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT* spatialAnchorCreateInfo, XrSpatialAnchorMSFT* spatialAnchor);
+typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceNameMSFT* spatialAnchorPersistenceName);
+typedef XrResult (XRAPI_PTR *PFN_xrClearSpatialAnchorStoreMSFT)(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorStoreConnectionMSFT(
+    XrSession                                   session,
+    XrSpatialAnchorStoreConnectionMSFT*         spatialAnchorStore);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialAnchorStoreConnectionMSFT(
+    XrSpatialAnchorStoreConnectionMSFT          spatialAnchorStore);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPersistSpatialAnchorMSFT(
+    XrSpatialAnchorStoreConnectionMSFT          spatialAnchorStore,
+    const XrSpatialAnchorPersistenceInfoMSFT*   spatialAnchorPersistenceInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumeratePersistedSpatialAnchorNamesMSFT(
+    XrSpatialAnchorStoreConnectionMSFT          spatialAnchorStore,
+    uint32_t                                    spatialAnchorNameCapacityInput,
+    uint32_t*                                   spatialAnchorNameCountOutput,
+    XrSpatialAnchorPersistenceNameMSFT*         spatialAnchorNames);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorFromPersistedNameMSFT(
+    XrSession                                   session,
+    const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT* spatialAnchorCreateInfo,
+    XrSpatialAnchorMSFT*                        spatialAnchor);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistSpatialAnchorMSFT(
+    XrSpatialAnchorStoreConnectionMSFT          spatialAnchorStore,
+    const XrSpatialAnchorPersistenceNameMSFT*   spatialAnchorPersistenceName);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrClearSpatialAnchorStoreMSFT(
+    XrSpatialAnchorStoreConnectionMSFT          spatialAnchorStore);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_MSFT_scene_marker is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_scene_marker 1
+#define XR_MSFT_scene_marker_SPEC_VERSION 1
+#define XR_MSFT_SCENE_MARKER_EXTENSION_NAME "XR_MSFT_scene_marker"
+
+typedef enum XrSceneMarkerTypeMSFT {
+    XR_SCENE_MARKER_TYPE_QR_CODE_MSFT = 1,
+    XR_SCENE_MARKER_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrSceneMarkerTypeMSFT;
+
+typedef enum XrSceneMarkerQRCodeSymbolTypeMSFT {
+    XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_QR_CODE_MSFT = 1,
+    XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_MICRO_QR_CODE_MSFT = 2,
+    XR_SCENE_MARKER_QRCODE_SYMBOL_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF
+} XrSceneMarkerQRCodeSymbolTypeMSFT;
+typedef struct XrSceneMarkerMSFT {
+    XrSceneMarkerTypeMSFT    markerType;
+    XrTime                   lastSeenTime;
+    XrOffset2Df              center;
+    XrExtent2Df              size;
+} XrSceneMarkerMSFT;
+
+// XrSceneMarkersMSFT extends XrSceneComponentsMSFT
+typedef struct XrSceneMarkersMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    sceneMarkerCapacityInput;
+    XrSceneMarkerMSFT*          sceneMarkers;
+} XrSceneMarkersMSFT;
+
+// XrSceneMarkerTypeFilterMSFT extends XrSceneComponentsGetInfoMSFT
+typedef struct XrSceneMarkerTypeFilterMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    markerTypeCount;
+    XrSceneMarkerTypeMSFT*      markerTypes;
+} XrSceneMarkerTypeFilterMSFT;
+
+typedef struct XrSceneMarkerQRCodeMSFT {
+    XrSceneMarkerQRCodeSymbolTypeMSFT    symbolType;
+    uint8_t                              version;
+} XrSceneMarkerQRCodeMSFT;
+
+// XrSceneMarkerQRCodesMSFT extends XrSceneComponentsMSFT
+typedef struct XrSceneMarkerQRCodesMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    qrCodeCapacityInput;
+    XrSceneMarkerQRCodeMSFT*    qrCodes;
+} XrSceneMarkerQRCodesMSFT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetSceneMarkerRawDataMSFT)(XrSceneMSFT scene, const XrUuidMSFT* markerId, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, uint8_t* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSceneMarkerDecodedStringMSFT)(XrSceneMSFT scene, const XrUuidMSFT* markerId, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSceneMarkerRawDataMSFT(
+    XrSceneMSFT                                 scene,
+    const XrUuidMSFT*                           markerId,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    uint8_t*                                    buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSceneMarkerDecodedStringMSFT(
+    XrSceneMSFT                                 scene,
+    const XrUuidMSFT*                           markerId,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    char*                                       buffer);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ULTRALEAP_hand_tracking_forearm is a preprocessor guard. Do not pass it to API calls.
+#define XR_ULTRALEAP_hand_tracking_forearm 1
+
+#define XR_HAND_FOREARM_JOINT_COUNT_ULTRALEAP 27
+
+#define XR_ULTRALEAP_hand_tracking_forearm_SPEC_VERSION 1
+#define XR_ULTRALEAP_HAND_TRACKING_FOREARM_EXTENSION_NAME "XR_ULTRALEAP_hand_tracking_forearm"
+
+typedef enum XrHandForearmJointULTRALEAP {
+    XR_HAND_FOREARM_JOINT_PALM_ULTRALEAP = 0,
+    XR_HAND_FOREARM_JOINT_WRIST_ULTRALEAP = 1,
+    XR_HAND_FOREARM_JOINT_THUMB_METACARPAL_ULTRALEAP = 2,
+    XR_HAND_FOREARM_JOINT_THUMB_PROXIMAL_ULTRALEAP = 3,
+    XR_HAND_FOREARM_JOINT_THUMB_DISTAL_ULTRALEAP = 4,
+    XR_HAND_FOREARM_JOINT_THUMB_TIP_ULTRALEAP = 5,
+    XR_HAND_FOREARM_JOINT_INDEX_METACARPAL_ULTRALEAP = 6,
+    XR_HAND_FOREARM_JOINT_INDEX_PROXIMAL_ULTRALEAP = 7,
+    XR_HAND_FOREARM_JOINT_INDEX_INTERMEDIATE_ULTRALEAP = 8,
+    XR_HAND_FOREARM_JOINT_INDEX_DISTAL_ULTRALEAP = 9,
+    XR_HAND_FOREARM_JOINT_INDEX_TIP_ULTRALEAP = 10,
+    XR_HAND_FOREARM_JOINT_MIDDLE_METACARPAL_ULTRALEAP = 11,
+    XR_HAND_FOREARM_JOINT_MIDDLE_PROXIMAL_ULTRALEAP = 12,
+    XR_HAND_FOREARM_JOINT_MIDDLE_INTERMEDIATE_ULTRALEAP = 13,
+    XR_HAND_FOREARM_JOINT_MIDDLE_DISTAL_ULTRALEAP = 14,
+    XR_HAND_FOREARM_JOINT_MIDDLE_TIP_ULTRALEAP = 15,
+    XR_HAND_FOREARM_JOINT_RING_METACARPAL_ULTRALEAP = 16,
+    XR_HAND_FOREARM_JOINT_RING_PROXIMAL_ULTRALEAP = 17,
+    XR_HAND_FOREARM_JOINT_RING_INTERMEDIATE_ULTRALEAP = 18,
+    XR_HAND_FOREARM_JOINT_RING_DISTAL_ULTRALEAP = 19,
+    XR_HAND_FOREARM_JOINT_RING_TIP_ULTRALEAP = 20,
+    XR_HAND_FOREARM_JOINT_LITTLE_METACARPAL_ULTRALEAP = 21,
+    XR_HAND_FOREARM_JOINT_LITTLE_PROXIMAL_ULTRALEAP = 22,
+    XR_HAND_FOREARM_JOINT_LITTLE_INTERMEDIATE_ULTRALEAP = 23,
+    XR_HAND_FOREARM_JOINT_LITTLE_DISTAL_ULTRALEAP = 24,
+    XR_HAND_FOREARM_JOINT_LITTLE_TIP_ULTRALEAP = 25,
+    XR_HAND_FOREARM_JOINT_ELBOW_ULTRALEAP = 26,
+    XR_HAND_FOREARM_JOINT_MAX_ENUM_ULTRALEAP = 0x7FFFFFFF
+} XrHandForearmJointULTRALEAP;
+
+
+// XR_FB_spatial_entity_query is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_spatial_entity_query 1
+#define XR_FB_spatial_entity_query_SPEC_VERSION 1
+#define XR_FB_SPATIAL_ENTITY_QUERY_EXTENSION_NAME "XR_FB_spatial_entity_query"
+
+typedef enum XrSpaceQueryActionFB {
+    XR_SPACE_QUERY_ACTION_LOAD_FB = 0,
+    XR_SPACE_QUERY_ACTION_MAX_ENUM_FB = 0x7FFFFFFF
+} XrSpaceQueryActionFB;
+
+typedef enum XrSpaceStorageLocationFB {
+    XR_SPACE_STORAGE_LOCATION_INVALID_FB = 0,
+    XR_SPACE_STORAGE_LOCATION_LOCAL_FB = 1,
+    XR_SPACE_STORAGE_LOCATION_CLOUD_FB = 2,
+    XR_SPACE_STORAGE_LOCATION_MAX_ENUM_FB = 0x7FFFFFFF
+} XrSpaceStorageLocationFB;
+typedef struct XR_MAY_ALIAS XrSpaceQueryInfoBaseHeaderFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpaceQueryInfoBaseHeaderFB;
+
+typedef struct XR_MAY_ALIAS XrSpaceFilterInfoBaseHeaderFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpaceFilterInfoBaseHeaderFB;
+
+typedef struct XrSpaceQueryInfoFB {
+    XrStructureType                         type;
+    const void* XR_MAY_ALIAS                next;
+    XrSpaceQueryActionFB                    queryAction;
+    uint32_t                                maxResultCount;
+    XrDuration                              timeout;
+    const XrSpaceFilterInfoBaseHeaderFB*    filter;
+    const XrSpaceFilterInfoBaseHeaderFB*    excludeFilter;
+} XrSpaceQueryInfoFB;
+
+// XrSpaceStorageLocationFilterInfoFB extends XrSpaceFilterInfoBaseHeaderFB
+typedef struct XrSpaceStorageLocationFilterInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpaceStorageLocationFB    location;
+} XrSpaceStorageLocationFilterInfoFB;
+
+typedef struct XrSpaceUuidFilterInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    uuidCount;
+    XrUuidEXT*                  uuids;
+} XrSpaceUuidFilterInfoFB;
+
+typedef struct XrSpaceComponentFilterInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpaceComponentTypeFB      componentType;
+} XrSpaceComponentFilterInfoFB;
+
+typedef struct XrSpaceQueryResultFB {
+    XrSpace      space;
+    XrUuidEXT    uuid;
+} XrSpaceQueryResultFB;
+
+typedef struct XrSpaceQueryResultsFB {
+    XrStructureType          type;
+    void* XR_MAY_ALIAS       next;
+    uint32_t                 resultCapacityInput;
+    uint32_t                 resultCountOutput;
+    XrSpaceQueryResultFB*    results;
+} XrSpaceQueryResultsFB;
+
+typedef struct XrEventDataSpaceQueryResultsAvailableFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+} XrEventDataSpaceQueryResultsAvailableFB;
+
+typedef struct XrEventDataSpaceQueryCompleteFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+} XrEventDataSpaceQueryCompleteFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrQuerySpacesFB)(XrSession session, const XrSpaceQueryInfoBaseHeaderFB* info, XrAsyncRequestIdFB* requestId);
+typedef XrResult (XRAPI_PTR *PFN_xrRetrieveSpaceQueryResultsFB)(XrSession session, XrAsyncRequestIdFB requestId, XrSpaceQueryResultsFB* results);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrQuerySpacesFB(
+    XrSession                                   session,
+    const XrSpaceQueryInfoBaseHeaderFB*         info,
+    XrAsyncRequestIdFB*                         requestId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRetrieveSpaceQueryResultsFB(
+    XrSession                                   session,
+    XrAsyncRequestIdFB                          requestId,
+    XrSpaceQueryResultsFB*                      results);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_spatial_entity_storage is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_spatial_entity_storage 1
+#define XR_FB_spatial_entity_storage_SPEC_VERSION 1
+#define XR_FB_SPATIAL_ENTITY_STORAGE_EXTENSION_NAME "XR_FB_spatial_entity_storage"
+
+typedef enum XrSpacePersistenceModeFB {
+    XR_SPACE_PERSISTENCE_MODE_INVALID_FB = 0,
+    XR_SPACE_PERSISTENCE_MODE_INDEFINITE_FB = 1,
+    XR_SPACE_PERSISTENCE_MODE_MAX_ENUM_FB = 0x7FFFFFFF
+} XrSpacePersistenceModeFB;
+typedef struct XrSpaceSaveInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrSpaceStorageLocationFB    location;
+    XrSpacePersistenceModeFB    persistenceMode;
+} XrSpaceSaveInfoFB;
+
+typedef struct XrSpaceEraseInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrSpaceStorageLocationFB    location;
+} XrSpaceEraseInfoFB;
+
+typedef struct XrEventDataSpaceSaveCompleteFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+    XrSpace                     space;
+    XrUuidEXT                   uuid;
+    XrSpaceStorageLocationFB    location;
+} XrEventDataSpaceSaveCompleteFB;
+
+typedef struct XrEventDataSpaceEraseCompleteFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+    XrSpace                     space;
+    XrUuidEXT                   uuid;
+    XrSpaceStorageLocationFB    location;
+} XrEventDataSpaceEraseCompleteFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSaveSpaceFB)(XrSession session, const XrSpaceSaveInfoFB* info, XrAsyncRequestIdFB* requestId);
+typedef XrResult (XRAPI_PTR *PFN_xrEraseSpaceFB)(XrSession session, const XrSpaceEraseInfoFB* info, XrAsyncRequestIdFB* requestId);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSaveSpaceFB(
+    XrSession                                   session,
+    const XrSpaceSaveInfoFB*                    info,
+    XrAsyncRequestIdFB*                         requestId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEraseSpaceFB(
+    XrSession                                   session,
+    const XrSpaceEraseInfoFB*                   info,
+    XrAsyncRequestIdFB*                         requestId);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_touch_controller_pro is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_touch_controller_pro 1
+#define XR_FB_touch_controller_pro_SPEC_VERSION 1
+#define XR_FB_TOUCH_CONTROLLER_PRO_EXTENSION_NAME "XR_FB_touch_controller_pro"
+
+
+// XR_FB_spatial_entity_sharing is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_spatial_entity_sharing 1
+XR_DEFINE_HANDLE(XrSpaceUserFB)
+#define XR_FB_spatial_entity_sharing_SPEC_VERSION 1
+#define XR_FB_SPATIAL_ENTITY_SHARING_EXTENSION_NAME "XR_FB_spatial_entity_sharing"
+typedef struct XrSpaceShareInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    spaceCount;
+    XrSpace*                    spaces;
+    uint32_t                    userCount;
+    XrSpaceUserFB*              users;
+} XrSpaceShareInfoFB;
+
+typedef struct XrEventDataSpaceShareCompleteFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+} XrEventDataSpaceShareCompleteFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrShareSpacesFB)(XrSession session, const XrSpaceShareInfoFB* info, XrAsyncRequestIdFB* requestId);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrShareSpacesFB(
+    XrSession                                   session,
+    const XrSpaceShareInfoFB*                   info,
+    XrAsyncRequestIdFB*                         requestId);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_space_warp is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_space_warp 1
+#define XR_FB_space_warp_SPEC_VERSION     2
+#define XR_FB_SPACE_WARP_EXTENSION_NAME   "XR_FB_space_warp"
+typedef XrFlags64 XrCompositionLayerSpaceWarpInfoFlagsFB;
+
+// Flag bits for XrCompositionLayerSpaceWarpInfoFlagsFB
+static const XrCompositionLayerSpaceWarpInfoFlagsFB XR_COMPOSITION_LAYER_SPACE_WARP_INFO_FRAME_SKIP_BIT_FB = 0x00000001;
+
+// XrCompositionLayerSpaceWarpInfoFB extends XrCompositionLayerProjectionView
+typedef struct XrCompositionLayerSpaceWarpInfoFB {
+    XrStructureType                           type;
+    const void* XR_MAY_ALIAS                  next;
+    XrCompositionLayerSpaceWarpInfoFlagsFB    layerFlags;
+    XrSwapchainSubImage                       motionVectorSubImage;
+    XrPosef                                   appSpaceDeltaPose;
+    XrSwapchainSubImage                       depthSubImage;
+    float                                     minDepth;
+    float                                     maxDepth;
+    float                                     nearZ;
+    float                                     farZ;
+} XrCompositionLayerSpaceWarpInfoFB;
+
+// XrSystemSpaceWarpPropertiesFB extends XrSystemProperties
+typedef struct XrSystemSpaceWarpPropertiesFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              recommendedMotionVectorImageRectWidth;
+    uint32_t              recommendedMotionVectorImageRectHeight;
+} XrSystemSpaceWarpPropertiesFB;
+
+
+
+// XR_FB_haptic_amplitude_envelope is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_haptic_amplitude_envelope 1
+
+#define XR_MAX_HAPTIC_AMPLITUDE_ENVELOPE_SAMPLES_FB 4000u
+
+#define XR_FB_haptic_amplitude_envelope_SPEC_VERSION 1
+#define XR_FB_HAPTIC_AMPLITUDE_ENVELOPE_EXTENSION_NAME "XR_FB_haptic_amplitude_envelope"
+typedef struct XrHapticAmplitudeEnvelopeVibrationFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrDuration                  duration;
+    uint32_t                    amplitudeCount;
+    const float*                amplitudes;
+} XrHapticAmplitudeEnvelopeVibrationFB;
+
+
+
+// XR_FB_scene is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_scene 1
+#define XR_FB_scene_SPEC_VERSION          4
+#define XR_FB_SCENE_EXTENSION_NAME        "XR_FB_scene"
+typedef XrFlags64 XrSemanticLabelsSupportFlagsFB;
+
+// Flag bits for XrSemanticLabelsSupportFlagsFB
+static const XrSemanticLabelsSupportFlagsFB XR_SEMANTIC_LABELS_SUPPORT_MULTIPLE_SEMANTIC_LABELS_BIT_FB = 0x00000001;
+static const XrSemanticLabelsSupportFlagsFB XR_SEMANTIC_LABELS_SUPPORT_ACCEPT_DESK_TO_TABLE_MIGRATION_BIT_FB = 0x00000002;
+static const XrSemanticLabelsSupportFlagsFB XR_SEMANTIC_LABELS_SUPPORT_ACCEPT_INVISIBLE_WALL_FACE_BIT_FB = 0x00000004;
+
+typedef XrExtent3Df XrExtent3DfFB;
+
+typedef struct XrOffset3DfFB {
+    float    x;
+    float    y;
+    float    z;
+} XrOffset3DfFB;
+
+typedef struct XrRect3DfFB {
+    XrOffset3DfFB    offset;
+    XrExtent3DfFB    extent;
+} XrRect3DfFB;
+
+typedef struct XrSemanticLabelsFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    bufferCapacityInput;
+    uint32_t                    bufferCountOutput;
+    char*                       buffer;
+} XrSemanticLabelsFB;
+
+typedef struct XrRoomLayoutFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrUuidEXT                   floorUuid;
+    XrUuidEXT                   ceilingUuid;
+    uint32_t                    wallUuidCapacityInput;
+    uint32_t                    wallUuidCountOutput;
+    XrUuidEXT*                  wallUuids;
+} XrRoomLayoutFB;
+
+typedef struct XrBoundary2DFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    vertexCapacityInput;
+    uint32_t                    vertexCountOutput;
+    XrVector2f*                 vertices;
+} XrBoundary2DFB;
+
+// XrSemanticLabelsSupportInfoFB extends XrSemanticLabelsFB
+typedef struct XrSemanticLabelsSupportInfoFB {
+    XrStructureType                   type;
+    const void* XR_MAY_ALIAS          next;
+    XrSemanticLabelsSupportFlagsFB    flags;
+    const char*                       recognizedLabels;
+} XrSemanticLabelsSupportInfoFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceBoundingBox2DFB)(XrSession session, XrSpace space, XrRect2Df* boundingBox2DOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceBoundingBox3DFB)(XrSession session, XrSpace space, XrRect3DfFB* boundingBox3DOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceSemanticLabelsFB)(XrSession session, XrSpace space, XrSemanticLabelsFB* semanticLabelsOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceBoundary2DFB)(XrSession session, XrSpace space, XrBoundary2DFB* boundary2DOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceRoomLayoutFB)(XrSession session, XrSpace space, XrRoomLayoutFB* roomLayoutOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceBoundingBox2DFB(
+    XrSession                                   session,
+    XrSpace                                     space,
+    XrRect2Df*                                  boundingBox2DOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceBoundingBox3DFB(
+    XrSession                                   session,
+    XrSpace                                     space,
+    XrRect3DfFB*                                boundingBox3DOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceSemanticLabelsFB(
+    XrSession                                   session,
+    XrSpace                                     space,
+    XrSemanticLabelsFB*                         semanticLabelsOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceBoundary2DFB(
+    XrSession                                   session,
+    XrSpace                                     space,
+    XrBoundary2DFB*                             boundary2DOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceRoomLayoutFB(
+    XrSession                                   session,
+    XrSpace                                     space,
+    XrRoomLayoutFB*                             roomLayoutOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_palm_pose is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_palm_pose 1
+#define XR_EXT_palm_pose_SPEC_VERSION     3
+#define XR_EXT_PALM_POSE_EXTENSION_NAME   "XR_EXT_palm_pose"
+
+
+// XR_ALMALENCE_digital_lens_control is a preprocessor guard. Do not pass it to API calls.
+#define XR_ALMALENCE_digital_lens_control 1
+#define XR_ALMALENCE_digital_lens_control_SPEC_VERSION 1
+#define XR_ALMALENCE_DIGITAL_LENS_CONTROL_EXTENSION_NAME "XR_ALMALENCE_digital_lens_control"
+typedef XrFlags64 XrDigitalLensControlFlagsALMALENCE;
+
+// Flag bits for XrDigitalLensControlFlagsALMALENCE
+static const XrDigitalLensControlFlagsALMALENCE XR_DIGITAL_LENS_CONTROL_PROCESSING_DISABLE_BIT_ALMALENCE = 0x00000001;
+
+typedef struct XrDigitalLensControlALMALENCE {
+    XrStructureType                       type;
+    const void* XR_MAY_ALIAS              next;
+    XrDigitalLensControlFlagsALMALENCE    flags;
+} XrDigitalLensControlALMALENCE;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSetDigitalLensControlALMALENCE)(XrSession session, const XrDigitalLensControlALMALENCE* digitalLensControl);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetDigitalLensControlALMALENCE(
+    XrSession                                   session,
+    const XrDigitalLensControlALMALENCE*        digitalLensControl);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_scene_capture is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_scene_capture 1
+#define XR_FB_scene_capture_SPEC_VERSION  1
+#define XR_FB_SCENE_CAPTURE_EXTENSION_NAME "XR_FB_scene_capture"
+typedef struct XrEventDataSceneCaptureCompleteFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+} XrEventDataSceneCaptureCompleteFB;
+
+typedef struct XrSceneCaptureRequestInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    requestByteCount;
+    const char*                 request;
+} XrSceneCaptureRequestInfoFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrRequestSceneCaptureFB)(XrSession session, const XrSceneCaptureRequestInfoFB* info, XrAsyncRequestIdFB* requestId);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestSceneCaptureFB(
+    XrSession                                   session,
+    const XrSceneCaptureRequestInfoFB*          info,
+    XrAsyncRequestIdFB*                         requestId);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_spatial_entity_container is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_spatial_entity_container 1
+#define XR_FB_spatial_entity_container_SPEC_VERSION 2
+#define XR_FB_SPATIAL_ENTITY_CONTAINER_EXTENSION_NAME "XR_FB_spatial_entity_container"
+typedef struct XrSpaceContainerFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    uuidCapacityInput;
+    uint32_t                    uuidCountOutput;
+    XrUuidEXT*                  uuids;
+} XrSpaceContainerFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceContainerFB)(XrSession session, XrSpace space, XrSpaceContainerFB* spaceContainerOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceContainerFB(
+    XrSession                                   session,
+    XrSpace                                     space,
+    XrSpaceContainerFB*                         spaceContainerOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_foveation_eye_tracked is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_foveation_eye_tracked 1
+#define XR_FOVEATION_CENTER_SIZE_META     2
+#define XR_META_foveation_eye_tracked_SPEC_VERSION 1
+#define XR_META_FOVEATION_EYE_TRACKED_EXTENSION_NAME "XR_META_foveation_eye_tracked"
+typedef XrFlags64 XrFoveationEyeTrackedProfileCreateFlagsMETA;
+
+// Flag bits for XrFoveationEyeTrackedProfileCreateFlagsMETA
+
+typedef XrFlags64 XrFoveationEyeTrackedStateFlagsMETA;
+
+// Flag bits for XrFoveationEyeTrackedStateFlagsMETA
+static const XrFoveationEyeTrackedStateFlagsMETA XR_FOVEATION_EYE_TRACKED_STATE_VALID_BIT_META = 0x00000001;
+
+// XrFoveationEyeTrackedProfileCreateInfoMETA extends XrFoveationLevelProfileCreateInfoFB
+typedef struct XrFoveationEyeTrackedProfileCreateInfoMETA {
+    XrStructureType                                type;
+    const void* XR_MAY_ALIAS                       next;
+    XrFoveationEyeTrackedProfileCreateFlagsMETA    flags;
+} XrFoveationEyeTrackedProfileCreateInfoMETA;
+
+typedef struct XrFoveationEyeTrackedStateMETA {
+    XrStructureType                        type;
+    void* XR_MAY_ALIAS                     next;
+    XrVector2f                             foveationCenter[XR_FOVEATION_CENTER_SIZE_META];
+    XrFoveationEyeTrackedStateFlagsMETA    flags;
+} XrFoveationEyeTrackedStateMETA;
+
+// XrSystemFoveationEyeTrackedPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemFoveationEyeTrackedPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsFoveationEyeTracked;
+} XrSystemFoveationEyeTrackedPropertiesMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetFoveationEyeTrackedStateMETA)(XrSession session, XrFoveationEyeTrackedStateMETA* foveationState);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetFoveationEyeTrackedStateMETA(
+    XrSession                                   session,
+    XrFoveationEyeTrackedStateMETA*             foveationState);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_face_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_face_tracking 1
+
+#define XR_FACE_EXPRESSSION_SET_DEFAULT_FB XR_FACE_EXPRESSION_SET_DEFAULT_FB
+
+XR_DEFINE_HANDLE(XrFaceTrackerFB)
+#define XR_FB_face_tracking_SPEC_VERSION  1
+#define XR_FB_FACE_TRACKING_EXTENSION_NAME "XR_FB_face_tracking"
+
+typedef enum XrFaceExpressionFB {
+    XR_FACE_EXPRESSION_BROW_LOWERER_L_FB = 0,
+    XR_FACE_EXPRESSION_BROW_LOWERER_R_FB = 1,
+    XR_FACE_EXPRESSION_CHEEK_PUFF_L_FB = 2,
+    XR_FACE_EXPRESSION_CHEEK_PUFF_R_FB = 3,
+    XR_FACE_EXPRESSION_CHEEK_RAISER_L_FB = 4,
+    XR_FACE_EXPRESSION_CHEEK_RAISER_R_FB = 5,
+    XR_FACE_EXPRESSION_CHEEK_SUCK_L_FB = 6,
+    XR_FACE_EXPRESSION_CHEEK_SUCK_R_FB = 7,
+    XR_FACE_EXPRESSION_CHIN_RAISER_B_FB = 8,
+    XR_FACE_EXPRESSION_CHIN_RAISER_T_FB = 9,
+    XR_FACE_EXPRESSION_DIMPLER_L_FB = 10,
+    XR_FACE_EXPRESSION_DIMPLER_R_FB = 11,
+    XR_FACE_EXPRESSION_EYES_CLOSED_L_FB = 12,
+    XR_FACE_EXPRESSION_EYES_CLOSED_R_FB = 13,
+    XR_FACE_EXPRESSION_EYES_LOOK_DOWN_L_FB = 14,
+    XR_FACE_EXPRESSION_EYES_LOOK_DOWN_R_FB = 15,
+    XR_FACE_EXPRESSION_EYES_LOOK_LEFT_L_FB = 16,
+    XR_FACE_EXPRESSION_EYES_LOOK_LEFT_R_FB = 17,
+    XR_FACE_EXPRESSION_EYES_LOOK_RIGHT_L_FB = 18,
+    XR_FACE_EXPRESSION_EYES_LOOK_RIGHT_R_FB = 19,
+    XR_FACE_EXPRESSION_EYES_LOOK_UP_L_FB = 20,
+    XR_FACE_EXPRESSION_EYES_LOOK_UP_R_FB = 21,
+    XR_FACE_EXPRESSION_INNER_BROW_RAISER_L_FB = 22,
+    XR_FACE_EXPRESSION_INNER_BROW_RAISER_R_FB = 23,
+    XR_FACE_EXPRESSION_JAW_DROP_FB = 24,
+    XR_FACE_EXPRESSION_JAW_SIDEWAYS_LEFT_FB = 25,
+    XR_FACE_EXPRESSION_JAW_SIDEWAYS_RIGHT_FB = 26,
+    XR_FACE_EXPRESSION_JAW_THRUST_FB = 27,
+    XR_FACE_EXPRESSION_LID_TIGHTENER_L_FB = 28,
+    XR_FACE_EXPRESSION_LID_TIGHTENER_R_FB = 29,
+    XR_FACE_EXPRESSION_LIP_CORNER_DEPRESSOR_L_FB = 30,
+    XR_FACE_EXPRESSION_LIP_CORNER_DEPRESSOR_R_FB = 31,
+    XR_FACE_EXPRESSION_LIP_CORNER_PULLER_L_FB = 32,
+    XR_FACE_EXPRESSION_LIP_CORNER_PULLER_R_FB = 33,
+    XR_FACE_EXPRESSION_LIP_FUNNELER_LB_FB = 34,
+    XR_FACE_EXPRESSION_LIP_FUNNELER_LT_FB = 35,
+    XR_FACE_EXPRESSION_LIP_FUNNELER_RB_FB = 36,
+    XR_FACE_EXPRESSION_LIP_FUNNELER_RT_FB = 37,
+    XR_FACE_EXPRESSION_LIP_PRESSOR_L_FB = 38,
+    XR_FACE_EXPRESSION_LIP_PRESSOR_R_FB = 39,
+    XR_FACE_EXPRESSION_LIP_PUCKER_L_FB = 40,
+    XR_FACE_EXPRESSION_LIP_PUCKER_R_FB = 41,
+    XR_FACE_EXPRESSION_LIP_STRETCHER_L_FB = 42,
+    XR_FACE_EXPRESSION_LIP_STRETCHER_R_FB = 43,
+    XR_FACE_EXPRESSION_LIP_SUCK_LB_FB = 44,
+    XR_FACE_EXPRESSION_LIP_SUCK_LT_FB = 45,
+    XR_FACE_EXPRESSION_LIP_SUCK_RB_FB = 46,
+    XR_FACE_EXPRESSION_LIP_SUCK_RT_FB = 47,
+    XR_FACE_EXPRESSION_LIP_TIGHTENER_L_FB = 48,
+    XR_FACE_EXPRESSION_LIP_TIGHTENER_R_FB = 49,
+    XR_FACE_EXPRESSION_LIPS_TOWARD_FB = 50,
+    XR_FACE_EXPRESSION_LOWER_LIP_DEPRESSOR_L_FB = 51,
+    XR_FACE_EXPRESSION_LOWER_LIP_DEPRESSOR_R_FB = 52,
+    XR_FACE_EXPRESSION_MOUTH_LEFT_FB = 53,
+    XR_FACE_EXPRESSION_MOUTH_RIGHT_FB = 54,
+    XR_FACE_EXPRESSION_NOSE_WRINKLER_L_FB = 55,
+    XR_FACE_EXPRESSION_NOSE_WRINKLER_R_FB = 56,
+    XR_FACE_EXPRESSION_OUTER_BROW_RAISER_L_FB = 57,
+    XR_FACE_EXPRESSION_OUTER_BROW_RAISER_R_FB = 58,
+    XR_FACE_EXPRESSION_UPPER_LID_RAISER_L_FB = 59,
+    XR_FACE_EXPRESSION_UPPER_LID_RAISER_R_FB = 60,
+    XR_FACE_EXPRESSION_UPPER_LIP_RAISER_L_FB = 61,
+    XR_FACE_EXPRESSION_UPPER_LIP_RAISER_R_FB = 62,
+    XR_FACE_EXPRESSION_COUNT_FB = 63,
+    XR_FACE_EXPRESSION_MAX_ENUM_FB = 0x7FFFFFFF
+} XrFaceExpressionFB;
+
+typedef enum XrFaceExpressionSetFB {
+    XR_FACE_EXPRESSION_SET_DEFAULT_FB = 0,
+    XR_FACE_EXPRESSION_SET_MAX_ENUM_FB = 0x7FFFFFFF
+} XrFaceExpressionSetFB;
+
+typedef enum XrFaceConfidenceFB {
+    XR_FACE_CONFIDENCE_LOWER_FACE_FB = 0,
+    XR_FACE_CONFIDENCE_UPPER_FACE_FB = 1,
+    XR_FACE_CONFIDENCE_COUNT_FB = 2,
+    XR_FACE_CONFIDENCE_MAX_ENUM_FB = 0x7FFFFFFF
+} XrFaceConfidenceFB;
+// XrSystemFaceTrackingPropertiesFB extends XrSystemProperties
+typedef struct XrSystemFaceTrackingPropertiesFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsFaceTracking;
+} XrSystemFaceTrackingPropertiesFB;
+
+typedef struct XrFaceTrackerCreateInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrFaceExpressionSetFB       faceExpressionSet;
+} XrFaceTrackerCreateInfoFB;
+
+typedef struct XrFaceExpressionInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      time;
+} XrFaceExpressionInfoFB;
+
+typedef struct XrFaceExpressionStatusFB {
+    XrBool32    isValid;
+    XrBool32    isEyeFollowingBlendshapesValid;
+} XrFaceExpressionStatusFB;
+
+typedef struct XrFaceExpressionWeightsFB {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    uint32_t                    weightCount;
+    float*                      weights;
+    uint32_t                    confidenceCount;
+    float*                      confidences;
+    XrFaceExpressionStatusFB    status;
+    XrTime                      time;
+} XrFaceExpressionWeightsFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTrackerFB)(XrSession session, const XrFaceTrackerCreateInfoFB* createInfo, XrFaceTrackerFB* faceTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTrackerFB)(XrFaceTrackerFB faceTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrGetFaceExpressionWeightsFB)(XrFaceTrackerFB faceTracker, const XrFaceExpressionInfoFB* expressionInfo, XrFaceExpressionWeightsFB* expressionWeights);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateFaceTrackerFB(
+    XrSession                                   session,
+    const XrFaceTrackerCreateInfoFB*            createInfo,
+    XrFaceTrackerFB*                            faceTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFaceTrackerFB(
+    XrFaceTrackerFB                             faceTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetFaceExpressionWeightsFB(
+    XrFaceTrackerFB                             faceTracker,
+    const XrFaceExpressionInfoFB*               expressionInfo,
+    XrFaceExpressionWeightsFB*                  expressionWeights);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_eye_tracking_social is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_eye_tracking_social 1
+XR_DEFINE_HANDLE(XrEyeTrackerFB)
+#define XR_FB_eye_tracking_social_SPEC_VERSION 1
+#define XR_FB_EYE_TRACKING_SOCIAL_EXTENSION_NAME "XR_FB_eye_tracking_social"
+
+typedef enum XrEyePositionFB {
+    XR_EYE_POSITION_LEFT_FB = 0,
+    XR_EYE_POSITION_RIGHT_FB = 1,
+    XR_EYE_POSITION_COUNT_FB = 2,
+    XR_EYE_POSITION_MAX_ENUM_FB = 0x7FFFFFFF
+} XrEyePositionFB;
+typedef struct XrEyeGazeFB {
+    XrBool32    isValid;
+    XrPosef     gazePose;
+    float       gazeConfidence;
+} XrEyeGazeFB;
+
+typedef struct XrEyeTrackerCreateInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrEyeTrackerCreateInfoFB;
+
+typedef struct XrEyeGazesInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+} XrEyeGazesInfoFB;
+
+// XrSystemEyeTrackingPropertiesFB extends XrSystemProperties
+typedef struct XrSystemEyeTrackingPropertiesFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsEyeTracking;
+} XrSystemEyeTrackingPropertiesFB;
+
+typedef struct XrEyeGazesFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrEyeGazeFB           gaze[XR_EYE_POSITION_COUNT_FB];
+    XrTime                time;
+} XrEyeGazesFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateEyeTrackerFB)(XrSession session, const XrEyeTrackerCreateInfoFB* createInfo, XrEyeTrackerFB* eyeTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyEyeTrackerFB)(XrEyeTrackerFB eyeTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrGetEyeGazesFB)(XrEyeTrackerFB eyeTracker, const XrEyeGazesInfoFB* gazeInfo, XrEyeGazesFB* eyeGazes);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateEyeTrackerFB(
+    XrSession                                   session,
+    const XrEyeTrackerCreateInfoFB*             createInfo,
+    XrEyeTrackerFB*                             eyeTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyEyeTrackerFB(
+    XrEyeTrackerFB                              eyeTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetEyeGazesFB(
+    XrEyeTrackerFB                              eyeTracker,
+    const XrEyeGazesInfoFB*                     gazeInfo,
+    XrEyeGazesFB*                               eyeGazes);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_passthrough_keyboard_hands is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_passthrough_keyboard_hands 1
+#define XR_FB_passthrough_keyboard_hands_SPEC_VERSION 2
+#define XR_FB_PASSTHROUGH_KEYBOARD_HANDS_EXTENSION_NAME "XR_FB_passthrough_keyboard_hands"
+typedef struct XrPassthroughKeyboardHandsIntensityFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       leftHandIntensity;
+    float                       rightHandIntensity;
+} XrPassthroughKeyboardHandsIntensityFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrPassthroughLayerSetKeyboardHandsIntensityFB)(XrPassthroughLayerFB layer, const XrPassthroughKeyboardHandsIntensityFB* intensity);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrPassthroughLayerSetKeyboardHandsIntensityFB(
+    XrPassthroughLayerFB                        layer,
+    const XrPassthroughKeyboardHandsIntensityFB* intensity);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_composition_layer_settings is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_composition_layer_settings 1
+#define XR_FB_composition_layer_settings_SPEC_VERSION 1
+#define XR_FB_COMPOSITION_LAYER_SETTINGS_EXTENSION_NAME "XR_FB_composition_layer_settings"
+typedef XrFlags64 XrCompositionLayerSettingsFlagsFB;
+
+// Flag bits for XrCompositionLayerSettingsFlagsFB
+static const XrCompositionLayerSettingsFlagsFB XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SUPER_SAMPLING_BIT_FB = 0x00000001;
+static const XrCompositionLayerSettingsFlagsFB XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SUPER_SAMPLING_BIT_FB = 0x00000002;
+static const XrCompositionLayerSettingsFlagsFB XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SHARPENING_BIT_FB = 0x00000004;
+static const XrCompositionLayerSettingsFlagsFB XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SHARPENING_BIT_FB = 0x00000008;
+static const XrCompositionLayerSettingsFlagsFB XR_COMPOSITION_LAYER_SETTINGS_AUTO_LAYER_FILTER_BIT_META = 0x00000020;
+
+// XrCompositionLayerSettingsFB extends XrCompositionLayerBaseHeader
+typedef struct XrCompositionLayerSettingsFB {
+    XrStructureType                      type;
+    const void* XR_MAY_ALIAS             next;
+    XrCompositionLayerSettingsFlagsFB    layerFlags;
+} XrCompositionLayerSettingsFB;
+
+
+
+// XR_FB_touch_controller_proximity is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_touch_controller_proximity 1
+#define XR_FB_touch_controller_proximity_SPEC_VERSION 1
+#define XR_FB_TOUCH_CONTROLLER_PROXIMITY_EXTENSION_NAME "XR_FB_touch_controller_proximity"
+
+
+// XR_FB_haptic_pcm is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_haptic_pcm 1
+
+#define XR_MAX_HAPTIC_PCM_BUFFER_SIZE_FB 4000
+
+#define XR_FB_haptic_pcm_SPEC_VERSION     1
+#define XR_FB_HAPTIC_PCM_EXTENSION_NAME   "XR_FB_haptic_pcm"
+typedef struct XrHapticPcmVibrationFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    bufferSize;
+    const float*                buffer;
+    float                       sampleRate;
+    XrBool32                    append;
+    uint32_t*                   samplesConsumed;
+} XrHapticPcmVibrationFB;
+
+typedef struct XrDevicePcmSampleRateStateFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    float                 sampleRate;
+} XrDevicePcmSampleRateStateFB;
+
+typedef XrDevicePcmSampleRateStateFB XrDevicePcmSampleRateGetInfoFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetDeviceSampleRateFB)(XrSession session, const XrHapticActionInfo* hapticActionInfo, XrDevicePcmSampleRateGetInfoFB* deviceSampleRate);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetDeviceSampleRateFB(
+    XrSession                                   session,
+    const XrHapticActionInfo*                   hapticActionInfo,
+    XrDevicePcmSampleRateGetInfoFB*             deviceSampleRate);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_frame_synthesis is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_frame_synthesis 1
+#define XR_EXT_frame_synthesis_SPEC_VERSION 1
+#define XR_EXT_FRAME_SYNTHESIS_EXTENSION_NAME "XR_EXT_frame_synthesis"
+typedef XrFlags64 XrFrameSynthesisInfoFlagsEXT;
+
+// Flag bits for XrFrameSynthesisInfoFlagsEXT
+static const XrFrameSynthesisInfoFlagsEXT XR_FRAME_SYNTHESIS_INFO_USE_2D_MOTION_VECTOR_BIT_EXT = 0x00000001;
+static const XrFrameSynthesisInfoFlagsEXT XR_FRAME_SYNTHESIS_INFO_REQUEST_RELAXED_FRAME_INTERVAL_BIT_EXT = 0x00000002;
+
+// XrFrameSynthesisInfoEXT extends XrCompositionLayerProjectionView
+typedef struct XrFrameSynthesisInfoEXT {
+    XrStructureType                 type;
+    const void* XR_MAY_ALIAS        next;
+    XrFrameSynthesisInfoFlagsEXT    layerFlags;
+    XrSwapchainSubImage             motionVectorSubImage;
+    XrVector4f                      motionVectorScale;
+    XrVector4f                      motionVectorOffset;
+    XrPosef                         appSpaceDeltaPose;
+    XrSwapchainSubImage             depthSubImage;
+    float                           minDepth;
+    float                           maxDepth;
+    float                           nearZ;
+    float                           farZ;
+} XrFrameSynthesisInfoEXT;
+
+// XrFrameSynthesisConfigViewEXT extends XrViewConfigurationView
+typedef struct XrFrameSynthesisConfigViewEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              recommendedMotionVectorImageRectWidth;
+    uint32_t              recommendedMotionVectorImageRectHeight;
+} XrFrameSynthesisConfigViewEXT;
+
+
+
+// XR_FB_composition_layer_depth_test is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_composition_layer_depth_test 1
+#define XR_FB_composition_layer_depth_test_SPEC_VERSION 1
+#define XR_FB_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME "XR_FB_composition_layer_depth_test"
+
+typedef enum XrCompareOpFB {
+    XR_COMPARE_OP_NEVER_FB = 0,
+    XR_COMPARE_OP_LESS_FB = 1,
+    XR_COMPARE_OP_EQUAL_FB = 2,
+    XR_COMPARE_OP_LESS_OR_EQUAL_FB = 3,
+    XR_COMPARE_OP_GREATER_FB = 4,
+    XR_COMPARE_OP_NOT_EQUAL_FB = 5,
+    XR_COMPARE_OP_GREATER_OR_EQUAL_FB = 6,
+    XR_COMPARE_OP_ALWAYS_FB = 7,
+    XR_COMPARE_OP_MAX_ENUM_FB = 0x7FFFFFFF
+} XrCompareOpFB;
+// XrCompositionLayerDepthTestFB extends XrCompositionLayerBaseHeader
+typedef struct XrCompositionLayerDepthTestFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    depthMask;
+    XrCompareOpFB               compareOp;
+} XrCompositionLayerDepthTestFB;
+
+
+
+// XR_META_local_dimming is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_local_dimming 1
+#define XR_META_local_dimming_SPEC_VERSION 1
+#define XR_META_LOCAL_DIMMING_EXTENSION_NAME "XR_META_local_dimming"
+
+typedef enum XrLocalDimmingModeMETA {
+    XR_LOCAL_DIMMING_MODE_OFF_META = 0,
+    XR_LOCAL_DIMMING_MODE_ON_META = 1,
+    XR_LOCAL_DIMMING_MODE_MAX_ENUM_META = 0x7FFFFFFF
+} XrLocalDimmingModeMETA;
+// XrLocalDimmingFrameEndInfoMETA extends XrFrameEndInfo
+typedef struct XrLocalDimmingFrameEndInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrLocalDimmingModeMETA      localDimmingMode;
+} XrLocalDimmingFrameEndInfoMETA;
+
+
+
+// XR_META_passthrough_preferences is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_passthrough_preferences 1
+#define XR_META_passthrough_preferences_SPEC_VERSION 1
+#define XR_META_PASSTHROUGH_PREFERENCES_EXTENSION_NAME "XR_META_passthrough_preferences"
+typedef XrFlags64 XrPassthroughPreferenceFlagsMETA;
+
+// Flag bits for XrPassthroughPreferenceFlagsMETA
+static const XrPassthroughPreferenceFlagsMETA XR_PASSTHROUGH_PREFERENCE_DEFAULT_TO_ACTIVE_BIT_META = 0x00000001;
+
+typedef struct XrPassthroughPreferencesMETA {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrPassthroughPreferenceFlagsMETA    flags;
+} XrPassthroughPreferencesMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetPassthroughPreferencesMETA)(XrSession session, XrPassthroughPreferencesMETA* preferences);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetPassthroughPreferencesMETA(
+    XrSession                                   session,
+    XrPassthroughPreferencesMETA*               preferences);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_virtual_keyboard is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_virtual_keyboard 1
+XR_DEFINE_HANDLE(XrVirtualKeyboardMETA)
+#define XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META 3992
+#define XR_META_virtual_keyboard_SPEC_VERSION 1
+#define XR_META_VIRTUAL_KEYBOARD_EXTENSION_NAME "XR_META_virtual_keyboard"
+
+typedef enum XrVirtualKeyboardLocationTypeMETA {
+    XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_CUSTOM_META = 0,
+    XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_FAR_META = 1,
+    XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_DIRECT_META = 2,
+    XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_MAX_ENUM_META = 0x7FFFFFFF
+} XrVirtualKeyboardLocationTypeMETA;
+
+typedef enum XrVirtualKeyboardInputSourceMETA {
+    XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_LEFT_META = 1,
+    XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_RIGHT_META = 2,
+    XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_LEFT_META = 3,
+    XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_RIGHT_META = 4,
+    XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_LEFT_META = 5,
+    XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_RIGHT_META = 6,
+    XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_LEFT_META = 7,
+    XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_RIGHT_META = 8,
+    XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_MAX_ENUM_META = 0x7FFFFFFF
+} XrVirtualKeyboardInputSourceMETA;
+typedef XrFlags64 XrVirtualKeyboardInputStateFlagsMETA;
+
+// Flag bits for XrVirtualKeyboardInputStateFlagsMETA
+static const XrVirtualKeyboardInputStateFlagsMETA XR_VIRTUAL_KEYBOARD_INPUT_STATE_PRESSED_BIT_META = 0x00000001;
+
+// XrSystemVirtualKeyboardPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemVirtualKeyboardPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsVirtualKeyboard;
+} XrSystemVirtualKeyboardPropertiesMETA;
+
+typedef struct XrVirtualKeyboardCreateInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrVirtualKeyboardCreateInfoMETA;
+
+typedef struct XrVirtualKeyboardSpaceCreateInfoMETA {
+    XrStructureType                      type;
+    const void* XR_MAY_ALIAS             next;
+    XrVirtualKeyboardLocationTypeMETA    locationType;
+    XrSpace                              space;
+    XrPosef                              poseInSpace;
+} XrVirtualKeyboardSpaceCreateInfoMETA;
+
+typedef struct XrVirtualKeyboardLocationInfoMETA {
+    XrStructureType                      type;
+    const void* XR_MAY_ALIAS             next;
+    XrVirtualKeyboardLocationTypeMETA    locationType;
+    XrSpace                              space;
+    XrPosef                              poseInSpace;
+    float                                scale;
+} XrVirtualKeyboardLocationInfoMETA;
+
+typedef struct XrVirtualKeyboardModelVisibilitySetInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    visible;
+} XrVirtualKeyboardModelVisibilitySetInfoMETA;
+
+typedef struct XrVirtualKeyboardAnimationStateMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    int32_t               animationIndex;
+    float                 fraction;
+} XrVirtualKeyboardAnimationStateMETA;
+
+typedef struct XrVirtualKeyboardModelAnimationStatesMETA {
+    XrStructureType                         type;
+    void* XR_MAY_ALIAS                      next;
+    uint32_t                                stateCapacityInput;
+    uint32_t                                stateCountOutput;
+    XrVirtualKeyboardAnimationStateMETA*    states;
+} XrVirtualKeyboardModelAnimationStatesMETA;
+
+typedef struct XrVirtualKeyboardTextureDataMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              textureWidth;
+    uint32_t              textureHeight;
+    uint32_t              bufferCapacityInput;
+    uint32_t              bufferCountOutput;
+    uint8_t*              buffer;
+} XrVirtualKeyboardTextureDataMETA;
+
+typedef struct XrVirtualKeyboardInputInfoMETA {
+    XrStructureType                         type;
+    const void* XR_MAY_ALIAS                next;
+    XrVirtualKeyboardInputSourceMETA        inputSource;
+    XrSpace                                 inputSpace;
+    XrPosef                                 inputPoseInSpace;
+    XrVirtualKeyboardInputStateFlagsMETA    inputState;
+} XrVirtualKeyboardInputInfoMETA;
+
+typedef struct XrVirtualKeyboardTextContextChangeInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    const char*                 textContext;
+} XrVirtualKeyboardTextContextChangeInfoMETA;
+
+typedef struct XrEventDataVirtualKeyboardCommitTextMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrVirtualKeyboardMETA       keyboard;
+    char                        text[XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META];
+} XrEventDataVirtualKeyboardCommitTextMETA;
+
+typedef struct XrEventDataVirtualKeyboardBackspaceMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrVirtualKeyboardMETA       keyboard;
+} XrEventDataVirtualKeyboardBackspaceMETA;
+
+typedef struct XrEventDataVirtualKeyboardEnterMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrVirtualKeyboardMETA       keyboard;
+} XrEventDataVirtualKeyboardEnterMETA;
+
+typedef struct XrEventDataVirtualKeyboardShownMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrVirtualKeyboardMETA       keyboard;
+} XrEventDataVirtualKeyboardShownMETA;
+
+typedef struct XrEventDataVirtualKeyboardHiddenMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrVirtualKeyboardMETA       keyboard;
+} XrEventDataVirtualKeyboardHiddenMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateVirtualKeyboardMETA)(XrSession session, const XrVirtualKeyboardCreateInfoMETA* createInfo, XrVirtualKeyboardMETA* keyboard);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyVirtualKeyboardMETA)(XrVirtualKeyboardMETA keyboard);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateVirtualKeyboardSpaceMETA)(XrSession session, XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardSpaceCreateInfoMETA* createInfo, XrSpace* keyboardSpace);
+typedef XrResult (XRAPI_PTR *PFN_xrSuggestVirtualKeyboardLocationMETA)(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardLocationInfoMETA* locationInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrGetVirtualKeyboardScaleMETA)(XrVirtualKeyboardMETA keyboard, float* scale);
+typedef XrResult (XRAPI_PTR *PFN_xrSetVirtualKeyboardModelVisibilityMETA)(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardModelVisibilitySetInfoMETA* modelVisibility);
+typedef XrResult (XRAPI_PTR *PFN_xrGetVirtualKeyboardModelAnimationStatesMETA)(XrVirtualKeyboardMETA keyboard, XrVirtualKeyboardModelAnimationStatesMETA* animationStates);
+typedef XrResult (XRAPI_PTR *PFN_xrGetVirtualKeyboardDirtyTexturesMETA)(XrVirtualKeyboardMETA keyboard, uint32_t textureIdCapacityInput, uint32_t* textureIdCountOutput, uint64_t* textureIds);
+typedef XrResult (XRAPI_PTR *PFN_xrGetVirtualKeyboardTextureDataMETA)(XrVirtualKeyboardMETA keyboard, uint64_t textureId, XrVirtualKeyboardTextureDataMETA* textureData);
+typedef XrResult (XRAPI_PTR *PFN_xrSendVirtualKeyboardInputMETA)(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardInputInfoMETA* info, XrPosef* interactorRootPose);
+typedef XrResult (XRAPI_PTR *PFN_xrChangeVirtualKeyboardTextContextMETA)(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardTextContextChangeInfoMETA* changeInfo);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateVirtualKeyboardMETA(
+    XrSession                                   session,
+    const XrVirtualKeyboardCreateInfoMETA*      createInfo,
+    XrVirtualKeyboardMETA*                      keyboard);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyVirtualKeyboardMETA(
+    XrVirtualKeyboardMETA                       keyboard);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateVirtualKeyboardSpaceMETA(
+    XrSession                                   session,
+    XrVirtualKeyboardMETA                       keyboard,
+    const XrVirtualKeyboardSpaceCreateInfoMETA* createInfo,
+    XrSpace*                                    keyboardSpace);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSuggestVirtualKeyboardLocationMETA(
+    XrVirtualKeyboardMETA                       keyboard,
+    const XrVirtualKeyboardLocationInfoMETA*    locationInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVirtualKeyboardScaleMETA(
+    XrVirtualKeyboardMETA                       keyboard,
+    float*                                      scale);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetVirtualKeyboardModelVisibilityMETA(
+    XrVirtualKeyboardMETA                       keyboard,
+    const XrVirtualKeyboardModelVisibilitySetInfoMETA* modelVisibility);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVirtualKeyboardModelAnimationStatesMETA(
+    XrVirtualKeyboardMETA                       keyboard,
+    XrVirtualKeyboardModelAnimationStatesMETA*  animationStates);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVirtualKeyboardDirtyTexturesMETA(
+    XrVirtualKeyboardMETA                       keyboard,
+    uint32_t                                    textureIdCapacityInput,
+    uint32_t*                                   textureIdCountOutput,
+    uint64_t*                                   textureIds);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVirtualKeyboardTextureDataMETA(
+    XrVirtualKeyboardMETA                       keyboard,
+    uint64_t                                    textureId,
+    XrVirtualKeyboardTextureDataMETA*           textureData);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSendVirtualKeyboardInputMETA(
+    XrVirtualKeyboardMETA                       keyboard,
+    const XrVirtualKeyboardInputInfoMETA*       info,
+    XrPosef*                                    interactorRootPose);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrChangeVirtualKeyboardTextContextMETA(
+    XrVirtualKeyboardMETA                       keyboard,
+    const XrVirtualKeyboardTextContextChangeInfoMETA* changeInfo);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_OCULUS_external_camera is a preprocessor guard. Do not pass it to API calls.
+#define XR_OCULUS_external_camera 1
+#define XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS 32
+#define XR_OCULUS_external_camera_SPEC_VERSION 1
+#define XR_OCULUS_EXTERNAL_CAMERA_EXTENSION_NAME "XR_OCULUS_external_camera"
+
+typedef enum XrExternalCameraAttachedToDeviceOCULUS {
+    XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_NONE_OCULUS = 0,
+    XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_HMD_OCULUS = 1,
+    XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_LTOUCH_OCULUS = 2,
+    XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_RTOUCH_OCULUS = 3,
+    XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_MAX_ENUM_OCULUS = 0x7FFFFFFF
+} XrExternalCameraAttachedToDeviceOCULUS;
+typedef XrFlags64 XrExternalCameraStatusFlagsOCULUS;
+
+// Flag bits for XrExternalCameraStatusFlagsOCULUS
+static const XrExternalCameraStatusFlagsOCULUS XR_EXTERNAL_CAMERA_STATUS_CONNECTED_BIT_OCULUS = 0x00000001;
+static const XrExternalCameraStatusFlagsOCULUS XR_EXTERNAL_CAMERA_STATUS_CALIBRATING_BIT_OCULUS = 0x00000002;
+static const XrExternalCameraStatusFlagsOCULUS XR_EXTERNAL_CAMERA_STATUS_CALIBRATION_FAILED_BIT_OCULUS = 0x00000004;
+static const XrExternalCameraStatusFlagsOCULUS XR_EXTERNAL_CAMERA_STATUS_CALIBRATED_BIT_OCULUS = 0x00000008;
+static const XrExternalCameraStatusFlagsOCULUS XR_EXTERNAL_CAMERA_STATUS_CAPTURING_BIT_OCULUS = 0x00000010;
+
+typedef struct XrExternalCameraIntrinsicsOCULUS {
+    XrTime         lastChangeTime;
+    XrFovf         fov;
+    float          virtualNearPlaneDistance;
+    float          virtualFarPlaneDistance;
+    XrExtent2Di    imageSensorPixelResolution;
+} XrExternalCameraIntrinsicsOCULUS;
+
+typedef struct XrExternalCameraExtrinsicsOCULUS {
+    XrTime                                    lastChangeTime;
+    XrExternalCameraStatusFlagsOCULUS         cameraStatusFlags;
+    XrExternalCameraAttachedToDeviceOCULUS    attachedToDevice;
+    XrPosef                                   relativePose;
+} XrExternalCameraExtrinsicsOCULUS;
+
+typedef struct XrExternalCameraOCULUS {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    char                                name[XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS];
+    XrExternalCameraIntrinsicsOCULUS    intrinsics;
+    XrExternalCameraExtrinsicsOCULUS    extrinsics;
+} XrExternalCameraOCULUS;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateExternalCamerasOCULUS)(XrSession session, uint32_t cameraCapacityInput, uint32_t* cameraCountOutput, XrExternalCameraOCULUS* cameras);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateExternalCamerasOCULUS(
+    XrSession                                   session,
+    uint32_t                                    cameraCapacityInput,
+    uint32_t*                                   cameraCountOutput,
+    XrExternalCameraOCULUS*                     cameras);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_performance_metrics is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_performance_metrics 1
+#define XR_META_performance_metrics_SPEC_VERSION 2
+#define XR_META_PERFORMANCE_METRICS_EXTENSION_NAME "XR_META_performance_metrics"
+
+typedef enum XrPerformanceMetricsCounterUnitMETA {
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_META = 0,
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_META = 1,
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_META = 2,
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_META = 3,
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_META = 4,
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_MAX_ENUM_META = 0x7FFFFFFF
+} XrPerformanceMetricsCounterUnitMETA;
+typedef XrFlags64 XrPerformanceMetricsCounterFlagsMETA;
+
+// Flag bits for XrPerformanceMetricsCounterFlagsMETA
+static const XrPerformanceMetricsCounterFlagsMETA XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_META = 0x00000001;
+static const XrPerformanceMetricsCounterFlagsMETA XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_META = 0x00000002;
+static const XrPerformanceMetricsCounterFlagsMETA XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_META = 0x00000004;
+
+typedef struct XrPerformanceMetricsStateMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    enabled;
+} XrPerformanceMetricsStateMETA;
+
+typedef struct XrPerformanceMetricsCounterMETA {
+    XrStructureType                         type;
+    const void* XR_MAY_ALIAS                next;
+    XrPerformanceMetricsCounterFlagsMETA    counterFlags;
+    XrPerformanceMetricsCounterUnitMETA     counterUnit;
+    uint32_t                                uintValue;
+    float                                   floatValue;
+} XrPerformanceMetricsCounterMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePerformanceMetricsCounterPathsMETA)(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t* counterPathCountOutput, XrPath* counterPaths);
+typedef XrResult (XRAPI_PTR *PFN_xrSetPerformanceMetricsStateMETA)(XrSession session, const XrPerformanceMetricsStateMETA* state);
+typedef XrResult (XRAPI_PTR *PFN_xrGetPerformanceMetricsStateMETA)(XrSession session, XrPerformanceMetricsStateMETA* state);
+typedef XrResult (XRAPI_PTR *PFN_xrQueryPerformanceMetricsCounterMETA)(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterMETA* counter);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumeratePerformanceMetricsCounterPathsMETA(
+    XrInstance                                  instance,
+    uint32_t                                    counterPathCapacityInput,
+    uint32_t*                                   counterPathCountOutput,
+    XrPath*                                     counterPaths);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetPerformanceMetricsStateMETA(
+    XrSession                                   session,
+    const XrPerformanceMetricsStateMETA*        state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetPerformanceMetricsStateMETA(
+    XrSession                                   session,
+    XrPerformanceMetricsStateMETA*              state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrQueryPerformanceMetricsCounterMETA(
+    XrSession                                   session,
+    XrPath                                      counterPath,
+    XrPerformanceMetricsCounterMETA*            counter);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_spatial_entity_storage_batch is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_spatial_entity_storage_batch 1
+#define XR_FB_spatial_entity_storage_batch_SPEC_VERSION 1
+#define XR_FB_SPATIAL_ENTITY_STORAGE_BATCH_EXTENSION_NAME "XR_FB_spatial_entity_storage_batch"
+typedef struct XrSpaceListSaveInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    spaceCount;
+    XrSpace*                    spaces;
+    XrSpaceStorageLocationFB    location;
+} XrSpaceListSaveInfoFB;
+
+typedef struct XrEventDataSpaceListSaveCompleteFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+} XrEventDataSpaceListSaveCompleteFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSaveSpaceListFB)(XrSession session, const XrSpaceListSaveInfoFB* info, XrAsyncRequestIdFB* requestId);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSaveSpaceListFB(
+    XrSession                                   session,
+    const XrSpaceListSaveInfoFB*                info,
+    XrAsyncRequestIdFB*                         requestId);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_detached_controllers is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_detached_controllers 1
+#define XR_META_detached_controllers_SPEC_VERSION 1
+#define XR_META_DETACHED_CONTROLLERS_EXTENSION_NAME "XR_META_detached_controllers"
+
+
+// XR_FB_spatial_entity_user is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_spatial_entity_user 1
+typedef uint64_t XrSpaceUserIdFB;
+#define XR_FB_spatial_entity_user_SPEC_VERSION 1
+#define XR_FB_SPATIAL_ENTITY_USER_EXTENSION_NAME "XR_FB_spatial_entity_user"
+typedef struct XrSpaceUserCreateInfoFB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpaceUserIdFB             userId;
+} XrSpaceUserCreateInfoFB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpaceUserFB)(XrSession session, const XrSpaceUserCreateInfoFB* info, XrSpaceUserFB* user);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceUserIdFB)(XrSpaceUserFB user, XrSpaceUserIdFB* userId);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpaceUserFB)(XrSpaceUserFB user);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpaceUserFB(
+    XrSession                                   session,
+    const XrSpaceUserCreateInfoFB*              info,
+    XrSpaceUserFB*                              user);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceUserIdFB(
+    XrSpaceUserFB                               user,
+    XrSpaceUserIdFB*                            userId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpaceUserFB(
+    XrSpaceUserFB                               user);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_headset_id is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_headset_id 1
+#define XR_META_headset_id_SPEC_VERSION   2
+#define XR_META_HEADSET_ID_EXTENSION_NAME "XR_META_headset_id"
+// XrSystemHeadsetIdPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemHeadsetIdPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrUuidEXT             id;
+} XrSystemHeadsetIdPropertiesMETA;
+
+
+
+// XR_META_spatial_entity_discovery is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_spatial_entity_discovery 1
+#define XR_META_spatial_entity_discovery_SPEC_VERSION 1
+#define XR_META_SPATIAL_ENTITY_DISCOVERY_EXTENSION_NAME "XR_META_spatial_entity_discovery"
+// XrSystemSpaceDiscoveryPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemSpaceDiscoveryPropertiesMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    supportsSpaceDiscovery;
+} XrSystemSpaceDiscoveryPropertiesMETA;
+
+typedef struct XR_MAY_ALIAS XrSpaceFilterBaseHeaderMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpaceFilterBaseHeaderMETA;
+
+typedef struct XrSpaceDiscoveryInfoMETA {
+    XrStructureType                               type;
+    const void* XR_MAY_ALIAS                      next;
+    uint32_t                                      filterCount;
+    const XrSpaceFilterBaseHeaderMETA* const *    filters;
+} XrSpaceDiscoveryInfoMETA;
+
+typedef struct XrSpaceFilterUuidMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    uuidCount;
+    const XrUuidEXT*            uuids;
+} XrSpaceFilterUuidMETA;
+
+typedef struct XrSpaceFilterComponentMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpaceComponentTypeFB      componentType;
+} XrSpaceFilterComponentMETA;
+
+typedef struct XrSpaceDiscoveryResultMETA {
+    XrSpace      space;
+    XrUuidEXT    uuid;
+} XrSpaceDiscoveryResultMETA;
+
+typedef struct XrSpaceDiscoveryResultsMETA {
+    XrStructureType                type;
+    const void* XR_MAY_ALIAS       next;
+    uint32_t                       resultCapacityInput;
+    uint32_t                       resultCountOutput;
+    XrSpaceDiscoveryResultMETA*    results;
+} XrSpaceDiscoveryResultsMETA;
+
+typedef struct XrEventDataSpaceDiscoveryResultsAvailableMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+} XrEventDataSpaceDiscoveryResultsAvailableMETA;
+
+typedef struct XrEventDataSpaceDiscoveryCompleteMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+} XrEventDataSpaceDiscoveryCompleteMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrDiscoverSpacesMETA)(XrSession session, const XrSpaceDiscoveryInfoMETA* info, XrAsyncRequestIdFB* requestId);
+typedef XrResult (XRAPI_PTR *PFN_xrRetrieveSpaceDiscoveryResultsMETA)(XrSession session, XrAsyncRequestIdFB requestId, XrSpaceDiscoveryResultsMETA* results);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrDiscoverSpacesMETA(
+    XrSession                                   session,
+    const XrSpaceDiscoveryInfoMETA*             info,
+    XrAsyncRequestIdFB*                         requestId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRetrieveSpaceDiscoveryResultsMETA(
+    XrSession                                   session,
+    XrAsyncRequestIdFB                          requestId,
+    XrSpaceDiscoveryResultsMETA*                results);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_hand_tracking_microgestures is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_hand_tracking_microgestures 1
+#define XR_META_hand_tracking_microgestures_SPEC_VERSION 1
+#define XR_META_HAND_TRACKING_MICROGESTURES_EXTENSION_NAME "XR_META_hand_tracking_microgestures"
+
+
+// XR_META_recommended_layer_resolution is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_recommended_layer_resolution 1
+#define XR_META_recommended_layer_resolution_SPEC_VERSION 1
+#define XR_META_RECOMMENDED_LAYER_RESOLUTION_EXTENSION_NAME "XR_META_recommended_layer_resolution"
+typedef struct XrRecommendedLayerResolutionMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrExtent2Di           recommendedImageDimensions;
+    XrBool32              isValid;
+} XrRecommendedLayerResolutionMETA;
+
+typedef struct XrRecommendedLayerResolutionGetInfoMETA {
+    XrStructureType                        type;
+    const void* XR_MAY_ALIAS               next;
+    const XrCompositionLayerBaseHeader*    layer;
+    XrTime                                 predictedDisplayTime;
+} XrRecommendedLayerResolutionGetInfoMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetRecommendedLayerResolutionMETA)(XrSession session, const XrRecommendedLayerResolutionGetInfoMETA* info, XrRecommendedLayerResolutionMETA* resolution);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetRecommendedLayerResolutionMETA(
+    XrSession                                   session,
+    const XrRecommendedLayerResolutionGetInfoMETA* info,
+    XrRecommendedLayerResolutionMETA*           resolution);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_spatial_entity_persistence is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_spatial_entity_persistence 1
+#define XR_META_spatial_entity_persistence_SPEC_VERSION 1
+#define XR_META_SPATIAL_ENTITY_PERSISTENCE_EXTENSION_NAME "XR_META_spatial_entity_persistence"
+// XrSystemSpacePersistencePropertiesMETA extends XrSystemProperties
+typedef struct XrSystemSpacePersistencePropertiesMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    supportsSpacePersistence;
+} XrSystemSpacePersistencePropertiesMETA;
+
+typedef struct XrSpacesSaveInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    spaceCount;
+    XrSpace*                    spaces;
+} XrSpacesSaveInfoMETA;
+
+typedef struct XrEventDataSpacesSaveResultMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+} XrEventDataSpacesSaveResultMETA;
+
+typedef struct XrSpacesEraseInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    spaceCount;
+    XrSpace*                    spaces;
+    uint32_t                    uuidCount;
+    XrUuidEXT*                  uuids;
+} XrSpacesEraseInfoMETA;
+
+typedef struct XrEventDataSpacesEraseResultMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+} XrEventDataSpacesEraseResultMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSaveSpacesMETA)(XrSession session, const XrSpacesSaveInfoMETA* info, XrAsyncRequestIdFB* requestId);
+typedef XrResult (XRAPI_PTR *PFN_xrEraseSpacesMETA)(XrSession session, const XrSpacesEraseInfoMETA* info, XrAsyncRequestIdFB* requestId);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSaveSpacesMETA(
+    XrSession                                   session,
+    const XrSpacesSaveInfoMETA*                 info,
+    XrAsyncRequestIdFB*                         requestId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEraseSpacesMETA(
+    XrSession                                   session,
+    const XrSpacesEraseInfoMETA*                info,
+    XrAsyncRequestIdFB*                         requestId);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_passthrough_color_lut is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_passthrough_color_lut 1
+XR_DEFINE_HANDLE(XrPassthroughColorLutMETA)
+#define XR_META_passthrough_color_lut_SPEC_VERSION 1
+#define XR_META_PASSTHROUGH_COLOR_LUT_EXTENSION_NAME "XR_META_passthrough_color_lut"
+
+typedef enum XrPassthroughColorLutChannelsMETA {
+    XR_PASSTHROUGH_COLOR_LUT_CHANNELS_RGB_META = 1,
+    XR_PASSTHROUGH_COLOR_LUT_CHANNELS_RGBA_META = 2,
+    XR_PASSTHROUGH_COLOR_LUT_CHANNELS_MAX_ENUM_META = 0x7FFFFFFF
+} XrPassthroughColorLutChannelsMETA;
+typedef struct XrPassthroughColorLutDataMETA {
+    uint32_t          bufferSize;
+    const uint8_t*    buffer;
+} XrPassthroughColorLutDataMETA;
+
+typedef struct XrPassthroughColorLutCreateInfoMETA {
+    XrStructureType                      type;
+    const void* XR_MAY_ALIAS             next;
+    XrPassthroughColorLutChannelsMETA    channels;
+    uint32_t                             resolution;
+    XrPassthroughColorLutDataMETA        data;
+} XrPassthroughColorLutCreateInfoMETA;
+
+typedef struct XrPassthroughColorLutUpdateInfoMETA {
+    XrStructureType                  type;
+    const void* XR_MAY_ALIAS         next;
+    XrPassthroughColorLutDataMETA    data;
+} XrPassthroughColorLutUpdateInfoMETA;
+
+// XrPassthroughColorMapLutMETA extends XrPassthroughStyleFB
+typedef struct XrPassthroughColorMapLutMETA {
+    XrStructureType              type;
+    const void* XR_MAY_ALIAS     next;
+    XrPassthroughColorLutMETA    colorLut;
+    float                        weight;
+} XrPassthroughColorMapLutMETA;
+
+// XrPassthroughColorMapInterpolatedLutMETA extends XrPassthroughStyleFB
+typedef struct XrPassthroughColorMapInterpolatedLutMETA {
+    XrStructureType              type;
+    const void* XR_MAY_ALIAS     next;
+    XrPassthroughColorLutMETA    sourceColorLut;
+    XrPassthroughColorLutMETA    targetColorLut;
+    float                        weight;
+} XrPassthroughColorMapInterpolatedLutMETA;
+
+// XrSystemPassthroughColorLutPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemPassthroughColorLutPropertiesMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    maxColorLutResolution;
+} XrSystemPassthroughColorLutPropertiesMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughColorLutMETA)(XrPassthroughFB passthrough, const XrPassthroughColorLutCreateInfoMETA* createInfo, XrPassthroughColorLutMETA* colorLut);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughColorLutMETA)(XrPassthroughColorLutMETA colorLut);
+typedef XrResult (XRAPI_PTR *PFN_xrUpdatePassthroughColorLutMETA)(XrPassthroughColorLutMETA colorLut, const XrPassthroughColorLutUpdateInfoMETA* updateInfo);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughColorLutMETA(
+    XrPassthroughFB                             passthrough,
+    const XrPassthroughColorLutCreateInfoMETA*  createInfo,
+    XrPassthroughColorLutMETA*                  colorLut);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughColorLutMETA(
+    XrPassthroughColorLutMETA                   colorLut);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUpdatePassthroughColorLutMETA(
+    XrPassthroughColorLutMETA                   colorLut,
+    const XrPassthroughColorLutUpdateInfoMETA*  updateInfo);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_spatial_entity_mesh is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_spatial_entity_mesh 1
+#define XR_META_spatial_entity_mesh_SPEC_VERSION 1
+#define XR_META_SPATIAL_ENTITY_MESH_EXTENSION_NAME "XR_META_spatial_entity_mesh"
+typedef struct XrSpaceTriangleMeshGetInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpaceTriangleMeshGetInfoMETA;
+
+typedef struct XrSpaceTriangleMeshMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              vertexCapacityInput;
+    uint32_t              vertexCountOutput;
+    XrVector3f*           vertices;
+    uint32_t              indexCapacityInput;
+    uint32_t              indexCountOutput;
+    uint32_t*             indices;
+} XrSpaceTriangleMeshMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceTriangleMeshMETA)(XrSpace space, const XrSpaceTriangleMeshGetInfoMETA* getInfo, XrSpaceTriangleMeshMETA* triangleMeshOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceTriangleMeshMETA(
+    XrSpace                                     space,
+    const XrSpaceTriangleMeshGetInfoMETA*       getInfo,
+    XrSpaceTriangleMeshMETA*                    triangleMeshOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_automatic_layer_filter is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_automatic_layer_filter 1
+#define XR_META_automatic_layer_filter_SPEC_VERSION 1
+#define XR_META_AUTOMATIC_LAYER_FILTER_EXTENSION_NAME "XR_META_automatic_layer_filter"
+
+
+// XR_META_body_tracking_full_body is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_body_tracking_full_body 1
+#define XR_META_body_tracking_full_body_SPEC_VERSION 1
+#define XR_META_BODY_TRACKING_FULL_BODY_EXTENSION_NAME "XR_META_body_tracking_full_body"
+
+typedef enum XrFullBodyJointMETA {
+    XR_FULL_BODY_JOINT_ROOT_META = 0,
+    XR_FULL_BODY_JOINT_HIPS_META = 1,
+    XR_FULL_BODY_JOINT_SPINE_LOWER_META = 2,
+    XR_FULL_BODY_JOINT_SPINE_MIDDLE_META = 3,
+    XR_FULL_BODY_JOINT_SPINE_UPPER_META = 4,
+    XR_FULL_BODY_JOINT_CHEST_META = 5,
+    XR_FULL_BODY_JOINT_NECK_META = 6,
+    XR_FULL_BODY_JOINT_HEAD_META = 7,
+    XR_FULL_BODY_JOINT_LEFT_SHOULDER_META = 8,
+    XR_FULL_BODY_JOINT_LEFT_SCAPULA_META = 9,
+    XR_FULL_BODY_JOINT_LEFT_ARM_UPPER_META = 10,
+    XR_FULL_BODY_JOINT_LEFT_ARM_LOWER_META = 11,
+    XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_TWIST_META = 12,
+    XR_FULL_BODY_JOINT_RIGHT_SHOULDER_META = 13,
+    XR_FULL_BODY_JOINT_RIGHT_SCAPULA_META = 14,
+    XR_FULL_BODY_JOINT_RIGHT_ARM_UPPER_META = 15,
+    XR_FULL_BODY_JOINT_RIGHT_ARM_LOWER_META = 16,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_META = 17,
+    XR_FULL_BODY_JOINT_LEFT_HAND_PALM_META = 18,
+    XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_META = 19,
+    XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_META = 20,
+    XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_META = 21,
+    XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_META = 22,
+    XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_TIP_META = 23,
+    XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_META = 24,
+    XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_META = 25,
+    XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_META = 26,
+    XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_META = 27,
+    XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_TIP_META = 28,
+    XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_META = 29,
+    XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_META = 30,
+    XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_META = 31,
+    XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_META = 32,
+    XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_META = 33,
+    XR_FULL_BODY_JOINT_LEFT_HAND_RING_METACARPAL_META = 34,
+    XR_FULL_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_META = 35,
+    XR_FULL_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_META = 36,
+    XR_FULL_BODY_JOINT_LEFT_HAND_RING_DISTAL_META = 37,
+    XR_FULL_BODY_JOINT_LEFT_HAND_RING_TIP_META = 38,
+    XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_META = 39,
+    XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_META = 40,
+    XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_META = 41,
+    XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_META = 42,
+    XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_TIP_META = 43,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_PALM_META = 44,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_META = 45,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_META = 46,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_META = 47,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_META = 48,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_TIP_META = 49,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_META = 50,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_META = 51,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_META = 52,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_META = 53,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_TIP_META = 54,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_META = 55,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_META = 56,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_META = 57,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_META = 58,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_META = 59,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_META = 60,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_META = 61,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_META = 62,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_RING_DISTAL_META = 63,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_RING_TIP_META = 64,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_META = 65,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_META = 66,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_META = 67,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_META = 68,
+    XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_META = 69,
+    XR_FULL_BODY_JOINT_LEFT_UPPER_LEG_META = 70,
+    XR_FULL_BODY_JOINT_LEFT_LOWER_LEG_META = 71,
+    XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_TWIST_META = 72,
+    XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_META = 73,
+    XR_FULL_BODY_JOINT_LEFT_FOOT_SUBTALAR_META = 74,
+    XR_FULL_BODY_JOINT_LEFT_FOOT_TRANSVERSE_META = 75,
+    XR_FULL_BODY_JOINT_LEFT_FOOT_BALL_META = 76,
+    XR_FULL_BODY_JOINT_RIGHT_UPPER_LEG_META = 77,
+    XR_FULL_BODY_JOINT_RIGHT_LOWER_LEG_META = 78,
+    XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_TWIST_META = 79,
+    XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_META = 80,
+    XR_FULL_BODY_JOINT_RIGHT_FOOT_SUBTALAR_META = 81,
+    XR_FULL_BODY_JOINT_RIGHT_FOOT_TRANSVERSE_META = 82,
+    XR_FULL_BODY_JOINT_RIGHT_FOOT_BALL_META = 83,
+    XR_FULL_BODY_JOINT_COUNT_META = 84,
+    XR_FULL_BODY_JOINT_NONE_META = 85,
+    XR_FULL_BODY_JOINT_MAX_ENUM_META = 0x7FFFFFFF
+} XrFullBodyJointMETA;
+// XrSystemPropertiesBodyTrackingFullBodyMETA extends XrSystemProperties
+typedef struct XrSystemPropertiesBodyTrackingFullBodyMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsFullBodyTracking;
+} XrSystemPropertiesBodyTrackingFullBodyMETA;
+
+
+
+// XR_META_touch_controller_plus is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_touch_controller_plus 1
+#define XR_META_touch_controller_plus_SPEC_VERSION 1
+#define XR_META_TOUCH_CONTROLLER_PLUS_EXTENSION_NAME "XR_META_touch_controller_plus"
+
+
+// XR_META_passthrough_layer_resumed_event is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_passthrough_layer_resumed_event 1
+#define XR_META_passthrough_layer_resumed_event_SPEC_VERSION 1
+#define XR_META_PASSTHROUGH_LAYER_RESUMED_EVENT_EXTENSION_NAME "XR_META_passthrough_layer_resumed_event"
+typedef struct XrEventDataPassthroughLayerResumedMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrPassthroughLayerFB        layer;
+} XrEventDataPassthroughLayerResumedMETA;
+
+
+
+// XR_META_body_tracking_calibration is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_body_tracking_calibration 1
+#define XR_META_body_tracking_calibration_SPEC_VERSION 1
+#define XR_META_BODY_TRACKING_CALIBRATION_EXTENSION_NAME "XR_META_body_tracking_calibration"
+
+typedef enum XrBodyTrackingCalibrationStateMETA {
+    XR_BODY_TRACKING_CALIBRATION_STATE_VALID_META = 1,
+    XR_BODY_TRACKING_CALIBRATION_STATE_CALIBRATING_META = 2,
+    XR_BODY_TRACKING_CALIBRATION_STATE_INVALID_META = 3,
+    XR_BODY_TRACKING_CALIBRATION_STATE_MAX_ENUM_META = 0x7FFFFFFF
+} XrBodyTrackingCalibrationStateMETA;
+// XrBodyTrackingCalibrationStatusMETA extends XrBodyJointLocationsFB
+typedef struct XrBodyTrackingCalibrationStatusMETA {
+    XrStructureType                       type;
+    void* XR_MAY_ALIAS                    next;
+    XrBodyTrackingCalibrationStateMETA    status;
+} XrBodyTrackingCalibrationStatusMETA;
+
+typedef struct XrBodyTrackingCalibrationInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       bodyHeight;
+} XrBodyTrackingCalibrationInfoMETA;
+
+// XrSystemPropertiesBodyTrackingCalibrationMETA extends XrSystemProperties
+typedef struct XrSystemPropertiesBodyTrackingCalibrationMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsHeightOverride;
+} XrSystemPropertiesBodyTrackingCalibrationMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSuggestBodyTrackingCalibrationOverrideMETA)(XrBodyTrackerFB bodyTracker, const XrBodyTrackingCalibrationInfoMETA* calibrationInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrResetBodyTrackingCalibrationMETA)(XrBodyTrackerFB bodyTracker);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSuggestBodyTrackingCalibrationOverrideMETA(
+    XrBodyTrackerFB                             bodyTracker,
+    const XrBodyTrackingCalibrationInfoMETA*    calibrationInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrResetBodyTrackingCalibrationMETA(
+    XrBodyTrackerFB                             bodyTracker);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_body_tracking_fidelity is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_body_tracking_fidelity 1
+#define XR_META_body_tracking_fidelity_SPEC_VERSION 1
+#define XR_META_BODY_TRACKING_FIDELITY_EXTENSION_NAME "XR_META_body_tracking_fidelity"
+
+typedef enum XrBodyTrackingFidelityMETA {
+    XR_BODY_TRACKING_FIDELITY_LOW_META = 1,
+    XR_BODY_TRACKING_FIDELITY_HIGH_META = 2,
+    XR_BODY_TRACKING_FIDELITY_MAX_ENUM_META = 0x7FFFFFFF
+} XrBodyTrackingFidelityMETA;
+// XrSystemPropertiesBodyTrackingFidelityMETA extends XrSystemProperties
+typedef struct XrSystemPropertiesBodyTrackingFidelityMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsBodyTrackingFidelity;
+} XrSystemPropertiesBodyTrackingFidelityMETA;
+
+// XrBodyTrackingFidelityStatusMETA extends XrBodyJointLocationsFB
+typedef struct XrBodyTrackingFidelityStatusMETA {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    XrBodyTrackingFidelityMETA    fidelity;
+} XrBodyTrackingFidelityStatusMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrRequestBodyTrackingFidelityMETA)(XrBodyTrackerFB bodyTracker, const XrBodyTrackingFidelityMETA fidelity);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestBodyTrackingFidelityMETA(
+    XrBodyTrackerFB                             bodyTracker,
+    const XrBodyTrackingFidelityMETA            fidelity);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_FB_face_tracking2 is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_face_tracking2 1
+XR_DEFINE_HANDLE(XrFaceTracker2FB)
+#define XR_FB_face_tracking2_SPEC_VERSION 1
+#define XR_FB_FACE_TRACKING2_EXTENSION_NAME "XR_FB_face_tracking2"
+
+typedef enum XrFaceExpression2FB {
+    XR_FACE_EXPRESSION2_BROW_LOWERER_L_FB = 0,
+    XR_FACE_EXPRESSION2_BROW_LOWERER_R_FB = 1,
+    XR_FACE_EXPRESSION2_CHEEK_PUFF_L_FB = 2,
+    XR_FACE_EXPRESSION2_CHEEK_PUFF_R_FB = 3,
+    XR_FACE_EXPRESSION2_CHEEK_RAISER_L_FB = 4,
+    XR_FACE_EXPRESSION2_CHEEK_RAISER_R_FB = 5,
+    XR_FACE_EXPRESSION2_CHEEK_SUCK_L_FB = 6,
+    XR_FACE_EXPRESSION2_CHEEK_SUCK_R_FB = 7,
+    XR_FACE_EXPRESSION2_CHIN_RAISER_B_FB = 8,
+    XR_FACE_EXPRESSION2_CHIN_RAISER_T_FB = 9,
+    XR_FACE_EXPRESSION2_DIMPLER_L_FB = 10,
+    XR_FACE_EXPRESSION2_DIMPLER_R_FB = 11,
+    XR_FACE_EXPRESSION2_EYES_CLOSED_L_FB = 12,
+    XR_FACE_EXPRESSION2_EYES_CLOSED_R_FB = 13,
+    XR_FACE_EXPRESSION2_EYES_LOOK_DOWN_L_FB = 14,
+    XR_FACE_EXPRESSION2_EYES_LOOK_DOWN_R_FB = 15,
+    XR_FACE_EXPRESSION2_EYES_LOOK_LEFT_L_FB = 16,
+    XR_FACE_EXPRESSION2_EYES_LOOK_LEFT_R_FB = 17,
+    XR_FACE_EXPRESSION2_EYES_LOOK_RIGHT_L_FB = 18,
+    XR_FACE_EXPRESSION2_EYES_LOOK_RIGHT_R_FB = 19,
+    XR_FACE_EXPRESSION2_EYES_LOOK_UP_L_FB = 20,
+    XR_FACE_EXPRESSION2_EYES_LOOK_UP_R_FB = 21,
+    XR_FACE_EXPRESSION2_INNER_BROW_RAISER_L_FB = 22,
+    XR_FACE_EXPRESSION2_INNER_BROW_RAISER_R_FB = 23,
+    XR_FACE_EXPRESSION2_JAW_DROP_FB = 24,
+    XR_FACE_EXPRESSION2_JAW_SIDEWAYS_LEFT_FB = 25,
+    XR_FACE_EXPRESSION2_JAW_SIDEWAYS_RIGHT_FB = 26,
+    XR_FACE_EXPRESSION2_JAW_THRUST_FB = 27,
+    XR_FACE_EXPRESSION2_LID_TIGHTENER_L_FB = 28,
+    XR_FACE_EXPRESSION2_LID_TIGHTENER_R_FB = 29,
+    XR_FACE_EXPRESSION2_LIP_CORNER_DEPRESSOR_L_FB = 30,
+    XR_FACE_EXPRESSION2_LIP_CORNER_DEPRESSOR_R_FB = 31,
+    XR_FACE_EXPRESSION2_LIP_CORNER_PULLER_L_FB = 32,
+    XR_FACE_EXPRESSION2_LIP_CORNER_PULLER_R_FB = 33,
+    XR_FACE_EXPRESSION2_LIP_FUNNELER_LB_FB = 34,
+    XR_FACE_EXPRESSION2_LIP_FUNNELER_LT_FB = 35,
+    XR_FACE_EXPRESSION2_LIP_FUNNELER_RB_FB = 36,
+    XR_FACE_EXPRESSION2_LIP_FUNNELER_RT_FB = 37,
+    XR_FACE_EXPRESSION2_LIP_PRESSOR_L_FB = 38,
+    XR_FACE_EXPRESSION2_LIP_PRESSOR_R_FB = 39,
+    XR_FACE_EXPRESSION2_LIP_PUCKER_L_FB = 40,
+    XR_FACE_EXPRESSION2_LIP_PUCKER_R_FB = 41,
+    XR_FACE_EXPRESSION2_LIP_STRETCHER_L_FB = 42,
+    XR_FACE_EXPRESSION2_LIP_STRETCHER_R_FB = 43,
+    XR_FACE_EXPRESSION2_LIP_SUCK_LB_FB = 44,
+    XR_FACE_EXPRESSION2_LIP_SUCK_LT_FB = 45,
+    XR_FACE_EXPRESSION2_LIP_SUCK_RB_FB = 46,
+    XR_FACE_EXPRESSION2_LIP_SUCK_RT_FB = 47,
+    XR_FACE_EXPRESSION2_LIP_TIGHTENER_L_FB = 48,
+    XR_FACE_EXPRESSION2_LIP_TIGHTENER_R_FB = 49,
+    XR_FACE_EXPRESSION2_LIPS_TOWARD_FB = 50,
+    XR_FACE_EXPRESSION2_LOWER_LIP_DEPRESSOR_L_FB = 51,
+    XR_FACE_EXPRESSION2_LOWER_LIP_DEPRESSOR_R_FB = 52,
+    XR_FACE_EXPRESSION2_MOUTH_LEFT_FB = 53,
+    XR_FACE_EXPRESSION2_MOUTH_RIGHT_FB = 54,
+    XR_FACE_EXPRESSION2_NOSE_WRINKLER_L_FB = 55,
+    XR_FACE_EXPRESSION2_NOSE_WRINKLER_R_FB = 56,
+    XR_FACE_EXPRESSION2_OUTER_BROW_RAISER_L_FB = 57,
+    XR_FACE_EXPRESSION2_OUTER_BROW_RAISER_R_FB = 58,
+    XR_FACE_EXPRESSION2_UPPER_LID_RAISER_L_FB = 59,
+    XR_FACE_EXPRESSION2_UPPER_LID_RAISER_R_FB = 60,
+    XR_FACE_EXPRESSION2_UPPER_LIP_RAISER_L_FB = 61,
+    XR_FACE_EXPRESSION2_UPPER_LIP_RAISER_R_FB = 62,
+    XR_FACE_EXPRESSION2_TONGUE_TIP_INTERDENTAL_FB = 63,
+    XR_FACE_EXPRESSION2_TONGUE_TIP_ALVEOLAR_FB = 64,
+    XR_FACE_EXPRESSION2_TONGUE_FRONT_DORSAL_PALATE_FB = 65,
+    XR_FACE_EXPRESSION2_TONGUE_MID_DORSAL_PALATE_FB = 66,
+    XR_FACE_EXPRESSION2_TONGUE_BACK_DORSAL_VELAR_FB = 67,
+    XR_FACE_EXPRESSION2_TONGUE_OUT_FB = 68,
+    XR_FACE_EXPRESSION2_TONGUE_RETREAT_FB = 69,
+    XR_FACE_EXPRESSION2_COUNT_FB = 70,
+    XR_FACE_EXPRESSION_2FB_MAX_ENUM_FB = 0x7FFFFFFF
+} XrFaceExpression2FB;
+
+typedef enum XrFaceExpressionSet2FB {
+    XR_FACE_EXPRESSION_SET2_DEFAULT_FB = 0,
+    XR_FACE_EXPRESSION_SET_2FB_MAX_ENUM_FB = 0x7FFFFFFF
+} XrFaceExpressionSet2FB;
+
+typedef enum XrFaceTrackingDataSource2FB {
+    XR_FACE_TRACKING_DATA_SOURCE2_VISUAL_FB = 0,
+    XR_FACE_TRACKING_DATA_SOURCE2_AUDIO_FB = 1,
+    XR_FACE_TRACKING_DATA_SOURCE_2FB_MAX_ENUM_FB = 0x7FFFFFFF
+} XrFaceTrackingDataSource2FB;
+
+typedef enum XrFaceConfidence2FB {
+    XR_FACE_CONFIDENCE2_LOWER_FACE_FB = 0,
+    XR_FACE_CONFIDENCE2_UPPER_FACE_FB = 1,
+    XR_FACE_CONFIDENCE2_COUNT_FB = 2,
+    XR_FACE_CONFIDENCE_2FB_MAX_ENUM_FB = 0x7FFFFFFF
+} XrFaceConfidence2FB;
+// XrSystemFaceTrackingProperties2FB extends XrSystemProperties
+typedef struct XrSystemFaceTrackingProperties2FB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsVisualFaceTracking;
+    XrBool32              supportsAudioFaceTracking;
+} XrSystemFaceTrackingProperties2FB;
+
+typedef struct XrFaceTrackerCreateInfo2FB {
+    XrStructureType                 type;
+    const void* XR_MAY_ALIAS        next;
+    XrFaceExpressionSet2FB          faceExpressionSet;
+    uint32_t                        requestedDataSourceCount;
+    XrFaceTrackingDataSource2FB*    requestedDataSources;
+} XrFaceTrackerCreateInfo2FB;
+
+typedef struct XrFaceExpressionInfo2FB {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      time;
+} XrFaceExpressionInfo2FB;
+
+typedef struct XrFaceExpressionWeights2FB {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    uint32_t                       weightCount;
+    float*                         weights;
+    uint32_t                       confidenceCount;
+    float*                         confidences;
+    XrBool32                       isValid;
+    XrBool32                       isEyeFollowingBlendshapesValid;
+    XrFaceTrackingDataSource2FB    dataSource;
+    XrTime                         time;
+} XrFaceExpressionWeights2FB;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTracker2FB)(XrSession session, const XrFaceTrackerCreateInfo2FB* createInfo, XrFaceTracker2FB* faceTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTracker2FB)(XrFaceTracker2FB faceTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrGetFaceExpressionWeights2FB)(XrFaceTracker2FB faceTracker, const XrFaceExpressionInfo2FB* expressionInfo, XrFaceExpressionWeights2FB* expressionWeights);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateFaceTracker2FB(
+    XrSession                                   session,
+    const XrFaceTrackerCreateInfo2FB*           createInfo,
+    XrFaceTracker2FB*                           faceTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFaceTracker2FB(
+    XrFaceTracker2FB                            faceTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetFaceExpressionWeights2FB(
+    XrFaceTracker2FB                            faceTracker,
+    const XrFaceExpressionInfo2FB*              expressionInfo,
+    XrFaceExpressionWeights2FB*                 expressionWeights);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_spatial_entity_sharing is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_spatial_entity_sharing 1
+#define XR_META_spatial_entity_sharing_SPEC_VERSION 1
+#define XR_META_SPATIAL_ENTITY_SHARING_EXTENSION_NAME "XR_META_spatial_entity_sharing"
+#define XR_MAX_SPACES_PER_SHARE_REQUEST_META 32
+// XrSystemSpatialEntitySharingPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemSpatialEntitySharingPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsSpatialEntitySharing;
+} XrSystemSpatialEntitySharingPropertiesMETA;
+
+typedef struct XR_MAY_ALIAS XrShareSpacesRecipientBaseHeaderMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrShareSpacesRecipientBaseHeaderMETA;
+
+typedef struct XrShareSpacesInfoMETA {
+    XrStructureType                                type;
+    const void* XR_MAY_ALIAS                       next;
+    uint32_t                                       spaceCount;
+    XrSpace*                                       spaces;
+    const XrShareSpacesRecipientBaseHeaderMETA*    recipientInfo;
+} XrShareSpacesInfoMETA;
+
+typedef struct XrEventDataShareSpacesCompleteMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+} XrEventDataShareSpacesCompleteMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrShareSpacesMETA)(XrSession session, const XrShareSpacesInfoMETA* info, XrAsyncRequestIdFB* requestId);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrShareSpacesMETA(
+    XrSession                                   session,
+    const XrShareSpacesInfoMETA*                info,
+    XrAsyncRequestIdFB*                         requestId);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_environment_depth is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_environment_depth 1
+XR_DEFINE_HANDLE(XrEnvironmentDepthProviderMETA)
+XR_DEFINE_HANDLE(XrEnvironmentDepthSwapchainMETA)
+#define XR_META_environment_depth_SPEC_VERSION 2
+#define XR_META_ENVIRONMENT_DEPTH_EXTENSION_NAME "XR_META_environment_depth"
+typedef XrFlags64 XrEnvironmentDepthProviderCreateFlagsMETA;
+
+// Flag bits for XrEnvironmentDepthProviderCreateFlagsMETA
+
+typedef XrFlags64 XrEnvironmentDepthSwapchainCreateFlagsMETA;
+
+// Flag bits for XrEnvironmentDepthSwapchainCreateFlagsMETA
+
+typedef struct XrEnvironmentDepthProviderCreateInfoMETA {
+    XrStructureType                              type;
+    const void* XR_MAY_ALIAS                     next;
+    XrEnvironmentDepthProviderCreateFlagsMETA    createFlags;
+} XrEnvironmentDepthProviderCreateInfoMETA;
+
+typedef struct XrEnvironmentDepthSwapchainCreateInfoMETA {
+    XrStructureType                               type;
+    const void* XR_MAY_ALIAS                      next;
+    XrEnvironmentDepthSwapchainCreateFlagsMETA    createFlags;
+} XrEnvironmentDepthSwapchainCreateInfoMETA;
+
+typedef struct XrEnvironmentDepthSwapchainStateMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              width;
+    uint32_t              height;
+} XrEnvironmentDepthSwapchainStateMETA;
+
+typedef struct XrEnvironmentDepthImageAcquireInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrTime                      displayTime;
+} XrEnvironmentDepthImageAcquireInfoMETA;
+
+typedef struct XrEnvironmentDepthImageViewMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrFovf                      fov;
+    XrPosef                     pose;
+} XrEnvironmentDepthImageViewMETA;
+
+typedef struct XrEnvironmentDepthImageMETA {
+    XrStructureType                    type;
+    const void* XR_MAY_ALIAS           next;
+    uint32_t                           swapchainIndex;
+    float                              nearZ;
+    float                              farZ;
+    XrEnvironmentDepthImageViewMETA    views[2];
+} XrEnvironmentDepthImageMETA;
+
+// XrEnvironmentDepthImageTimestampMETA extends XrEnvironmentDepthImageMETA
+typedef struct XrEnvironmentDepthImageTimestampMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      captureTime;
+} XrEnvironmentDepthImageTimestampMETA;
+
+typedef struct XrEnvironmentDepthHandRemovalSetInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    enabled;
+} XrEnvironmentDepthHandRemovalSetInfoMETA;
+
+// XrSystemEnvironmentDepthPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemEnvironmentDepthPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsEnvironmentDepth;
+    XrBool32              supportsHandRemoval;
+} XrSystemEnvironmentDepthPropertiesMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentDepthProviderMETA)(XrSession session, const XrEnvironmentDepthProviderCreateInfoMETA* createInfo, XrEnvironmentDepthProviderMETA* environmentDepthProvider);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider);
+typedef XrResult (XRAPI_PTR *PFN_xrStartEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider);
+typedef XrResult (XRAPI_PTR *PFN_xrStopEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthSwapchainCreateInfoMETA* createInfo, XrEnvironmentDepthSwapchainMETA* swapchain);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthSwapchainMETA swapchain);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentDepthSwapchainImagesMETA)(XrEnvironmentDepthSwapchainMETA swapchain, uint32_t imageCapacityInput, uint32_t* imageCountOutput, XrSwapchainImageBaseHeader* images);
+typedef XrResult (XRAPI_PTR *PFN_xrGetEnvironmentDepthSwapchainStateMETA)(XrEnvironmentDepthSwapchainMETA swapchain, XrEnvironmentDepthSwapchainStateMETA* state);
+typedef XrResult (XRAPI_PTR *PFN_xrAcquireEnvironmentDepthImageMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthImageAcquireInfoMETA* acquireInfo, XrEnvironmentDepthImageMETA* environmentDepthImage);
+typedef XrResult (XRAPI_PTR *PFN_xrSetEnvironmentDepthHandRemovalMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthHandRemovalSetInfoMETA* setInfo);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateEnvironmentDepthProviderMETA(
+    XrSession                                   session,
+    const XrEnvironmentDepthProviderCreateInfoMETA* createInfo,
+    XrEnvironmentDepthProviderMETA*             environmentDepthProvider);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyEnvironmentDepthProviderMETA(
+    XrEnvironmentDepthProviderMETA              environmentDepthProvider);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStartEnvironmentDepthProviderMETA(
+    XrEnvironmentDepthProviderMETA              environmentDepthProvider);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStopEnvironmentDepthProviderMETA(
+    XrEnvironmentDepthProviderMETA              environmentDepthProvider);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateEnvironmentDepthSwapchainMETA(
+    XrEnvironmentDepthProviderMETA              environmentDepthProvider,
+    const XrEnvironmentDepthSwapchainCreateInfoMETA* createInfo,
+    XrEnvironmentDepthSwapchainMETA*            swapchain);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyEnvironmentDepthSwapchainMETA(
+    XrEnvironmentDepthSwapchainMETA             swapchain);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentDepthSwapchainImagesMETA(
+    XrEnvironmentDepthSwapchainMETA             swapchain,
+    uint32_t                                    imageCapacityInput,
+    uint32_t*                                   imageCountOutput,
+    XrSwapchainImageBaseHeader*                 images);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetEnvironmentDepthSwapchainStateMETA(
+    XrEnvironmentDepthSwapchainMETA             swapchain,
+    XrEnvironmentDepthSwapchainStateMETA*       state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrAcquireEnvironmentDepthImageMETA(
+    XrEnvironmentDepthProviderMETA              environmentDepthProvider,
+    const XrEnvironmentDepthImageAcquireInfoMETA* acquireInfo,
+    XrEnvironmentDepthImageMETA*                environmentDepthImage);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetEnvironmentDepthHandRemovalMETA(
+    XrEnvironmentDepthProviderMETA              environmentDepthProvider,
+    const XrEnvironmentDepthHandRemovalSetInfoMETA* setInfo);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_uuid is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_uuid 1
+#define XR_EXT_uuid_SPEC_VERSION          1
+#define XR_EXT_UUID_EXTENSION_NAME        "XR_EXT_uuid"
+#define XR_UUID_SIZE_EXT                  16
+
+
+// XR_EXT_render_model is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_render_model 1
+XR_DEFINE_ATOM(XrRenderModelIdEXT)
+XR_DEFINE_HANDLE(XrRenderModelEXT)
+XR_DEFINE_HANDLE(XrRenderModelAssetEXT)
+#define XR_MAX_RENDER_MODEL_ASSET_NODE_NAME_SIZE_EXT 64
+#define XR_EXT_render_model_SPEC_VERSION  1
+#define XR_EXT_RENDER_MODEL_EXTENSION_NAME "XR_EXT_render_model"
+#define XR_NULL_RENDER_MODEL_ID_EXT       0
+typedef struct XrRenderModelCreateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrRenderModelIdEXT          renderModelId;
+    uint32_t                    gltfExtensionCount;
+    const char* const*          gltfExtensions;
+} XrRenderModelCreateInfoEXT;
+
+typedef struct XrRenderModelPropertiesGetInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrRenderModelPropertiesGetInfoEXT;
+
+typedef struct XrRenderModelPropertiesEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrUuidEXT             cacheId;
+    uint32_t              animatableNodeCount;
+} XrRenderModelPropertiesEXT;
+
+typedef struct XrRenderModelSpaceCreateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrRenderModelEXT            renderModel;
+} XrRenderModelSpaceCreateInfoEXT;
+
+typedef struct XrRenderModelStateGetInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      displayTime;
+} XrRenderModelStateGetInfoEXT;
+
+typedef struct XrRenderModelNodeStateEXT {
+    XrPosef     nodePose;
+    XrBool32    isVisible;
+} XrRenderModelNodeStateEXT;
+
+typedef struct XrRenderModelStateEXT {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    uint32_t                      nodeStateCount;
+    XrRenderModelNodeStateEXT*    nodeStates;
+} XrRenderModelStateEXT;
+
+typedef struct XrRenderModelAssetCreateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrUuidEXT                   cacheId;
+} XrRenderModelAssetCreateInfoEXT;
+
+typedef struct XrRenderModelAssetDataGetInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrRenderModelAssetDataGetInfoEXT;
+
+typedef struct XrRenderModelAssetDataEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              bufferCapacityInput;
+    uint32_t              bufferCountOutput;
+    uint8_t*              buffer;
+} XrRenderModelAssetDataEXT;
+
+typedef struct XrRenderModelAssetPropertiesGetInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrRenderModelAssetPropertiesGetInfoEXT;
+
+typedef struct XrRenderModelAssetNodePropertiesEXT {
+    char    uniqueName[XR_MAX_RENDER_MODEL_ASSET_NODE_NAME_SIZE_EXT];
+} XrRenderModelAssetNodePropertiesEXT;
+
+typedef struct XrRenderModelAssetPropertiesEXT {
+    XrStructureType                         type;
+    void* XR_MAY_ALIAS                      next;
+    uint32_t                                nodePropertyCount;
+    XrRenderModelAssetNodePropertiesEXT*    nodeProperties;
+} XrRenderModelAssetPropertiesEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateRenderModelEXT)(XrSession session, const XrRenderModelCreateInfoEXT* createInfo, XrRenderModelEXT* renderModel);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyRenderModelEXT)(XrRenderModelEXT renderModel);
+typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelPropertiesEXT)(XrRenderModelEXT renderModel, const XrRenderModelPropertiesGetInfoEXT* getInfo, XrRenderModelPropertiesEXT* properties);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateRenderModelSpaceEXT)(XrSession session, const XrRenderModelSpaceCreateInfoEXT* createInfo, XrSpace* space);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateRenderModelAssetEXT)(XrSession session, const XrRenderModelAssetCreateInfoEXT* createInfo, XrRenderModelAssetEXT* asset);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyRenderModelAssetEXT)(XrRenderModelAssetEXT asset);
+typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelAssetDataEXT)(XrRenderModelAssetEXT asset, const XrRenderModelAssetDataGetInfoEXT* getInfo, XrRenderModelAssetDataEXT* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelAssetPropertiesEXT)(XrRenderModelAssetEXT asset, const XrRenderModelAssetPropertiesGetInfoEXT* getInfo, XrRenderModelAssetPropertiesEXT* properties);
+typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelStateEXT)(XrRenderModelEXT renderModel, const XrRenderModelStateGetInfoEXT* getInfo, XrRenderModelStateEXT* state);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateRenderModelEXT(
+    XrSession                                   session,
+    const XrRenderModelCreateInfoEXT*           createInfo,
+    XrRenderModelEXT*                           renderModel);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyRenderModelEXT(
+    XrRenderModelEXT                            renderModel);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelPropertiesEXT(
+    XrRenderModelEXT                            renderModel,
+    const XrRenderModelPropertiesGetInfoEXT*    getInfo,
+    XrRenderModelPropertiesEXT*                 properties);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateRenderModelSpaceEXT(
+    XrSession                                   session,
+    const XrRenderModelSpaceCreateInfoEXT*      createInfo,
+    XrSpace*                                    space);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateRenderModelAssetEXT(
+    XrSession                                   session,
+    const XrRenderModelAssetCreateInfoEXT*      createInfo,
+    XrRenderModelAssetEXT*                      asset);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyRenderModelAssetEXT(
+    XrRenderModelAssetEXT                       asset);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelAssetDataEXT(
+    XrRenderModelAssetEXT                       asset,
+    const XrRenderModelAssetDataGetInfoEXT*     getInfo,
+    XrRenderModelAssetDataEXT*                  buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelAssetPropertiesEXT(
+    XrRenderModelAssetEXT                       asset,
+    const XrRenderModelAssetPropertiesGetInfoEXT* getInfo,
+    XrRenderModelAssetPropertiesEXT*            properties);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelStateEXT(
+    XrRenderModelEXT                            renderModel,
+    const XrRenderModelStateGetInfoEXT*         getInfo,
+    XrRenderModelStateEXT*                      state);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_interaction_render_model is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_interaction_render_model 1
+#define XR_EXT_interaction_render_model_SPEC_VERSION 1
+#define XR_EXT_INTERACTION_RENDER_MODEL_EXTENSION_NAME "XR_EXT_interaction_render_model"
+typedef struct XrInteractionRenderModelIdsEnumerateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrInteractionRenderModelIdsEnumerateInfoEXT;
+
+typedef struct XrInteractionRenderModelSubactionPathInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrInteractionRenderModelSubactionPathInfoEXT;
+
+typedef struct XrInteractionRenderModelTopLevelUserPathGetInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    topLevelUserPathCount;
+    const XrPath*               topLevelUserPaths;
+} XrInteractionRenderModelTopLevelUserPathGetInfoEXT;
+
+typedef struct XrEventDataInteractionRenderModelsChangedEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrEventDataInteractionRenderModelsChangedEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateInteractionRenderModelIdsEXT)(XrSession session, const XrInteractionRenderModelIdsEnumerateInfoEXT* getInfo, uint32_t renderModelIdCapacityInput, uint32_t* renderModelIdCountOutput, XrRenderModelIdEXT* renderModelIds);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateRenderModelSubactionPathsEXT)(XrRenderModelEXT renderModel, const XrInteractionRenderModelSubactionPathInfoEXT* info, uint32_t pathCapacityInput, uint32_t* pathCountOutput, XrPath* paths);
+typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelPoseTopLevelUserPathEXT)(XrRenderModelEXT renderModel, const XrInteractionRenderModelTopLevelUserPathGetInfoEXT* info, XrPath* topLevelUserPath);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateInteractionRenderModelIdsEXT(
+    XrSession                                   session,
+    const XrInteractionRenderModelIdsEnumerateInfoEXT* getInfo,
+    uint32_t                                    renderModelIdCapacityInput,
+    uint32_t*                                   renderModelIdCountOutput,
+    XrRenderModelIdEXT*                         renderModelIds);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateRenderModelSubactionPathsEXT(
+    XrRenderModelEXT                            renderModel,
+    const XrInteractionRenderModelSubactionPathInfoEXT* info,
+    uint32_t                                    pathCapacityInput,
+    uint32_t*                                   pathCountOutput,
+    XrPath*                                     paths);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelPoseTopLevelUserPathEXT(
+    XrRenderModelEXT                            renderModel,
+    const XrInteractionRenderModelTopLevelUserPathGetInfoEXT* info,
+    XrPath*                                     topLevelUserPath);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_hand_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_hand_interaction 1
+#define XR_EXT_hand_interaction_SPEC_VERSION 2
+#define XR_EXT_HAND_INTERACTION_EXTENSION_NAME "XR_EXT_hand_interaction"
+
+
+// XR_QCOM_tracking_optimization_settings is a preprocessor guard. Do not pass it to API calls.
+#define XR_QCOM_tracking_optimization_settings 1
+#define XR_QCOM_tracking_optimization_settings_SPEC_VERSION 2
+#define XR_QCOM_TRACKING_OPTIMIZATION_SETTINGS_EXTENSION_NAME "XR_QCOM_tracking_optimization_settings"
+
+typedef enum XrTrackingOptimizationSettingsDomainQCOM {
+    XR_TRACKING_OPTIMIZATION_SETTINGS_DOMAIN_ALL_QCOM = 1,
+    XR_TRACKING_OPTIMIZATION_SETTINGS_DOMAIN_MAX_ENUM_QCOM = 0x7FFFFFFF
+} XrTrackingOptimizationSettingsDomainQCOM;
+
+typedef enum XrTrackingOptimizationSettingsHintQCOM {
+    XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_NONE_QCOM = 0,
+    XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORITIZATION_QCOM = 1,
+    XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORITIZATION_QCOM = 2,
+    XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORITIZATION_QCOM = 3,
+    XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORITIZATION_QCOM = 4,
+    XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORIZATION_QCOM = XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORITIZATION_QCOM,
+    XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORIZATION_QCOM = XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORITIZATION_QCOM,
+    XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORIZATION_QCOM = XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORITIZATION_QCOM,
+    XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORIZATION_QCOM = XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORITIZATION_QCOM,
+    XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_MAX_ENUM_QCOM = 0x7FFFFFFF
+} XrTrackingOptimizationSettingsHintQCOM;
+typedef XrResult (XRAPI_PTR *PFN_xrSetTrackingOptimizationSettingsHintQCOM)(XrSession session, XrTrackingOptimizationSettingsDomainQCOM domain, XrTrackingOptimizationSettingsHintQCOM hint);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetTrackingOptimizationSettingsHintQCOM(
+    XrSession                                   session,
+    XrTrackingOptimizationSettingsDomainQCOM    domain,
+    XrTrackingOptimizationSettingsHintQCOM      hint);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_QCOM_hand_tracking_gesture is a preprocessor guard. Do not pass it to API calls.
+#define XR_QCOM_hand_tracking_gesture 1
+#define XR_QCOM_hand_tracking_gesture_SPEC_VERSION 1
+#define XR_QCOM_HAND_TRACKING_GESTURE_EXTENSION_NAME "XR_QCOM_hand_tracking_gesture"
+
+typedef enum XrHandGestureTypeQCOM {
+    XR_HAND_GESTURE_TYPE_UNKNOWN_QCOM = -1,
+    XR_HAND_GESTURE_TYPE_OPEN_HAND_QCOM = 0,
+    XR_HAND_GESTURE_TYPE_GRAB_QCOM = 2,
+    XR_HAND_GESTURE_TYPE_PINCH_QCOM = 7,
+    XR_HAND_GESTURE_TYPE_MAX_ENUM_QCOM = 0x7FFFFFFF
+} XrHandGestureTypeQCOM;
+typedef struct XrHandGestureQCOM {
+    XrHandGestureTypeQCOM    gesture;
+    float                    gestureRatio;
+    float                    flipRatio;
+} XrHandGestureQCOM;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetHandGestureQCOM)(XrHandTrackerEXT handTracker, XrTime time, XrHandGestureQCOM* handGesture);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetHandGestureQCOM(
+    XrHandTrackerEXT                            handTracker,
+    XrTime                                      time,
+    XrHandGestureQCOM*                          handGesture);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_HTC_passthrough is a preprocessor guard. Do not pass it to API calls.
+#define XR_HTC_passthrough 1
+XR_DEFINE_HANDLE(XrPassthroughHTC)
+#define XR_HTC_passthrough_SPEC_VERSION   1
+#define XR_HTC_PASSTHROUGH_EXTENSION_NAME "XR_HTC_passthrough"
+
+typedef enum XrPassthroughFormHTC {
+    XR_PASSTHROUGH_FORM_PLANAR_HTC = 0,
+    XR_PASSTHROUGH_FORM_PROJECTED_HTC = 1,
+    XR_PASSTHROUGH_FORM_MAX_ENUM_HTC = 0x7FFFFFFF
+} XrPassthroughFormHTC;
+typedef struct XrPassthroughCreateInfoHTC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrPassthroughFormHTC        form;
+} XrPassthroughCreateInfoHTC;
+
+typedef struct XrPassthroughColorHTC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       alpha;
+} XrPassthroughColorHTC;
+
+// XrPassthroughMeshTransformInfoHTC extends XrCompositionLayerPassthroughHTC
+typedef struct XrPassthroughMeshTransformInfoHTC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    vertexCount;
+    const XrVector3f*           vertices;
+    uint32_t                    indexCount;
+    const uint32_t*             indices;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+    XrPosef                     pose;
+    XrVector3f                  scale;
+} XrPassthroughMeshTransformInfoHTC;
+
+typedef struct XrCompositionLayerPassthroughHTC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCompositionLayerFlags     layerFlags;
+    XrSpace                     space;
+    XrPassthroughHTC            passthrough;
+    XrPassthroughColorHTC       color;
+} XrCompositionLayerPassthroughHTC;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughHTC)(XrSession session, const XrPassthroughCreateInfoHTC* createInfo, XrPassthroughHTC* passthrough);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughHTC)(XrPassthroughHTC passthrough);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughHTC(
+    XrSession                                   session,
+    const XrPassthroughCreateInfoHTC*           createInfo,
+    XrPassthroughHTC*                           passthrough);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughHTC(
+    XrPassthroughHTC                            passthrough);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_HTC_foveation is a preprocessor guard. Do not pass it to API calls.
+#define XR_HTC_foveation 1
+#define XR_HTC_foveation_SPEC_VERSION     1
+#define XR_HTC_FOVEATION_EXTENSION_NAME   "XR_HTC_foveation"
+
+typedef enum XrFoveationModeHTC {
+    XR_FOVEATION_MODE_DISABLE_HTC = 0,
+    XR_FOVEATION_MODE_FIXED_HTC = 1,
+    XR_FOVEATION_MODE_DYNAMIC_HTC = 2,
+    XR_FOVEATION_MODE_CUSTOM_HTC = 3,
+    XR_FOVEATION_MODE_MAX_ENUM_HTC = 0x7FFFFFFF
+} XrFoveationModeHTC;
+
+typedef enum XrFoveationLevelHTC {
+    XR_FOVEATION_LEVEL_NONE_HTC = 0,
+    XR_FOVEATION_LEVEL_LOW_HTC = 1,
+    XR_FOVEATION_LEVEL_MEDIUM_HTC = 2,
+    XR_FOVEATION_LEVEL_HIGH_HTC = 3,
+    XR_FOVEATION_LEVEL_MAX_ENUM_HTC = 0x7FFFFFFF
+} XrFoveationLevelHTC;
+typedef XrFlags64 XrFoveationDynamicFlagsHTC;
+
+// Flag bits for XrFoveationDynamicFlagsHTC
+static const XrFoveationDynamicFlagsHTC XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_BIT_HTC = 0x00000001;
+static const XrFoveationDynamicFlagsHTC XR_FOVEATION_DYNAMIC_CLEAR_FOV_ENABLED_BIT_HTC = 0x00000002;
+static const XrFoveationDynamicFlagsHTC XR_FOVEATION_DYNAMIC_FOCAL_CENTER_OFFSET_ENABLED_BIT_HTC = 0x00000004;
+
+typedef struct XrFoveationApplyInfoHTC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrFoveationModeHTC          mode;
+    uint32_t                    subImageCount;
+    XrSwapchainSubImage*        subImages;
+} XrFoveationApplyInfoHTC;
+
+typedef struct XrFoveationConfigurationHTC {
+    XrFoveationLevelHTC    level;
+    float                  clearFovDegree;
+    XrVector2f             focalCenterOffset;
+} XrFoveationConfigurationHTC;
+
+// XrFoveationDynamicModeInfoHTC extends XrFoveationApplyInfoHTC
+typedef struct XrFoveationDynamicModeInfoHTC {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrFoveationDynamicFlagsHTC    dynamicFlags;
+} XrFoveationDynamicModeInfoHTC;
+
+// XrFoveationCustomModeInfoHTC extends XrFoveationApplyInfoHTC
+typedef struct XrFoveationCustomModeInfoHTC {
+    XrStructureType                       type;
+    const void* XR_MAY_ALIAS              next;
+    uint32_t                              configCount;
+    const XrFoveationConfigurationHTC*    configs;
+} XrFoveationCustomModeInfoHTC;
+
+typedef XrResult (XRAPI_PTR *PFN_xrApplyFoveationHTC)(XrSession session, const XrFoveationApplyInfoHTC* applyInfo);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrApplyFoveationHTC(
+    XrSession                                   session,
+    const XrFoveationApplyInfoHTC*              applyInfo);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_HTC_anchor is a preprocessor guard. Do not pass it to API calls.
+#define XR_HTC_anchor 1
+#define XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC 256
+#define XR_HTC_anchor_SPEC_VERSION        1
+#define XR_HTC_ANCHOR_EXTENSION_NAME      "XR_HTC_anchor"
+// XrSystemAnchorPropertiesHTC extends XrSystemProperties
+typedef struct XrSystemAnchorPropertiesHTC {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsAnchor;
+} XrSystemAnchorPropertiesHTC;
+
+typedef struct XrSpatialAnchorNameHTC {
+    char    name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC];
+} XrSpatialAnchorNameHTC;
+
+typedef struct XrSpatialAnchorCreateInfoHTC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrPosef                     poseInSpace;
+    XrSpatialAnchorNameHTC      name;
+} XrSpatialAnchorCreateInfoHTC;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorHTC)(XrSession session, const XrSpatialAnchorCreateInfoHTC* createInfo, XrSpace* anchor);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialAnchorNameHTC)(XrSpace anchor, XrSpatialAnchorNameHTC* name);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorHTC(
+    XrSession                                   session,
+    const XrSpatialAnchorCreateInfoHTC*         createInfo,
+    XrSpace*                                    anchor);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialAnchorNameHTC(
+    XrSpace                                     anchor,
+    XrSpatialAnchorNameHTC*                     name);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_HTC_body_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_HTC_body_tracking 1
+
+#define XR_BODY_JOINT_COUNT_HTC 26
+
+XR_DEFINE_HANDLE(XrBodyTrackerHTC)
+#define XR_HTC_body_tracking_SPEC_VERSION 1
+#define XR_HTC_BODY_TRACKING_EXTENSION_NAME "XR_HTC_body_tracking"
+
+typedef enum XrBodyJointHTC {
+    XR_BODY_JOINT_PELVIS_HTC = 0,
+    XR_BODY_JOINT_LEFT_HIP_HTC = 1,
+    XR_BODY_JOINT_LEFT_KNEE_HTC = 2,
+    XR_BODY_JOINT_LEFT_ANKLE_HTC = 3,
+    XR_BODY_JOINT_LEFT_FEET_HTC = 4,
+    XR_BODY_JOINT_RIGHT_HIP_HTC = 5,
+    XR_BODY_JOINT_RIGHT_KNEE_HTC = 6,
+    XR_BODY_JOINT_RIGHT_ANKLE_HTC = 7,
+    XR_BODY_JOINT_RIGHT_FEET_HTC = 8,
+    XR_BODY_JOINT_WAIST_HTC = 9,
+    XR_BODY_JOINT_SPINE_LOWER_HTC = 10,
+    XR_BODY_JOINT_SPINE_MIDDLE_HTC = 11,
+    XR_BODY_JOINT_SPINE_HIGH_HTC = 12,
+    XR_BODY_JOINT_CHEST_HTC = 13,
+    XR_BODY_JOINT_NECK_HTC = 14,
+    XR_BODY_JOINT_HEAD_HTC = 15,
+    XR_BODY_JOINT_LEFT_CLAVICLE_HTC = 16,
+    XR_BODY_JOINT_LEFT_SCAPULA_HTC = 17,
+    XR_BODY_JOINT_LEFT_ARM_HTC = 18,
+    XR_BODY_JOINT_LEFT_ELBOW_HTC = 19,
+    XR_BODY_JOINT_LEFT_WRIST_HTC = 20,
+    XR_BODY_JOINT_RIGHT_CLAVICLE_HTC = 21,
+    XR_BODY_JOINT_RIGHT_SCAPULA_HTC = 22,
+    XR_BODY_JOINT_RIGHT_ARM_HTC = 23,
+    XR_BODY_JOINT_RIGHT_ELBOW_HTC = 24,
+    XR_BODY_JOINT_RIGHT_WRIST_HTC = 25,
+    XR_BODY_JOINT_MAX_ENUM_HTC = 0x7FFFFFFF
+} XrBodyJointHTC;
+
+typedef enum XrBodyJointSetHTC {
+    XR_BODY_JOINT_SET_FULL_HTC = 0,
+    XR_BODY_JOINT_SET_MAX_ENUM_HTC = 0x7FFFFFFF
+} XrBodyJointSetHTC;
+
+typedef enum XrBodyJointConfidenceHTC {
+    XR_BODY_JOINT_CONFIDENCE_NONE_HTC = 0,
+    XR_BODY_JOINT_CONFIDENCE_LOW_HTC = 1,
+    XR_BODY_JOINT_CONFIDENCE_HIGH_HTC = 2,
+    XR_BODY_JOINT_CONFIDENCE_MAX_ENUM_HTC = 0x7FFFFFFF
+} XrBodyJointConfidenceHTC;
+// XrSystemBodyTrackingPropertiesHTC extends XrSystemProperties
+typedef struct XrSystemBodyTrackingPropertiesHTC {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsBodyTracking;
+} XrSystemBodyTrackingPropertiesHTC;
+
+typedef struct XrBodyTrackerCreateInfoHTC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBodyJointSetHTC           bodyJointSet;
+} XrBodyTrackerCreateInfoHTC;
+
+typedef struct XrBodyJointsLocateInfoHTC {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+} XrBodyJointsLocateInfoHTC;
+
+typedef struct XrBodyJointLocationHTC {
+    XrSpaceLocationFlags    locationFlags;
+    XrPosef                 pose;
+} XrBodyJointLocationHTC;
+
+typedef struct XrBodyJointLocationsHTC {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    XrSpaceLocationFlags        combinedLocationFlags;
+    XrBodyJointConfidenceHTC    confidenceLevel;
+    uint32_t                    jointLocationCount;
+    XrBodyJointLocationHTC*     jointLocations;
+    uint32_t                    skeletonGenerationId;
+} XrBodyJointLocationsHTC;
+
+typedef struct XrBodySkeletonJointHTC {
+    XrPosef    pose;
+} XrBodySkeletonJointHTC;
+
+typedef struct XrBodySkeletonHTC {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    uint32_t                   jointCount;
+    XrBodySkeletonJointHTC*    joints;
+} XrBodySkeletonHTC;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateBodyTrackerHTC)(XrSession session, const XrBodyTrackerCreateInfoHTC* createInfo, XrBodyTrackerHTC* bodyTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyBodyTrackerHTC)(XrBodyTrackerHTC bodyTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrLocateBodyJointsHTC)(XrBodyTrackerHTC bodyTracker, const XrBodyJointsLocateInfoHTC* locateInfo, XrBodyJointLocationsHTC* locations);
+typedef XrResult (XRAPI_PTR *PFN_xrGetBodySkeletonHTC)(XrBodyTrackerHTC bodyTracker, XrSpace baseSpace, uint32_t skeletonGenerationId, XrBodySkeletonHTC* skeleton);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateBodyTrackerHTC(
+    XrSession                                   session,
+    const XrBodyTrackerCreateInfoHTC*           createInfo,
+    XrBodyTrackerHTC*                           bodyTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyBodyTrackerHTC(
+    XrBodyTrackerHTC                            bodyTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateBodyJointsHTC(
+    XrBodyTrackerHTC                            bodyTracker,
+    const XrBodyJointsLocateInfoHTC*            locateInfo,
+    XrBodyJointLocationsHTC*                    locations);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetBodySkeletonHTC(
+    XrBodyTrackerHTC                            bodyTracker,
+    XrSpace                                     baseSpace,
+    uint32_t                                    skeletonGenerationId,
+    XrBodySkeletonHTC*                          skeleton);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_active_action_set_priority is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_active_action_set_priority 1
+#define XR_EXT_active_action_set_priority_SPEC_VERSION 1
+#define XR_EXT_ACTIVE_ACTION_SET_PRIORITY_EXTENSION_NAME "XR_EXT_active_action_set_priority"
+typedef struct XrActiveActionSetPriorityEXT {
+    XrActionSet    actionSet;
+    uint32_t       priorityOverride;
+} XrActiveActionSetPriorityEXT;
+
+// XrActiveActionSetPrioritiesEXT extends XrActionsSyncInfo
+typedef struct XrActiveActionSetPrioritiesEXT {
+    XrStructureType                        type;
+    const void* XR_MAY_ALIAS               next;
+    uint32_t                               actionSetPriorityCount;
+    const XrActiveActionSetPriorityEXT*    actionSetPriorities;
+} XrActiveActionSetPrioritiesEXT;
+
+
+
+// XR_MNDX_force_feedback_curl is a preprocessor guard. Do not pass it to API calls.
+#define XR_MNDX_force_feedback_curl 1
+#define XR_MNDX_force_feedback_curl_SPEC_VERSION 1
+#define XR_MNDX_FORCE_FEEDBACK_CURL_EXTENSION_NAME "XR_MNDX_force_feedback_curl"
+
+typedef enum XrForceFeedbackCurlLocationMNDX {
+    XR_FORCE_FEEDBACK_CURL_LOCATION_THUMB_CURL_MNDX = 0,
+    XR_FORCE_FEEDBACK_CURL_LOCATION_INDEX_CURL_MNDX = 1,
+    XR_FORCE_FEEDBACK_CURL_LOCATION_MIDDLE_CURL_MNDX = 2,
+    XR_FORCE_FEEDBACK_CURL_LOCATION_RING_CURL_MNDX = 3,
+    XR_FORCE_FEEDBACK_CURL_LOCATION_LITTLE_CURL_MNDX = 4,
+    XR_FORCE_FEEDBACK_CURL_LOCATION_MAX_ENUM_MNDX = 0x7FFFFFFF
+} XrForceFeedbackCurlLocationMNDX;
+// XrSystemForceFeedbackCurlPropertiesMNDX extends XrSystemProperties
+typedef struct XrSystemForceFeedbackCurlPropertiesMNDX {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsForceFeedbackCurl;
+} XrSystemForceFeedbackCurlPropertiesMNDX;
+
+typedef struct XrForceFeedbackCurlApplyLocationMNDX {
+    XrForceFeedbackCurlLocationMNDX    location;
+    float                              value;
+} XrForceFeedbackCurlApplyLocationMNDX;
+
+typedef struct XrForceFeedbackCurlApplyLocationsMNDX {
+    XrStructureType                          type;
+    const void* XR_MAY_ALIAS                 next;
+    uint32_t                                 locationCount;
+    XrForceFeedbackCurlApplyLocationMNDX*    locations;
+} XrForceFeedbackCurlApplyLocationsMNDX;
+
+typedef XrResult (XRAPI_PTR *PFN_xrApplyForceFeedbackCurlMNDX)(XrHandTrackerEXT handTracker, const XrForceFeedbackCurlApplyLocationsMNDX* locations);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrApplyForceFeedbackCurlMNDX(
+    XrHandTrackerEXT                            handTracker,
+    const XrForceFeedbackCurlApplyLocationsMNDX* locations);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_BD_controller_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_controller_interaction 1
+#define XR_BD_controller_interaction_SPEC_VERSION 2
+#define XR_BD_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_BD_controller_interaction"
+
+
+// XR_BD_body_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_body_tracking 1
+
+#define XR_BODY_JOINT_COUNT_BD 24
+
+
+#define XR_BODY_JOINT_WITHOUT_ARM_COUNT_BD 16
+
+XR_DEFINE_HANDLE(XrBodyTrackerBD)
+#define XR_BD_body_tracking_SPEC_VERSION  1
+#define XR_BD_BODY_TRACKING_EXTENSION_NAME "XR_BD_body_tracking"
+
+typedef enum XrBodyJointBD {
+    XR_BODY_JOINT_PELVIS_BD = 0,
+    XR_BODY_JOINT_LEFT_HIP_BD = 1,
+    XR_BODY_JOINT_RIGHT_HIP_BD = 2,
+    XR_BODY_JOINT_SPINE1_BD = 3,
+    XR_BODY_JOINT_LEFT_KNEE_BD = 4,
+    XR_BODY_JOINT_RIGHT_KNEE_BD = 5,
+    XR_BODY_JOINT_SPINE2_BD = 6,
+    XR_BODY_JOINT_LEFT_ANKLE_BD = 7,
+    XR_BODY_JOINT_RIGHT_ANKLE_BD = 8,
+    XR_BODY_JOINT_SPINE3_BD = 9,
+    XR_BODY_JOINT_LEFT_FOOT_BD = 10,
+    XR_BODY_JOINT_RIGHT_FOOT_BD = 11,
+    XR_BODY_JOINT_NECK_BD = 12,
+    XR_BODY_JOINT_LEFT_COLLAR_BD = 13,
+    XR_BODY_JOINT_RIGHT_COLLAR_BD = 14,
+    XR_BODY_JOINT_HEAD_BD = 15,
+    XR_BODY_JOINT_LEFT_SHOULDER_BD = 16,
+    XR_BODY_JOINT_RIGHT_SHOULDER_BD = 17,
+    XR_BODY_JOINT_LEFT_ELBOW_BD = 18,
+    XR_BODY_JOINT_RIGHT_ELBOW_BD = 19,
+    XR_BODY_JOINT_LEFT_WRIST_BD = 20,
+    XR_BODY_JOINT_RIGHT_WRIST_BD = 21,
+    XR_BODY_JOINT_LEFT_HAND_BD = 22,
+    XR_BODY_JOINT_RIGHT_HAND_BD = 23,
+    XR_BODY_JOINT_MAX_ENUM_BD = 0x7FFFFFFF
+} XrBodyJointBD;
+
+typedef enum XrBodyJointSetBD {
+    XR_BODY_JOINT_SET_BODY_WITHOUT_ARM_BD = 1,
+    XR_BODY_JOINT_SET_FULL_BODY_JOINTS_BD = 2,
+    XR_BODY_JOINT_SET_MAX_ENUM_BD = 0x7FFFFFFF
+} XrBodyJointSetBD;
+// XrSystemBodyTrackingPropertiesBD extends XrSystemProperties
+typedef struct XrSystemBodyTrackingPropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsBodyTracking;
+} XrSystemBodyTrackingPropertiesBD;
+
+typedef struct XrBodyTrackerCreateInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBodyJointSetBD            jointSet;
+} XrBodyTrackerCreateInfoBD;
+
+typedef struct XrBodyJointsLocateInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+} XrBodyJointsLocateInfoBD;
+
+typedef struct XrBodyJointLocationBD {
+    XrSpaceLocationFlags    locationFlags;
+    XrPosef                 pose;
+} XrBodyJointLocationBD;
+
+typedef struct XrBodyJointLocationsBD {
+    XrStructureType           type;
+    void* XR_MAY_ALIAS        next;
+    XrBool32                  allJointPosesTracked;
+    uint32_t                  jointLocationCount;
+    XrBodyJointLocationBD*    jointLocations;
+} XrBodyJointLocationsBD;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateBodyTrackerBD)(XrSession session, const XrBodyTrackerCreateInfoBD* createInfo, XrBodyTrackerBD* bodyTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyBodyTrackerBD)(XrBodyTrackerBD bodyTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrLocateBodyJointsBD)(XrBodyTrackerBD bodyTracker, const XrBodyJointsLocateInfoBD* locateInfo, XrBodyJointLocationsBD* locations);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateBodyTrackerBD(
+    XrSession                                   session,
+    const XrBodyTrackerCreateInfoBD*            createInfo,
+    XrBodyTrackerBD*                            bodyTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyBodyTrackerBD(
+    XrBodyTrackerBD                             bodyTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateBodyJointsBD(
+    XrBodyTrackerBD                             bodyTracker,
+    const XrBodyJointsLocateInfoBD*             locateInfo,
+    XrBodyJointLocationsBD*                     locations);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_BD_facial_simulation is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_facial_simulation 1
+
+#define XR_FACE_EXPRESSION_COUNT_BD 52
+
+
+#define XR_LIP_EXPRESSION_COUNT_BD 20
+
+ XR_DEFINE_HANDLE(XrFaceTrackerBD)
+#define XR_BD_facial_simulation_SPEC_VERSION 1
+#define XR_BD_FACIAL_SIMULATION_EXTENSION_NAME "XR_BD_facial_simulation"
+
+typedef enum XrFacialSimulationModeBD {
+    XR_FACIAL_SIMULATION_MODE_DEFAULT_BD = 0,
+    XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_BD = 1,
+    XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_WITH_LIP_BD = 2,
+    XR_FACIAL_SIMULATION_MODE_ONLY_AUDIO_WITH_LIP_BD = 3,
+    XR_FACIAL_SIMULATION_MODE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrFacialSimulationModeBD;
+
+typedef enum XrFaceExpressionBD {
+    XR_FACE_EXPRESSION_BROW_DROP_L_BD = 0,
+    XR_FACE_EXPRESSION_BROW_DROP_R_BD = 1,
+    XR_FACE_EXPRESSION_BROW_INNER_UPWARDS_BD = 2,
+    XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_L_BD = 3,
+    XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_R_BD = 4,
+    XR_FACE_EXPRESSION_EYE_BLINK_L_BD = 5,
+    XR_FACE_EXPRESSION_EYE_LOOK_DROP_L_BD = 6,
+    XR_FACE_EXPRESSION_EYE_LOOK_IN_L_BD = 7,
+    XR_FACE_EXPRESSION_EYE_LOOK_OUT_L_BD = 8,
+    XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_L_BD = 9,
+    XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_L_BD = 10,
+    XR_FACE_EXPRESSION_EYE_LOOK_WIDE_L_BD = 11,
+    XR_FACE_EXPRESSION_EYE_BLINK_R_BD = 12,
+    XR_FACE_EXPRESSION_EYE_LOOK_DROP_R_BD = 13,
+    XR_FACE_EXPRESSION_EYE_LOOK_IN_R_BD = 14,
+    XR_FACE_EXPRESSION_EYE_LOOK_OUT_R_BD = 15,
+    XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_R_BD = 16,
+    XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_R_BD = 17,
+    XR_FACE_EXPRESSION_EYE_LOOK_WIDE_R_BD = 18,
+    XR_FACE_EXPRESSION_NOSE_SNEER_L_BD = 19,
+    XR_FACE_EXPRESSION_NOSE_SNEER_R_BD = 20,
+    XR_FACE_EXPRESSION_CHEEK_PUFF_BD = 21,
+    XR_FACE_EXPRESSION_CHEEK_SQUINT_L_BD = 22,
+    XR_FACE_EXPRESSION_CHEEK_SQUINT_R_BD = 23,
+    XR_FACE_EXPRESSION_MOUTH_CLOSE_BD = 24,
+    XR_FACE_EXPRESSION_MOUTH_FUNNEL_BD = 25,
+    XR_FACE_EXPRESSION_MOUTH_PUCKER_BD = 26,
+    XR_FACE_EXPRESSION_MOUTH_L_BD = 27,
+    XR_FACE_EXPRESSION_MOUTH_R_BD = 28,
+    XR_FACE_EXPRESSION_MOUTH_SMILE_L_BD = 29,
+    XR_FACE_EXPRESSION_MOUTH_SMILE_R_BD = 30,
+    XR_FACE_EXPRESSION_MOUTH_FROWN_L_BD = 31,
+    XR_FACE_EXPRESSION_MOUTH_FROWN_R_BD = 32,
+    XR_FACE_EXPRESSION_MOUTH_DIMPLE_L_BD = 33,
+    XR_FACE_EXPRESSION_MOUTH_DIMPLE_R_BD = 34,
+    XR_FACE_EXPRESSION_MOUTH_STRETCH_L_BD = 35,
+    XR_FACE_EXPRESSION_MOUTH_STRETCH_R_BD = 36,
+    XR_FACE_EXPRESSION_MOUTH_ROLL_LOWER_BD = 37,
+    XR_FACE_EXPRESSION_MOUTH_ROLL_UPPER_BD = 38,
+    XR_FACE_EXPRESSION_MOUTH_SHRUG_LOWER_BD = 39,
+    XR_FACE_EXPRESSION_MOUTH_SHRUG_UPPER_BD = 40,
+    XR_FACE_EXPRESSION_MOUTH_PRESS_L_BD = 41,
+    XR_FACE_EXPRESSION_MOUTH_PRESS_R_BD = 42,
+    XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_L_BD = 43,
+    XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_R_BD = 44,
+    XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_L_BD = 45,
+    XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_R_BD = 46,
+    XR_FACE_EXPRESSION_JAW_FORWARD_BD = 47,
+    XR_FACE_EXPRESSION_JAW_L_BD = 48,
+    XR_FACE_EXPRESSION_JAW_R_BD = 49,
+    XR_FACE_EXPRESSION_JAW_OPEN_BD = 50,
+    XR_FACE_EXPRESSION_TONGUE_OUT_BD = 51,
+    XR_FACE_EXPRESSION_MAX_ENUM_BD = 0x7FFFFFFF
+} XrFaceExpressionBD;
+
+typedef enum XrLipExpressionBD {
+    XR_LIP_EXPRESSION_PP_BD = 0,
+    XR_LIP_EXPRESSION_CH_BD = 1,
+    XR_LIP_EXPRESSION_LO_BD = 2,
+    XR_LIP_EXPRESSION_O_BD = 3,
+    XR_LIP_EXPRESSION_I_BD = 4,
+    XR_LIP_EXPRESSION_LU_BD = 5,
+    XR_LIP_EXPRESSION_RR_BD = 6,
+    XR_LIP_EXPRESSION_XX_BD = 7,
+    XR_LIP_EXPRESSION_LAA_BD = 8,
+    XR_LIP_EXPRESSION_LI_BD = 9,
+    XR_LIP_EXPRESSION_FF_BD = 10,
+    XR_LIP_EXPRESSION_U_BD = 11,
+    XR_LIP_EXPRESSION_TH_BD = 12,
+    XR_LIP_EXPRESSION_LKK_BD = 13,
+    XR_LIP_EXPRESSION_SS_BD = 14,
+    XR_LIP_EXPRESSION_LE_BD = 15,
+    XR_LIP_EXPRESSION_DD_BD = 16,
+    XR_LIP_EXPRESSION_E_BD = 17,
+    XR_LIP_EXPRESSION_LNN_BD = 18,
+    XR_LIP_EXPRESSION_SIL_BD = 19,
+    XR_LIP_EXPRESSION_MAX_ENUM_BD = 0x7FFFFFFF
+} XrLipExpressionBD;
+// XrSystemFacialSimulationPropertiesBD extends XrSystemProperties
+typedef struct XrSystemFacialSimulationPropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsFaceTracking;
+} XrSystemFacialSimulationPropertiesBD;
+
+typedef struct XrFaceTrackerCreateInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrFacialSimulationModeBD    mode;
+} XrFaceTrackerCreateInfoBD;
+
+typedef struct XrFacialSimulationDataGetInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      time;
+} XrFacialSimulationDataGetInfoBD;
+
+typedef struct XrFacialSimulationDataBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              faceExpressionWeightCount;
+    float*                faceExpressionWeights;
+    XrBool32              isUpperFaceDataValid;
+    XrBool32              isLowerFaceDataValid;
+    XrTime                time;
+} XrFacialSimulationDataBD;
+
+// XrLipExpressionDataBD extends XrFacialSimulationDataBD
+typedef struct XrLipExpressionDataBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              lipsyncExpressionWeightCount;
+    float*                lipsyncExpressionWeights;
+} XrLipExpressionDataBD;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateFacialSimulationModesBD)(XrSession session, uint32_t modeCapacityInput, uint32_t* modeCountOutput, XrFacialSimulationModeBD* modes);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTrackerBD)(XrSession session, const XrFaceTrackerCreateInfoBD* createInfo, XrFaceTrackerBD* tracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTrackerBD)(XrFaceTrackerBD tracker);
+typedef XrResult (XRAPI_PTR *PFN_xrGetFacialSimulationDataBD)(XrFaceTrackerBD tracker, const XrFacialSimulationDataGetInfoBD*info, XrFacialSimulationDataBD* facialData);
+typedef XrResult (XRAPI_PTR *PFN_xrSetFacialSimulationModeBD)(XrFaceTrackerBD tracker, XrFacialSimulationModeBD mode);
+typedef XrResult (XRAPI_PTR *PFN_xrGetFacialSimulationModeBD)(XrFaceTrackerBD tracker, XrFacialSimulationModeBD*mode);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateFacialSimulationModesBD(
+    XrSession                                   session,
+    uint32_t                                    modeCapacityInput,
+    uint32_t*                                   modeCountOutput,
+    XrFacialSimulationModeBD*                   modes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateFaceTrackerBD(
+    XrSession                                   session,
+    const XrFaceTrackerCreateInfoBD*            createInfo,
+    XrFaceTrackerBD*                            tracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFaceTrackerBD(
+    XrFaceTrackerBD                             tracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetFacialSimulationDataBD(
+    XrFaceTrackerBD                             tracker,
+    const XrFacialSimulationDataGetInfoBD*      info,
+    XrFacialSimulationDataBD*                   facialData);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetFacialSimulationModeBD(
+    XrFaceTrackerBD                             tracker,
+    XrFacialSimulationModeBD                    mode);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetFacialSimulationModeBD(
+    XrFaceTrackerBD                             tracker,
+    XrFacialSimulationModeBD*                   mode);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_BD_spatial_sensing is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_spatial_sensing 1
+XR_DEFINE_ATOM(XrSpatialEntityIdBD)
+XR_DEFINE_HANDLE(XrSenseDataProviderBD)
+XR_DEFINE_HANDLE(XrSenseDataSnapshotBD)
+XR_DEFINE_HANDLE(XrAnchorBD)
+#define XR_BD_spatial_sensing_SPEC_VERSION 3
+#define XR_BD_SPATIAL_SENSING_EXTENSION_NAME "XR_BD_spatial_sensing"
+
+typedef enum XrSpatialEntityComponentTypeBD {
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_LOCATION_BD = 0,
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_SEMANTIC_BD = 1,
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_2D_BD = 2,
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_POLYGON_BD = 3,
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_3D_BD = 4,
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_TRIANGLE_MESH_BD = 5,
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_SPHERE_BD = 6,
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_PLANE_ORIENTATION_BD = 1000396000,
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_LIGHT_ESTIMATION_BD = 1000397000,
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_DYNAMIC_OBJECT_BD = 1000746000,
+    XR_SPATIAL_ENTITY_COMPONENT_TYPE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSpatialEntityComponentTypeBD;
+
+typedef enum XrSemanticLabelBD {
+    XR_SEMANTIC_LABEL_UNKNOWN_BD = 0,
+    XR_SEMANTIC_LABEL_FLOOR_BD = 1,
+    XR_SEMANTIC_LABEL_CEILING_BD = 2,
+    XR_SEMANTIC_LABEL_WALL_BD = 3,
+    XR_SEMANTIC_LABEL_DOOR_BD = 4,
+    XR_SEMANTIC_LABEL_WINDOW_BD = 5,
+    XR_SEMANTIC_LABEL_OPENING_BD = 6,
+    XR_SEMANTIC_LABEL_TABLE_BD = 7,
+    XR_SEMANTIC_LABEL_SOFA_BD = 8,
+    XR_SEMANTIC_LABEL_CHAIR_BD = 9,
+    XR_SEMANTIC_LABEL_HUMAN_BD = 10,
+    XR_SEMANTIC_LABEL_BEAM_BD = 11,
+    XR_SEMANTIC_LABEL_COLUMN_BD = 12,
+    XR_SEMANTIC_LABEL_CURTAIN_BD = 13,
+    XR_SEMANTIC_LABEL_CABINET_BD = 14,
+    XR_SEMANTIC_LABEL_BED_BD = 15,
+    XR_SEMANTIC_LABEL_PLANT_BD = 16,
+    XR_SEMANTIC_LABEL_SCREEN_BD = 17,
+    XR_SEMANTIC_LABEL_VIRTUAL_WALL_BD = 18,
+    XR_SEMANTIC_LABEL_REFRIGERATOR_BD = 19,
+    XR_SEMANTIC_LABEL_WASHING_MACHINE_BD = 20,
+    XR_SEMANTIC_LABEL_AIR_CONDITIONER_BD = 21,
+    XR_SEMANTIC_LABEL_LAMP_BD = 22,
+    XR_SEMANTIC_LABEL_WALL_ART_BD = 23,
+    XR_SEMANTIC_LABEL_STAIRWAY_BD = 24,
+    XR_SEMANTIC_LABEL_KEYBOARD_BD = 25,
+    XR_SEMANTIC_LABEL_MOUSE_BD = 26,
+    XR_SEMANTIC_LABEL_LAPTOP_BD = 27,
+    XR_SEMANTIC_LABEL_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSemanticLabelBD;
+
+typedef enum XrSenseDataProviderTypeBD {
+    XR_SENSE_DATA_PROVIDER_TYPE_ANCHOR_BD = 1000390000,
+    XR_SENSE_DATA_PROVIDER_TYPE_SCENE_BD = 1000392000,
+    XR_SENSE_DATA_PROVIDER_TYPE_MESH_BD = 1000393000,
+    XR_SENSE_DATA_PROVIDER_TYPE_PLANE_BD = 1000396000,
+    XR_SENSE_DATA_PROVIDER_TYPE_LIGHT_ESTIMATION_BD = 1000397000,
+    XR_SENSE_DATA_PROVIDER_TYPE_DYNAMIC_OBJECT_BD = 1000746000,
+    XR_SENSE_DATA_PROVIDER_TYPE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSenseDataProviderTypeBD;
+
+typedef enum XrSenseDataProviderStateBD {
+    XR_SENSE_DATA_PROVIDER_STATE_INITIALIZED_BD = 0,
+    XR_SENSE_DATA_PROVIDER_STATE_RUNNING_BD = 1,
+    XR_SENSE_DATA_PROVIDER_STATE_STOPPED_BD = 2,
+    XR_SENSE_DATA_PROVIDER_STATE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSenseDataProviderStateBD;
+// XrSystemSpatialSensingPropertiesBD extends XrSystemProperties
+typedef struct XrSystemSpatialSensingPropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsSpatialSensing;
+} XrSystemSpatialSensingPropertiesBD;
+
+typedef struct XrSpatialEntityComponentGetInfoBD {
+    XrStructureType                   type;
+    const void* XR_MAY_ALIAS          next;
+    XrSpatialEntityIdBD               entityId;
+    XrSpatialEntityComponentTypeBD    componentType;
+} XrSpatialEntityComponentGetInfoBD;
+
+typedef struct XrSpatialEntityComponentDataBaseHeaderBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+} XrSpatialEntityComponentDataBaseHeaderBD;
+
+// XrSpatialEntityLocationGetInfoBD extends XrSpatialEntityComponentGetInfoBD
+typedef struct XrSpatialEntityLocationGetInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+} XrSpatialEntityLocationGetInfoBD;
+
+// XrSpatialEntityComponentDataLocationBD extends XrSpatialEntityComponentDataBaseHeaderBD
+typedef struct XrSpatialEntityComponentDataLocationBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrSpaceLocation       location;
+} XrSpatialEntityComponentDataLocationBD;
+
+// XrSpatialEntityComponentDataSemanticBD extends XrSpatialEntityComponentDataBaseHeaderBD
+typedef struct XrSpatialEntityComponentDataSemanticBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              labelCapacityInput;
+    uint32_t              labelCountOutput;
+    XrSemanticLabelBD*    labels;
+} XrSpatialEntityComponentDataSemanticBD;
+
+// XrSpatialEntityComponentDataBoundingBox2DBD extends XrSpatialEntityComponentDataBaseHeaderBD
+typedef struct XrSpatialEntityComponentDataBoundingBox2DBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrRect2Df             boundingBox2D;
+} XrSpatialEntityComponentDataBoundingBox2DBD;
+
+// XrSpatialEntityComponentDataPolygonBD extends XrSpatialEntityComponentDataBaseHeaderBD
+typedef struct XrSpatialEntityComponentDataPolygonBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              vertexCapacityInput;
+    uint32_t              vertexCountOutput;
+    XrVector2f*           vertices;
+} XrSpatialEntityComponentDataPolygonBD;
+
+// XrSpatialEntityComponentDataBoundingBox3DBD extends XrSpatialEntityComponentDataBaseHeaderBD
+typedef struct XrSpatialEntityComponentDataBoundingBox3DBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBoxf                boundingBox3D;
+} XrSpatialEntityComponentDataBoundingBox3DBD;
+
+// XrSpatialEntityComponentDataTriangleMeshBD extends XrSpatialEntityComponentDataBaseHeaderBD
+typedef struct XrSpatialEntityComponentDataTriangleMeshBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              vertexCapacityInput;
+    uint32_t              vertexCountOutput;
+    XrVector3f*           vertices;
+    uint32_t              indexCapacityInput;
+    uint32_t              indexCountOutput;
+    uint16_t*             indices;
+} XrSpatialEntityComponentDataTriangleMeshBD;
+
+// XrSpatialEntityComponentDataSphereBD extends XrSpatialEntityComponentDataBaseHeaderBD
+typedef struct XrSpatialEntityComponentDataSphereBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrSpheref             sphere;
+} XrSpatialEntityComponentDataSphereBD;
+
+typedef struct XrSenseDataProviderCreateInfoBD {
+    XrStructureType              type;
+    const void* XR_MAY_ALIAS     next;
+    XrSenseDataProviderTypeBD    providerType;
+} XrSenseDataProviderCreateInfoBD;
+
+typedef struct XrSenseDataProviderStartInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSenseDataProviderStartInfoBD;
+
+typedef struct XrEventDataSenseDataProviderStateChangedBD {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrSenseDataProviderBD         provider;
+    XrSenseDataProviderStateBD    newState;
+} XrEventDataSenseDataProviderStateChangedBD;
+
+typedef struct XrEventDataSenseDataUpdatedBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSenseDataProviderBD       provider;
+} XrEventDataSenseDataUpdatedBD;
+
+typedef struct XrSenseDataQueryInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSenseDataQueryInfoBD;
+
+typedef struct XrSenseDataQueryCompletionBD {
+    XrStructureType          type;
+    void* XR_MAY_ALIAS       next;
+    XrResult                 futureResult;
+    XrSenseDataSnapshotBD    snapshot;
+} XrSenseDataQueryCompletionBD;
+
+typedef struct XrQueriedSenseDataGetInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrQueriedSenseDataGetInfoBD;
+
+typedef struct XrSpatialEntityStateBD {
+    XrStructureType        type;
+    void* XR_MAY_ALIAS     next;
+    XrSpatialEntityIdBD    entityId;
+    XrTime                 lastUpdateTime;
+    XrUuidEXT              uuid;
+} XrSpatialEntityStateBD;
+
+typedef struct XrQueriedSenseDataBD {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    uint32_t                   stateCapacityInput;
+    uint32_t                   stateCountOutput;
+    XrSpatialEntityStateBD*    states;
+} XrQueriedSenseDataBD;
+
+// XrSenseDataFilterUuidBD extends XrSenseDataQueryInfoBD
+typedef struct XrSenseDataFilterUuidBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    uuidCount;
+    const XrUuidEXT*            uuids;
+} XrSenseDataFilterUuidBD;
+
+// XrSenseDataFilterSemanticBD extends XrSenseDataQueryInfoBD
+typedef struct XrSenseDataFilterSemanticBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    labelCount;
+    const XrSemanticLabelBD*    labels;
+} XrSenseDataFilterSemanticBD;
+
+typedef struct XrSpatialEntityAnchorCreateInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSenseDataSnapshotBD       snapshot;
+    XrSpatialEntityIdBD         entityId;
+} XrSpatialEntityAnchorCreateInfoBD;
+
+typedef struct XrAnchorSpaceCreateInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAnchorBD                  anchor;
+    XrPosef                     poseInAnchorSpace;
+} XrAnchorSpaceCreateInfoBD;
+
+typedef struct XrFutureCompletionEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrResult              futureResult;
+} XrFutureCompletionEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialEntityComponentTypesBD)(XrSenseDataSnapshotBD snapshot, XrSpatialEntityIdBD entityId, uint32_t componentTypeCapacityInput, uint32_t* componentTypeCountOutput, XrSpatialEntityComponentTypeBD* componentTypes);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialEntityUuidBD)(XrSenseDataSnapshotBD snapshot, XrSpatialEntityIdBD entityId, XrUuidEXT* uuid);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialEntityComponentDataBD)(XrSenseDataSnapshotBD snapshot, const XrSpatialEntityComponentGetInfoBD* getInfo, XrSpatialEntityComponentDataBaseHeaderBD* componentData);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSenseDataProviderBD)(XrSession session, const XrSenseDataProviderCreateInfoBD* createInfo, XrSenseDataProviderBD* provider);
+typedef XrResult (XRAPI_PTR *PFN_xrStartSenseDataProviderAsyncBD)(XrSenseDataProviderBD provider, const XrSenseDataProviderStartInfoBD* startInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrStartSenseDataProviderCompleteBD)(XrSession session, XrFutureEXT future, XrFutureCompletionEXT* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSenseDataProviderStateBD)(XrSenseDataProviderBD provider, XrSenseDataProviderStateBD* state);
+typedef XrResult (XRAPI_PTR *PFN_xrQuerySenseDataAsyncBD)(XrSenseDataProviderBD provider, const XrSenseDataQueryInfoBD* queryInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrQuerySenseDataCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrSenseDataQueryCompletionBD* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySenseDataSnapshotBD)(XrSenseDataSnapshotBD snapshot);
+typedef XrResult (XRAPI_PTR *PFN_xrGetQueriedSenseDataBD)(XrSenseDataSnapshotBD snapshot, XrQueriedSenseDataGetInfoBD* getInfo, XrQueriedSenseDataBD* queriedSenseData);
+typedef XrResult (XRAPI_PTR *PFN_xrStopSenseDataProviderBD)(XrSenseDataProviderBD provider);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySenseDataProviderBD)(XrSenseDataProviderBD provider);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialEntityAnchorBD)(XrSenseDataProviderBD provider, const XrSpatialEntityAnchorCreateInfoBD* createInfo, XrAnchorBD* anchor);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyAnchorBD)(XrAnchorBD anchor);
+typedef XrResult (XRAPI_PTR *PFN_xrGetAnchorUuidBD)(XrAnchorBD anchor, XrUuidEXT* uuid);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateAnchorSpaceBD)(XrSession session, const XrAnchorSpaceCreateInfoBD* createInfo, XrSpace* space);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialEntityComponentTypesBD(
+    XrSenseDataSnapshotBD                       snapshot,
+    XrSpatialEntityIdBD                         entityId,
+    uint32_t                                    componentTypeCapacityInput,
+    uint32_t*                                   componentTypeCountOutput,
+    XrSpatialEntityComponentTypeBD*             componentTypes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialEntityUuidBD(
+    XrSenseDataSnapshotBD                       snapshot,
+    XrSpatialEntityIdBD                         entityId,
+    XrUuidEXT*                                  uuid);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialEntityComponentDataBD(
+    XrSenseDataSnapshotBD                       snapshot,
+    const XrSpatialEntityComponentGetInfoBD*    getInfo,
+    XrSpatialEntityComponentDataBaseHeaderBD*   componentData);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSenseDataProviderBD(
+    XrSession                                   session,
+    const XrSenseDataProviderCreateInfoBD*      createInfo,
+    XrSenseDataProviderBD*                      provider);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStartSenseDataProviderAsyncBD(
+    XrSenseDataProviderBD                       provider,
+    const XrSenseDataProviderStartInfoBD*       startInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStartSenseDataProviderCompleteBD(
+    XrSession                                   session,
+    XrFutureEXT                                 future,
+    XrFutureCompletionEXT*                      completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSenseDataProviderStateBD(
+    XrSenseDataProviderBD                       provider,
+    XrSenseDataProviderStateBD*                 state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrQuerySenseDataAsyncBD(
+    XrSenseDataProviderBD                       provider,
+    const XrSenseDataQueryInfoBD*               queryInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrQuerySenseDataCompleteBD(
+    XrSenseDataProviderBD                       provider,
+    XrFutureEXT                                 future,
+    XrSenseDataQueryCompletionBD*               completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySenseDataSnapshotBD(
+    XrSenseDataSnapshotBD                       snapshot);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetQueriedSenseDataBD(
+    XrSenseDataSnapshotBD                       snapshot,
+    XrQueriedSenseDataGetInfoBD*                getInfo,
+    XrQueriedSenseDataBD*                       queriedSenseData);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStopSenseDataProviderBD(
+    XrSenseDataProviderBD                       provider);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySenseDataProviderBD(
+    XrSenseDataProviderBD                       provider);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialEntityAnchorBD(
+    XrSenseDataProviderBD                       provider,
+    const XrSpatialEntityAnchorCreateInfoBD*    createInfo,
+    XrAnchorBD*                                 anchor);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyAnchorBD(
+    XrAnchorBD                                  anchor);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetAnchorUuidBD(
+    XrAnchorBD                                  anchor,
+    XrUuidEXT*                                  uuid);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateAnchorSpaceBD(
+    XrSession                                   session,
+    const XrAnchorSpaceCreateInfoBD*            createInfo,
+    XrSpace*                                    space);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_BD_spatial_anchor is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_spatial_anchor 1
+#define XR_BD_spatial_anchor_SPEC_VERSION 2
+#define XR_BD_SPATIAL_ANCHOR_EXTENSION_NAME "XR_BD_spatial_anchor"
+
+typedef enum XrPersistenceLocationBD {
+    XR_PERSISTENCE_LOCATION_LOCAL_BD = 0,
+    XR_PERSISTENCE_LOCATION_MAX_ENUM_BD = 0x7FFFFFFF
+} XrPersistenceLocationBD;
+// XrSystemSpatialAnchorPropertiesBD extends XrSystemProperties
+typedef struct XrSystemSpatialAnchorPropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsSpatialAnchor;
+} XrSystemSpatialAnchorPropertiesBD;
+
+typedef struct XrSpatialAnchorCreateInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrPosef                     pose;
+    XrTime                      time;
+} XrSpatialAnchorCreateInfoBD;
+
+typedef struct XrSpatialAnchorCreateCompletionBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrResult              futureResult;
+    XrUuidEXT             uuid;
+    XrAnchorBD            anchor;
+} XrSpatialAnchorCreateCompletionBD;
+
+typedef struct XrSpatialAnchorPersistInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrPersistenceLocationBD     location;
+    XrAnchorBD                  anchor;
+} XrSpatialAnchorPersistInfoBD;
+
+typedef struct XrSpatialAnchorUnpersistInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrPersistenceLocationBD     location;
+    XrAnchorBD                  anchor;
+} XrSpatialAnchorUnpersistInfoBD;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorAsyncBD)(XrSenseDataProviderBD provider, const XrSpatialAnchorCreateInfoBD* info, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrSpatialAnchorCreateCompletionBD* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorAsyncBD)(XrSenseDataProviderBD provider, const XrSpatialAnchorPersistInfoBD* info, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorAsyncBD)(XrSenseDataProviderBD provider, const XrSpatialAnchorUnpersistInfoBD* info, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT* completion);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorAsyncBD(
+    XrSenseDataProviderBD                       provider,
+    const XrSpatialAnchorCreateInfoBD*          info,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorCompleteBD(
+    XrSenseDataProviderBD                       provider,
+    XrFutureEXT                                 future,
+    XrSpatialAnchorCreateCompletionBD*          completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPersistSpatialAnchorAsyncBD(
+    XrSenseDataProviderBD                       provider,
+    const XrSpatialAnchorPersistInfoBD*         info,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPersistSpatialAnchorCompleteBD(
+    XrSenseDataProviderBD                       provider,
+    XrFutureEXT                                 future,
+    XrFutureCompletionEXT*                      completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistSpatialAnchorAsyncBD(
+    XrSenseDataProviderBD                       provider,
+    const XrSpatialAnchorUnpersistInfoBD*       info,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistSpatialAnchorCompleteBD(
+    XrSenseDataProviderBD                       provider,
+    XrFutureEXT                                 future,
+    XrFutureCompletionEXT*                      completion);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_BD_spatial_anchor_sharing is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_spatial_anchor_sharing 1
+#define XR_BD_spatial_anchor_sharing_SPEC_VERSION 2
+#define XR_BD_SPATIAL_ANCHOR_SHARING_EXTENSION_NAME "XR_BD_spatial_anchor_sharing"
+// XrSystemSpatialAnchorSharingPropertiesBD extends XrSystemProperties
+typedef struct XrSystemSpatialAnchorSharingPropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsSpatialAnchorSharing;
+} XrSystemSpatialAnchorSharingPropertiesBD;
+
+typedef struct XrSpatialAnchorShareInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAnchorBD                  anchor;
+} XrSpatialAnchorShareInfoBD;
+
+typedef struct XrSharedSpatialAnchorDownloadInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrUuidEXT                   uuid;
+} XrSharedSpatialAnchorDownloadInfoBD;
+
+typedef XrResult (XRAPI_PTR *PFN_xrShareSpatialAnchorAsyncBD)(XrSenseDataProviderBD provider, const XrSpatialAnchorShareInfoBD* info, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrShareSpatialAnchorCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrDownloadSharedSpatialAnchorAsyncBD)(XrSenseDataProviderBD provider, const XrSharedSpatialAnchorDownloadInfoBD* info, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrDownloadSharedSpatialAnchorCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT* completion);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrShareSpatialAnchorAsyncBD(
+    XrSenseDataProviderBD                       provider,
+    const XrSpatialAnchorShareInfoBD*           info,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrShareSpatialAnchorCompleteBD(
+    XrSenseDataProviderBD                       provider,
+    XrFutureEXT                                 future,
+    XrFutureCompletionEXT*                      completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDownloadSharedSpatialAnchorAsyncBD(
+    XrSenseDataProviderBD                       provider,
+    const XrSharedSpatialAnchorDownloadInfoBD*  info,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDownloadSharedSpatialAnchorCompleteBD(
+    XrSenseDataProviderBD                       provider,
+    XrFutureEXT                                 future,
+    XrFutureCompletionEXT*                      completion);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_BD_spatial_scene is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_spatial_scene 1
+#define XR_BD_spatial_scene_SPEC_VERSION  1
+#define XR_BD_SPATIAL_SCENE_EXTENSION_NAME "XR_BD_spatial_scene"
+// XrSystemSpatialScenePropertiesBD extends XrSystemProperties
+typedef struct XrSystemSpatialScenePropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsSpatialScene;
+} XrSystemSpatialScenePropertiesBD;
+
+typedef struct XrSceneCaptureInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSceneCaptureInfoBD;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCaptureSceneAsyncBD)(XrSenseDataProviderBD provider, const XrSceneCaptureInfoBD* info, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCaptureSceneCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT* completion);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCaptureSceneAsyncBD(
+    XrSenseDataProviderBD                       provider,
+    const XrSceneCaptureInfoBD*                 info,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCaptureSceneCompleteBD(
+    XrSenseDataProviderBD                       provider,
+    XrFutureEXT                                 future,
+    XrFutureCompletionEXT*                      completion);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_BD_spatial_mesh is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_spatial_mesh 1
+#define XR_BD_spatial_mesh_SPEC_VERSION   1
+#define XR_BD_SPATIAL_MESH_EXTENSION_NAME "XR_BD_spatial_mesh"
+
+typedef enum XrSpatialMeshLodBD {
+    XR_SPATIAL_MESH_LOD_COARSE_BD = 0,
+    XR_SPATIAL_MESH_LOD_MEDIUM_BD = 1,
+    XR_SPATIAL_MESH_LOD_FINE_BD = 2,
+    XR_SPATIAL_MESH_LOD_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSpatialMeshLodBD;
+typedef XrFlags64 XrSpatialMeshConfigFlagsBD;
+
+// Flag bits for XrSpatialMeshConfigFlagsBD
+static const XrSpatialMeshConfigFlagsBD XR_SPATIAL_MESH_CONFIG_SEMANTIC_BIT_BD = 0x00000001;
+static const XrSpatialMeshConfigFlagsBD XR_SPATIAL_MESH_CONFIG_ALIGN_SEMANTIC_WITH_VERTEX_BIT_BD = 0x00000002;
+
+// XrSystemSpatialMeshPropertiesBD extends XrSystemProperties
+typedef struct XrSystemSpatialMeshPropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsSpatialMesh;
+} XrSystemSpatialMeshPropertiesBD;
+
+// XrSenseDataProviderCreateInfoSpatialMeshBD extends XrSenseDataProviderCreateInfoBD
+typedef struct XrSenseDataProviderCreateInfoSpatialMeshBD {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrSpatialMeshConfigFlagsBD    configFlags;
+    XrSpatialMeshLodBD            lod;
+} XrSenseDataProviderCreateInfoSpatialMeshBD;
+
+
+
+// XR_BD_future_progress is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_future_progress 1
+#define XR_BD_future_progress_SPEC_VERSION 1
+#define XR_BD_FUTURE_PROGRESS_EXTENSION_NAME "XR_BD_future_progress"
+// XrFuturePollResultProgressBD extends XrFuturePollResultEXT
+typedef struct XrFuturePollResultProgressBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              isSupported;
+    uint32_t              progressPercentage;
+} XrFuturePollResultProgressBD;
+
+
+
+// XR_BD_body_tracking_auxiliary_metrics is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_body_tracking_auxiliary_metrics 1
+#define XR_BD_body_tracking_auxiliary_metrics_SPEC_VERSION 1
+#define XR_BD_BODY_TRACKING_AUXILIARY_METRICS_EXTENSION_NAME "XR_BD_body_tracking_auxiliary_metrics"
+
+typedef enum XrBodyTrackingPostureBD {
+    XR_BODY_TRACKING_POSTURE_STOMP_BD = 1,
+    XR_BODY_TRACKING_POSTURE_STATIC_BD = 2,
+    XR_BODY_TRACKING_POSTURE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrBodyTrackingPostureBD;
+
+typedef enum XrBodyTrackingStatusBD {
+    XR_BODY_TRACKING_STATUS_INVALID_BD = 0,
+    XR_BODY_TRACKING_STATUS_VALID_BD = 1,
+    XR_BODY_TRACKING_STATUS_LIMITED_BD = 2,
+    XR_BODY_TRACKING_STATUS_MAX_ENUM_BD = 0x7FFFFFFF
+} XrBodyTrackingStatusBD;
+
+typedef enum XrBodyTrackingMessageBD {
+    XR_BODY_TRACKING_MESSAGE_NO_ERROR_BD = 0,
+    XR_BODY_TRACKING_MESSAGE_TRACKER_NOT_CALIBRATED_BD = 1,
+    XR_BODY_TRACKING_MESSAGE_TRACKER_NUM_NOT_ENOUGH_BD = 2,
+    XR_BODY_TRACKING_MESSAGE_TRACKER_STATE_NOT_SATISFIED_BD = 3,
+    XR_BODY_TRACKING_MESSAGE_TRACKER_PERSISTENT_INVISIBILITY_BD = 4,
+    XR_BODY_TRACKING_MESSAGE_TRACKER_DATA_ERROR_BD = 5,
+    XR_BODY_TRACKING_MESSAGE_USER_CHANGE_BD = 6,
+    XR_BODY_TRACKING_MESSAGE_TRACKING_POSE_ERROR_BD = 7,
+    XR_BODY_TRACKING_MESSAGE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrBodyTrackingMessageBD;
+typedef XrFlags64 XrSpaceAccelerationFlagsBD;
+
+// Flag bits for XrSpaceAccelerationFlagsBD
+static const XrSpaceAccelerationFlagsBD XR_SPACE_ACCELERATION_LINEAR_VALID_BIT_BD = 0x00000001;
+static const XrSpaceAccelerationFlagsBD XR_SPACE_ACCELERATION_ANGULAR_VALID_BIT_BD = 0x00000002;
+
+// XrBodyTrackingPostureDataBD extends XrBodyJointLocationsBD
+typedef struct XrBodyTrackingPostureDataBD {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    uint32_t                    postureCount;
+    XrBodyTrackingPostureBD*    postureData;
+} XrBodyTrackingPostureDataBD;
+
+typedef struct XrBodyJointVelocityBD {
+    XrSpaceVelocityFlags    velocityFlags;
+    XrVector3f              linearVelocity;
+    XrVector3f              angularVelocity;
+} XrBodyJointVelocityBD;
+
+// XrBodyJointVelocitiesBD extends XrBodyJointLocationsBD
+typedef struct XrBodyJointVelocitiesBD {
+    XrStructureType           type;
+    void* XR_MAY_ALIAS        next;
+    uint32_t                  velocityCount;
+    XrBodyJointVelocityBD*    velocities;
+} XrBodyJointVelocitiesBD;
+
+typedef struct XrBodyJointAccelerationBD {
+    XrSpaceAccelerationFlagsBD    accelerationFlags;
+    XrVector3f                    linearAcceleration;
+    XrVector3f                    angularAcceleration;
+} XrBodyJointAccelerationBD;
+
+// XrBodyJointAccelerationsBD extends XrBodyJointLocationsBD
+typedef struct XrBodyJointAccelerationsBD {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    uint32_t                      accelerationCount;
+    XrBodyJointAccelerationBD*    accelerations;
+} XrBodyJointAccelerationsBD;
+
+typedef struct XrBodyTrackingStateBD {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    XrBodyTrackingStatusBD     status;
+    XrBodyTrackingMessageBD    message;
+} XrBodyTrackingStateBD;
+
+typedef XrResult (XRAPI_PTR *PFN_xrStartBodyTrackingCalibrationAppBD)(XrSession session);
+typedef XrResult (XRAPI_PTR *PFN_xrGetBodyTrackingStateBD)(XrSession session, XrBodyTrackingStateBD* state);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrStartBodyTrackingCalibrationAppBD(
+    XrSession                                   session);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetBodyTrackingStateBD(
+    XrSession                                   session,
+    XrBodyTrackingStateBD*                      state);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_BD_spatial_plane is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_spatial_plane 1
+#define XR_BD_spatial_plane_SPEC_VERSION  1
+#define XR_BD_SPATIAL_PLANE_EXTENSION_NAME "XR_BD_spatial_plane"
+
+typedef enum XrPlaneOrientationBD {
+    XR_PLANE_ORIENTATION_HORIZONTAL_UPWARD_BD = 0,
+    XR_PLANE_ORIENTATION_HORIZONTAL_DOWNWARD_BD = 1,
+    XR_PLANE_ORIENTATION_VERTICAL_BD = 2,
+    XR_PLANE_ORIENTATION_ARBITRARY_BD = 3,
+    XR_PLANE_ORIENTATION_MAX_ENUM_BD = 0x7FFFFFFF
+} XrPlaneOrientationBD;
+// XrSystemSpatialPlanePropertiesBD extends XrSystemProperties
+typedef struct XrSystemSpatialPlanePropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsSpatialPlane;
+} XrSystemSpatialPlanePropertiesBD;
+
+// XrSpatialEntityComponentDataPlaneOrientationBD extends XrSpatialEntityComponentDataBaseHeaderBD
+typedef struct XrSpatialEntityComponentDataPlaneOrientationBD {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    XrPlaneOrientationBD    orientation;
+} XrSpatialEntityComponentDataPlaneOrientationBD;
+
+// XrSenseDataFilterPlaneOrientationBD extends XrSenseDataQueryInfoBD
+typedef struct XrSenseDataFilterPlaneOrientationBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    orientationCount;
+    XrPlaneOrientationBD*       orientations;
+} XrSenseDataFilterPlaneOrientationBD;
+
+
+
+// XR_BD_spatial_light_estimation is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_spatial_light_estimation 1
+#define XR_BD_spatial_light_estimation_SPEC_VERSION 1
+#define XR_BD_SPATIAL_LIGHT_ESTIMATION_EXTENSION_NAME "XR_BD_spatial_light_estimation"
+
+typedef enum XrEnvironmentTexturePixelFormatBD {
+    XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_RGB_16FLOAT_BD = 0,
+    XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_RGBA_16FLOAT_BD = 1,
+    XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_MAX_ENUM_BD = 0x7FFFFFFF
+} XrEnvironmentTexturePixelFormatBD;
+
+typedef enum XrEnvironmentTextureResolutionBD {
+    XR_ENVIRONMENT_TEXTURE_RESOLUTION_8_8_BD = 0,
+    XR_ENVIRONMENT_TEXTURE_RESOLUTION_16_16_BD = 1,
+    XR_ENVIRONMENT_TEXTURE_RESOLUTION_32_32_BD = 2,
+    XR_ENVIRONMENT_TEXTURE_RESOLUTION_64_64_BD = 3,
+    XR_ENVIRONMENT_TEXTURE_RESOLUTION_128_128_BD = 4,
+    XR_ENVIRONMENT_TEXTURE_RESOLUTION_MAX_ENUM_BD = 0x7FFFFFFF
+} XrEnvironmentTextureResolutionBD;
+
+typedef enum XrEnvironmentTextureTransferTypeBD {
+    XR_ENVIRONMENT_TEXTURE_TRANSFER_TYPE_RAW_BD = 0,
+    XR_ENVIRONMENT_TEXTURE_TRANSFER_TYPE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrEnvironmentTextureTransferTypeBD;
+
+typedef enum XrSphericalHarmonicsKindBD {
+    XR_SPHERICAL_HARMONICS_KIND_TOTAL_BD = 0,
+    XR_SPHERICAL_HARMONICS_KIND_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSphericalHarmonicsKindBD;
+typedef XrFlags64 XrLightEstimationCreateFlagsBD;
+
+// Flag bits for XrLightEstimationCreateFlagsBD
+static const XrLightEstimationCreateFlagsBD XR_LIGHT_ESTIMATION_CREATE_SPHERICAL_HARMONICS_BIT_BD = 0x00000001;
+static const XrLightEstimationCreateFlagsBD XR_LIGHT_ESTIMATION_CREATE_ENVIRONMENT_TEXTURE_BIT_BD = 0x00000002;
+
+// XrSystemLightEstimationPropertiesBD extends XrSystemProperties
+typedef struct XrSystemLightEstimationPropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsLightEstimation;
+    XrBool32              supportsEnvironmentTexture;
+    XrBool32              supportsSphericalHarmonics;
+} XrSystemLightEstimationPropertiesBD;
+
+// XrSenseDataProviderCreateInfoLightEstimationBD extends XrSenseDataProviderCreateInfoBD
+typedef struct XrSenseDataProviderCreateInfoLightEstimationBD {
+    XrStructureType                   type;
+    const void* XR_MAY_ALIAS          next;
+    XrLightEstimationCreateFlagsBD    createFlags;
+} XrSenseDataProviderCreateInfoLightEstimationBD;
+
+// XrEnvironmentTextureCreateConfigInfoBD extends XrSenseDataProviderCreateInfoBD
+typedef struct XrEnvironmentTextureCreateConfigInfoBD {
+    XrStructureType                       type;
+    const void* XR_MAY_ALIAS              next;
+    XrEnvironmentTexturePixelFormatBD     pixelFormat;
+    XrEnvironmentTextureResolutionBD      resolution;
+    XrEnvironmentTextureTransferTypeBD    transferType;
+} XrEnvironmentTextureCreateConfigInfoBD;
+
+// XrLightEstimationDataEnvironmentTextureRawBD extends XrSpatialEntityComponentDataLightEstimationBD
+typedef struct XrLightEstimationDataEnvironmentTextureRawBD {
+    XrStructureType                      type;
+    const void* XR_MAY_ALIAS             next;
+    XrEnvironmentTexturePixelFormatBD    pixelFormat;
+    uint32_t                             cubemapFaceBufferSize;
+    uint8_t*                             rightCubemapFaceBuffer;
+    uint8_t*                             leftCubemapFaceBuffer;
+    uint8_t*                             topCubemapFaceBuffer;
+    uint8_t*                             bottomCubemapFaceBuffer;
+    uint8_t*                             frontCubemapFaceBuffer;
+    uint8_t*                             backCubemapFaceBuffer;
+} XrLightEstimationDataEnvironmentTextureRawBD;
+
+// XrLightEstimationDataSphericalHarmonicsBD extends XrSpatialEntityComponentDataLightEstimationBD
+typedef struct XrLightEstimationDataSphericalHarmonicsBD {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrSphericalHarmonicsKindBD    kind;
+    uint32_t                      coefficientCapacityInput;
+    uint32_t                      coefficientCountOutput;
+     float*                       coefficients;
+} XrLightEstimationDataSphericalHarmonicsBD;
+
+// XrSpatialEntityComponentDataLightEstimationBD extends XrSpatialEntityComponentDataBaseHeaderBD
+typedef struct XrSpatialEntityComponentDataLightEstimationBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              isValid;
+} XrSpatialEntityComponentDataLightEstimationBD;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentTextureResolutionsBD)(XrSession session, uint32_t resolutionCapacityInput, uint32_t* resolutionCountOutput, XrEnvironmentTextureResolutionBD* resolutions);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentTexturePixelFormatsBD)(XrSession session, uint32_t pixelFormatCapacityInput, uint32_t* pixelFormatCountOutput, XrEnvironmentTexturePixelFormatBD* pixelFormats);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentTextureTransferTypesBD)(XrSession session, uint32_t transferTypeCapacityInput, uint32_t* transferTypeCountOutput, XrEnvironmentTextureTransferTypeBD* transferTypes);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentTextureResolutionsBD(
+    XrSession                                   session,
+    uint32_t                                    resolutionCapacityInput,
+    uint32_t*                                   resolutionCountOutput,
+    XrEnvironmentTextureResolutionBD*           resolutions);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentTexturePixelFormatsBD(
+    XrSession                                   session,
+    uint32_t                                    pixelFormatCapacityInput,
+    uint32_t*                                   pixelFormatCountOutput,
+    XrEnvironmentTexturePixelFormatBD*          pixelFormats);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentTextureTransferTypesBD(
+    XrSession                                   session,
+    uint32_t                                    transferTypeCapacityInput,
+    uint32_t*                                   transferTypeCountOutput,
+    XrEnvironmentTextureTransferTypeBD*         transferTypes);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_BD_ultra_controller_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_ultra_controller_interaction 1
+#define XR_BD_ultra_controller_interaction_SPEC_VERSION 1
+#define XR_BD_ULTRA_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_BD_ultra_controller_interaction"
+
+
+// XR_BD_spatial_audio_rendering is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_spatial_audio_rendering 1
+XR_DEFINE_HANDLE(XrSpatialAudioRendererBD)
+XR_DEFINE_HANDLE(XrSoundFieldBD)
+XR_DEFINE_HANDLE(XrSoundObjectBD)
+XR_DEFINE_HANDLE(XrSoundObstacleBD)
+XR_DEFINE_HANDLE(XrSoundObstacleMaterialBD)
+#define XR_BD_spatial_audio_rendering_SPEC_VERSION 1
+#define XR_BD_SPATIAL_AUDIO_RENDERING_EXTENSION_NAME "XR_BD_spatial_audio_rendering"
+
+typedef enum XrAudioSampleRateBD {
+    XR_AUDIO_SAMPLE_RATE_192000_HZ_BD = 1,
+    XR_AUDIO_SAMPLE_RATE_96000_HZ_BD = 2,
+    XR_AUDIO_SAMPLE_RATE_48000_HZ_BD = 3,
+    XR_AUDIO_SAMPLE_RATE_44100_HZ_BD = 4,
+    XR_AUDIO_SAMPLE_RATE_32000_HZ_BD = 5,
+    XR_AUDIO_SAMPLE_RATE_24000_HZ_BD = 6,
+    XR_AUDIO_SAMPLE_RATE_22050_HZ_BD = 7,
+    XR_AUDIO_SAMPLE_RATE_16000_HZ_BD = 8,
+    XR_AUDIO_SAMPLE_RATE_12000_HZ_BD = 9,
+    XR_AUDIO_SAMPLE_RATE_11025_HZ_BD = 10,
+    XR_AUDIO_SAMPLE_RATE_8000_HZ_BD = 11,
+    XR_AUDIO_SAMPLE_RATE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrAudioSampleRateBD;
+
+typedef enum XrAudioBufferChannelLayoutBD {
+    XR_AUDIO_BUFFER_CHANNEL_LAYOUT_INTERLEAVED_BD = 0,
+    XR_AUDIO_BUFFER_CHANNEL_LAYOUT_PLANAR_BD = 1,
+    XR_AUDIO_BUFFER_CHANNEL_LAYOUT_MAX_ENUM_BD = 0x7FFFFFFF
+} XrAudioBufferChannelLayoutBD;
+
+typedef enum XrSoundObjectDistanceAttenuationTypeBD {
+    XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_NONE_BD = 0,
+    XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_INVERSE_SQUARE_BD = 1,
+    XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_ROLLOFF_BD = 2,
+    XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_CUSTOMIZED_BD = 100,
+    XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSoundObjectDistanceAttenuationTypeBD;
+
+typedef enum XrSoundFieldChannelMaskSurroundBD {
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_LEFT_BD = 1,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_RIGHT_BD = 2,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_CENTER_BD = 4,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD = 8,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_LEFT_BD = 16,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_RIGHT_BD = 32,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_LEFT_BD = 64,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_RIGHT_BD = 128,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD = 256,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD = 512,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_LEFT_BD = 1024,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_RIGHT_BD = 2048,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_CENTER_BD = 4096,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_LEFT_BD = 8192,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_RIGHT_BD = 16384,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD = 3,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_2_1_BD = 11,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD = 7,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_4_0_BD = 4099,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_BACK_SURROUND_BD = 48,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_QUAD_BD = 51,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_1_BD = 15,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_BD = 55,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD = 192,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_SIDE_BD = 199,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD = 63,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_SIDE_BD = 207,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_0_BD = 247,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_BD = 255,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_2_BD = 831,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_4_BD = 3903,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_2_BD = 24831,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_4_BD = 4095,
+    XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSoundFieldChannelMaskSurroundBD;
+
+typedef enum XrSoundFieldChannelMaskAmbixBD {
+    XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_1ST_ORDER_BD = 1,
+    XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_2ND_ORDER_BD = 2,
+    XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_3RD_ORDER_BD = 3,
+    XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_4TH_ORDER_BD = 4,
+    XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_5TH_ORDER_BD = 5,
+    XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_6TH_ORDER_BD = 6,
+    XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_7TH_ORDER_BD = 7,
+    XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSoundFieldChannelMaskAmbixBD;
+
+typedef enum XrSoundFieldChannelMaskFumaBD {
+    XR_SOUND_FIELD_CHANNEL_MASK_FUMA_1ST_ORDER_BD = 1,
+    XR_SOUND_FIELD_CHANNEL_MASK_FUMA_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSoundFieldChannelMaskFumaBD;
+
+typedef enum XrSoundObstacleMaterialTypeBD {
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_ACOUSTIC_TILE_BD = 0,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_BD = 1,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_PAINTED_BD = 2,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_BD = 3,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_BD = 4,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_PADDED_BD = 5,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_CERAMIC_TILE_BD = 6,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BD = 7,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_ROUGH_BD = 8,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_BD = 9,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_PAINTED_BD = 10,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_CURTAIN_BD = 11,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_FOLIAGE_BD = 12,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_BD = 13,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_HEAVY_BD = 14,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRASS_BD = 15,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRAVEL_BD = 16,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_GYPSUM_BOARD_BD = 17,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_BRICK_BD = 18,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_CONCRETE_BLOCK_BD = 19,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOIL_BD = 20,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOUND_PROOF_BD = 21,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_SNOW_BD = 22,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_STEEL_BD = 23,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_WATER_BD = 24,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THIN_BD = 25,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THICK_BD = 26,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_FLOOR_BD = 27,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_ON_CONCRETE_BD = 28,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_CUSTOM_BD = 29,
+    XR_SOUND_OBSTACLE_MATERIAL_TYPE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrSoundObstacleMaterialTypeBD;
+typedef XrFlags64 XrSoundObstacleFlagsBD;
+
+// Flag bits for XrSoundObstacleFlagsBD
+static const XrSoundObstacleFlagsBD XR_SOUND_OBSTACLE_ENABLED_BIT_BD = 0x00000001;
+static const XrSoundObstacleFlagsBD XR_SOUND_OBSTACLE_POSE_BIT_BD = 0x00000002;
+static const XrSoundObstacleFlagsBD XR_SOUND_OBSTACLE_MESH_BIT_BD = 0x00000004;
+static const XrSoundObstacleFlagsBD XR_SOUND_OBSTACLE_MATERIALS_BIT_BD = 0x00000008;
+
+typedef XrFlags64 XrSoundObjectFlagsBD;
+
+// Flag bits for XrSoundObjectFlagsBD
+static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_ENABLED_BIT_BD = 0x00000001;
+static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_POSE_BIT_BD = 0x00000002;
+static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_DIRECTIVITY_BIT_BD = 0x00000004;
+static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_SHAPE_BIT_BD = 0x00000008;
+static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_MAIN_VOLUME_BIT_BD = 0x00000010;
+static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_REFLECTION_GAIN_BIT_BD = 0x00000020;
+static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_ENABLE_DOPPLER_BIT_BD = 0x00000040;
+static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_DIRECT_SOUND_ATTENUATION_BIT_BD = 0x00000080;
+static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_INDIRECT_SOUND_ATTENUATION_BIT_BD = 0x00000100;
+
+typedef XrFlags64 XrSoundFieldFlagsBD;
+
+// Flag bits for XrSoundFieldFlagsBD
+static const XrSoundFieldFlagsBD XR_SOUND_FIELD_ENABLED_BIT_BD = 0x00000001;
+static const XrSoundFieldFlagsBD XR_SOUND_FIELD_ORIENTATION_BIT_BD = 0x00000002;
+static const XrSoundFieldFlagsBD XR_SOUND_FIELD_MAIN_VOLUME_BIT_BD = 0x00000004;
+static const XrSoundFieldFlagsBD XR_SOUND_FIELD_LFE_GAIN_BIT_BD = 0x00000008;
+
+typedef struct XrSpatialAudioRendererCreateInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    framesPerBuffer;
+    XrAudioSampleRateBD         sampleRate;
+} XrSpatialAudioRendererCreateInfoBD;
+
+typedef struct XrAudioBufferBD {
+    XrStructureType                 type;
+    const void* XR_MAY_ALIAS        next;
+    XrAudioBufferChannelLayoutBD    channelLayout;
+    uint32_t                        bufferChannels;
+    uint32_t                        bufferLength;
+    float*                          buffer;
+} XrAudioBufferBD;
+
+// XrSoundObjectDirectivityCardioidBD extends XrSoundObjectConfigBD
+typedef struct XrSoundObjectDirectivityCardioidBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       alpha;
+    float                       order;
+} XrSoundObjectDirectivityCardioidBD;
+
+// XrSoundObjectShapeSphereBD extends XrSoundObjectConfigBD
+typedef struct XrSoundObjectShapeSphereBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       radius;
+} XrSoundObjectShapeSphereBD;
+
+typedef struct XrAttenuationCurvePointBD {
+    float    distance;
+    float    gain;
+} XrAttenuationCurvePointBD;
+
+typedef struct XrSoundObjectDistanceAttenuationCurveBD {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    uint32_t                      curvePointCount;
+    XrAttenuationCurvePointBD*    curvePoints;
+} XrSoundObjectDistanceAttenuationCurveBD;
+
+typedef struct XrSoundObjectDistanceAttenuationBD {
+    XrStructureType                             type;
+    const void* XR_MAY_ALIAS                    next;
+    XrSoundObjectDistanceAttenuationTypeBD      distanceAttenuationType;
+    float                                       minAttenuationRange;
+    float                                       maxAttenuationRange;
+    float                                       referenceDistance;
+    float                                       rolloffFactor;
+    XrSoundObjectDistanceAttenuationCurveBD*    customDistanceAttenuationCurve;
+} XrSoundObjectDistanceAttenuationBD;
+
+typedef struct XrSoundObjectConfigBD {
+    XrStructureType                              type;
+    const void* XR_MAY_ALIAS                     next;
+    XrBool32                                     enabled;
+    XrPosef                                      pose;
+    XrSpace                                      baseSpace;
+    float                                        mainVolume;
+    float                                        reflectionGain;
+    XrBool32                                     enableDoppler;
+    const XrSoundObjectDistanceAttenuationBD*    directSoundAttenuation;
+    const XrSoundObjectDistanceAttenuationBD*    indirectSoundAttenuation;
+} XrSoundObjectConfigBD;
+
+typedef struct XrSoundFieldConfigBD {
+     XrStructureType            type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    enabled;
+    XrQuaternionf               orientation;
+    XrSpace                     baseSpace;
+    float                       mainVolume;
+    float                       lfeGain;
+} XrSoundFieldConfigBD;
+
+// XrSoundFieldChannelDefinitionSurroundBD extends XrSoundFieldConfigBD
+typedef struct XrSoundFieldChannelDefinitionSurroundBD {
+    XrStructureType                      type;
+    const void* XR_MAY_ALIAS             next;
+    XrSoundFieldChannelMaskSurroundBD    channelMask;
+} XrSoundFieldChannelDefinitionSurroundBD;
+
+// XrSoundFieldChannelDefinitionAmbixBD extends XrSoundFieldConfigBD
+typedef struct XrSoundFieldChannelDefinitionAmbixBD {
+    XrStructureType                   type;
+    const void* XR_MAY_ALIAS          next;
+    XrSoundFieldChannelMaskAmbixBD    channelMask;
+} XrSoundFieldChannelDefinitionAmbixBD;
+
+// XrSoundFieldChannelDefinitionFumaBD extends XrSoundFieldConfigBD
+typedef struct XrSoundFieldChannelDefinitionFumaBD {
+    XrStructureType                  type;
+    const void* XR_MAY_ALIAS         next;
+    XrSoundFieldChannelMaskFumaBD    channelMask;
+} XrSoundFieldChannelDefinitionFumaBD;
+
+typedef struct XrSoundTriangleMeshBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    vertexCount;
+    XrVector3f*                 vertices;
+    uint32_t                    indexCount;
+    uint32_t*                   indices;
+} XrSoundTriangleMeshBD;
+
+typedef struct XrSoundObstacleConfigBD {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrBool32                      enabled;
+    XrPosef                       pose;
+    XrSpace                       baseSpace;
+    uint32_t                      materialCount;
+    XrSoundObstacleMaterialBD*    materials;
+} XrSoundObstacleConfigBD;
+
+typedef struct XrSoundObstacleMaterialConfigBD {
+    XrStructureType                  type;
+    const void* XR_MAY_ALIAS         next;
+    XrSoundObstacleMaterialTypeBD    materialType;
+    uint32_t                         bandCount;
+    float*                           bandFrequencies;
+    float*                           bandAbsorptions;
+    float*                           bandScatterings;
+    float*                           bandTransmissions;
+} XrSoundObstacleMaterialConfigBD;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedAudioSampleRateBD)(XrSession session, uint32_t sampleRateCapacityInput, uint32_t* sampleRateCountOutput, XrAudioSampleRateBD* sampleRates);
+typedef XrResult (XRAPI_PTR *PFN_xrQueryFramesPerBufferRangeBD)(XrSession session, XrAudioSampleRateBD sampleRate, uint32_t* min, uint32_t* max);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAudioRendererBD)(XrSession session, const XrSpatialAudioRendererCreateInfoBD* createInfo, XrSpatialAudioRendererBD* renderer);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAudioRendererBD)(XrSpatialAudioRendererBD renderer);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundObstacleMaterialBD)(XrSpatialAudioRendererBD renderer, const XrSoundObstacleMaterialConfigBD* config, XrSoundObstacleMaterialBD* material);
+typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundObstacleMaterialConfigBD)(XrSoundObstacleMaterialBD material, const XrSoundObstacleMaterialConfigBD* config);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundObstacleMaterialBD)(XrSoundObstacleMaterialBD material);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundObstacleBD)(XrSpatialAudioRendererBD renderer, const XrSoundObstacleConfigBD* config, const XrSoundTriangleMeshBD* mesh, XrSoundObstacleBD* soundObstacle);
+typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundObstacleConfigBD)(XrSoundObstacleBD soundObstacle, const XrSoundObstacleConfigBD* config, const XrSoundTriangleMeshBD* mesh, XrSoundObstacleFlagsBD flags);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundObstacleBD)(XrSoundObstacleBD soundObstacle);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundObjectBD)(XrSpatialAudioRendererBD renderer, const XrSoundObjectConfigBD* config, XrSoundObjectBD* soundObject);
+typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundObjectConfigBD)(XrSoundObjectBD soundObject, const XrSoundObjectConfigBD* config, XrSoundObjectFlagsBD flags);
+typedef XrResult (XRAPI_PTR *PFN_xrSubmitSoundObjectBufferBD)(XrSoundObjectBD soundObject, const XrAudioBufferBD* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundObjectBD)(XrSoundObjectBD soundObject);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundFieldBD)(XrSpatialAudioRendererBD renderer, const XrSoundFieldConfigBD* config, XrSoundFieldBD* soundField);
+typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundFieldConfigBD)(XrSoundFieldBD soundField, const XrSoundFieldConfigBD* config, XrSoundFieldFlagsBD flags);
+typedef XrResult (XRAPI_PTR *PFN_xrSubmitSoundFieldBufferBD)(XrSoundFieldBD soundField, const XrAudioBufferBD* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundFieldBD)(XrSoundFieldBD soundField);
+typedef XrResult (XRAPI_PTR *PFN_xrWaitAudioPeriodBD)(XrSpatialAudioRendererBD renderer, XrDuration timeout);
+typedef XrResult (XRAPI_PTR *PFN_xrEndAudioPeriodBD)(XrSpatialAudioRendererBD renderer);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedAudioSampleRateBD(
+    XrSession                                   session,
+    uint32_t                                    sampleRateCapacityInput,
+    uint32_t*                                   sampleRateCountOutput,
+    XrAudioSampleRateBD*                        sampleRates);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrQueryFramesPerBufferRangeBD(
+    XrSession                                   session,
+    XrAudioSampleRateBD                         sampleRate,
+    uint32_t*                                   min,
+    uint32_t*                                   max);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAudioRendererBD(
+    XrSession                                   session,
+    const XrSpatialAudioRendererCreateInfoBD*   createInfo,
+    XrSpatialAudioRendererBD*                   renderer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialAudioRendererBD(
+    XrSpatialAudioRendererBD                    renderer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSoundObstacleMaterialBD(
+    XrSpatialAudioRendererBD                    renderer,
+    const XrSoundObstacleMaterialConfigBD*      config,
+    XrSoundObstacleMaterialBD*                  material);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSoundObstacleMaterialConfigBD(
+    XrSoundObstacleMaterialBD                   material,
+    const XrSoundObstacleMaterialConfigBD*      config);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySoundObstacleMaterialBD(
+    XrSoundObstacleMaterialBD                   material);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSoundObstacleBD(
+    XrSpatialAudioRendererBD                    renderer,
+    const XrSoundObstacleConfigBD*              config,
+    const XrSoundTriangleMeshBD*                mesh,
+    XrSoundObstacleBD*                          soundObstacle);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSoundObstacleConfigBD(
+    XrSoundObstacleBD                           soundObstacle,
+    const XrSoundObstacleConfigBD*              config,
+    const XrSoundTriangleMeshBD*                mesh,
+    XrSoundObstacleFlagsBD                      flags);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySoundObstacleBD(
+    XrSoundObstacleBD                           soundObstacle);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSoundObjectBD(
+    XrSpatialAudioRendererBD                    renderer,
+    const XrSoundObjectConfigBD*                config,
+    XrSoundObjectBD*                            soundObject);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSoundObjectConfigBD(
+    XrSoundObjectBD                             soundObject,
+    const XrSoundObjectConfigBD*                config,
+    XrSoundObjectFlagsBD                        flags);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSubmitSoundObjectBufferBD(
+    XrSoundObjectBD                             soundObject,
+    const XrAudioBufferBD*                      buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySoundObjectBD(
+    XrSoundObjectBD                             soundObject);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSoundFieldBD(
+    XrSpatialAudioRendererBD                    renderer,
+    const XrSoundFieldConfigBD*                 config,
+    XrSoundFieldBD*                             soundField);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSoundFieldConfigBD(
+    XrSoundFieldBD                              soundField,
+    const XrSoundFieldConfigBD*                 config,
+    XrSoundFieldFlagsBD                         flags);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSubmitSoundFieldBufferBD(
+    XrSoundFieldBD                              soundField,
+    const XrAudioBufferBD*                      buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySoundFieldBD(
+    XrSoundFieldBD                              soundField);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrWaitAudioPeriodBD(
+    XrSpatialAudioRendererBD                    renderer,
+    XrDuration                                  timeout);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEndAudioPeriodBD(
+    XrSpatialAudioRendererBD                    renderer);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_local_floor is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_local_floor 1
+#define XR_EXT_local_floor_SPEC_VERSION   1
+#define XR_EXT_LOCAL_FLOOR_EXTENSION_NAME "XR_EXT_local_floor"
+
+
+// XR_EXT_hand_tracking_data_source is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_hand_tracking_data_source 1
+#define XR_EXT_hand_tracking_data_source_SPEC_VERSION 1
+#define XR_EXT_HAND_TRACKING_DATA_SOURCE_EXTENSION_NAME "XR_EXT_hand_tracking_data_source"
+
+typedef enum XrHandTrackingDataSourceEXT {
+    XR_HAND_TRACKING_DATA_SOURCE_UNOBSTRUCTED_EXT = 1,
+    XR_HAND_TRACKING_DATA_SOURCE_CONTROLLER_EXT = 2,
+    XR_HAND_TRACKING_DATA_SOURCE_UNOBSTRUCTED_WIDE_MOTION_META = 1000695000,
+    XR_HAND_TRACKING_DATA_SOURCE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrHandTrackingDataSourceEXT;
+// XrHandTrackingDataSourceInfoEXT extends XrHandTrackerCreateInfoEXT
+typedef struct XrHandTrackingDataSourceInfoEXT {
+    XrStructureType                 type;
+    const void* XR_MAY_ALIAS        next;
+    uint32_t                        requestedDataSourceCount;
+    XrHandTrackingDataSourceEXT*    requestedDataSources;
+} XrHandTrackingDataSourceInfoEXT;
+
+// XrHandTrackingDataSourceStateEXT extends XrHandJointLocationsEXT
+typedef struct XrHandTrackingDataSourceStateEXT {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    XrBool32                       isActive;
+    XrHandTrackingDataSourceEXT    dataSource;
+} XrHandTrackingDataSourceStateEXT;
+
+
+
+// XR_EXT_plane_detection is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_plane_detection 1
+XR_DEFINE_HANDLE(XrPlaneDetectorEXT)
+#define XR_EXT_plane_detection_SPEC_VERSION 2
+#define XR_EXT_PLANE_DETECTION_EXTENSION_NAME "XR_EXT_plane_detection"
+
+typedef enum XrPlaneDetectorOrientationEXT {
+    XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_UPWARD_EXT = 0,
+    XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_DOWNWARD_EXT = 1,
+    XR_PLANE_DETECTOR_ORIENTATION_VERTICAL_EXT = 2,
+    XR_PLANE_DETECTOR_ORIENTATION_ARBITRARY_EXT = 3,
+    XR_PLANE_DETECTOR_ORIENTATION_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrPlaneDetectorOrientationEXT;
+
+typedef enum XrPlaneDetectorSemanticTypeEXT {
+    XR_PLANE_DETECTOR_SEMANTIC_TYPE_UNDEFINED_EXT = 0,
+    XR_PLANE_DETECTOR_SEMANTIC_TYPE_CEILING_EXT = 1,
+    XR_PLANE_DETECTOR_SEMANTIC_TYPE_FLOOR_EXT = 2,
+    XR_PLANE_DETECTOR_SEMANTIC_TYPE_WALL_EXT = 3,
+    XR_PLANE_DETECTOR_SEMANTIC_TYPE_PLATFORM_EXT = 4,
+    XR_PLANE_DETECTOR_SEMANTIC_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrPlaneDetectorSemanticTypeEXT;
+
+typedef enum XrPlaneDetectionStateEXT {
+    XR_PLANE_DETECTION_STATE_NONE_EXT = 0,
+    XR_PLANE_DETECTION_STATE_PENDING_EXT = 1,
+    XR_PLANE_DETECTION_STATE_DONE_EXT = 2,
+    XR_PLANE_DETECTION_STATE_ERROR_EXT = 3,
+    XR_PLANE_DETECTION_STATE_FATAL_EXT = 4,
+    XR_PLANE_DETECTION_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrPlaneDetectionStateEXT;
+typedef XrFlags64 XrPlaneDetectionCapabilityFlagsEXT;
+
+// Flag bits for XrPlaneDetectionCapabilityFlagsEXT
+static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_PLANE_DETECTION_BIT_EXT = 0x00000001;
+static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_PLANE_HOLES_BIT_EXT = 0x00000002;
+static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_CEILING_BIT_EXT = 0x00000004;
+static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_FLOOR_BIT_EXT = 0x00000008;
+static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_WALL_BIT_EXT = 0x00000010;
+static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_PLATFORM_BIT_EXT = 0x00000020;
+static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_ORIENTATION_BIT_EXT = 0x00000040;
+
+typedef XrFlags64 XrPlaneDetectorFlagsEXT;
+
+// Flag bits for XrPlaneDetectorFlagsEXT
+static const XrPlaneDetectorFlagsEXT XR_PLANE_DETECTOR_ENABLE_CONTOUR_BIT_EXT = 0x00000001;
+
+// XrSystemPlaneDetectionPropertiesEXT extends XrSystemProperties
+typedef struct XrSystemPlaneDetectionPropertiesEXT {
+    XrStructureType                       type;
+    void* XR_MAY_ALIAS                    next;
+    XrPlaneDetectionCapabilityFlagsEXT    supportedFeatures;
+} XrSystemPlaneDetectionPropertiesEXT;
+
+typedef struct XrPlaneDetectorCreateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrPlaneDetectorFlagsEXT     flags;
+} XrPlaneDetectorCreateInfoEXT;
+
+typedef XrExtent3Df XrExtent3DfEXT;
+
+typedef struct XrPlaneDetectorBeginInfoEXT {
+    XrStructureType                          type;
+    const void* XR_MAY_ALIAS                 next;
+    XrSpace                                  baseSpace;
+    XrTime                                   time;
+    uint32_t                                 orientationCount;
+    const XrPlaneDetectorOrientationEXT*     orientations;
+    uint32_t                                 semanticTypeCount;
+    const XrPlaneDetectorSemanticTypeEXT*    semanticTypes;
+    uint32_t                                 maxPlanes;
+    float                                    minArea;
+    XrPosef                                  boundingBoxPose;
+    XrExtent3DfEXT                           boundingBoxExtent;
+} XrPlaneDetectorBeginInfoEXT;
+
+typedef struct XrPlaneDetectorGetInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+} XrPlaneDetectorGetInfoEXT;
+
+typedef struct XrPlaneDetectorLocationEXT {
+    XrStructureType                   type;
+    void* XR_MAY_ALIAS                next;
+    uint64_t                          planeId;
+    XrSpaceLocationFlags              locationFlags;
+    XrPosef                           pose;
+    XrExtent2Df                       extents;
+    XrPlaneDetectorOrientationEXT     orientation;
+    XrPlaneDetectorSemanticTypeEXT    semanticType;
+    uint32_t                          polygonBufferCount;
+} XrPlaneDetectorLocationEXT;
+
+typedef struct XrPlaneDetectorLocationsEXT {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    uint32_t                       planeLocationCapacityInput;
+    uint32_t                       planeLocationCountOutput;
+    XrPlaneDetectorLocationEXT*    planeLocations;
+} XrPlaneDetectorLocationsEXT;
+
+typedef struct XrPlaneDetectorPolygonBufferEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              vertexCapacityInput;
+    uint32_t              vertexCountOutput;
+    XrVector2f*           vertices;
+} XrPlaneDetectorPolygonBufferEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreatePlaneDetectorEXT)(XrSession session, const XrPlaneDetectorCreateInfoEXT* createInfo, XrPlaneDetectorEXT* planeDetector);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyPlaneDetectorEXT)(XrPlaneDetectorEXT planeDetector);
+typedef XrResult (XRAPI_PTR *PFN_xrBeginPlaneDetectionEXT)(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorBeginInfoEXT* beginInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrGetPlaneDetectionStateEXT)(XrPlaneDetectorEXT planeDetector, XrPlaneDetectionStateEXT* state);
+typedef XrResult (XRAPI_PTR *PFN_xrGetPlaneDetectionsEXT)(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorGetInfoEXT* info, XrPlaneDetectorLocationsEXT* locations);
+typedef XrResult (XRAPI_PTR *PFN_xrGetPlanePolygonBufferEXT)(XrPlaneDetectorEXT planeDetector, uint64_t planeId, uint32_t polygonBufferIndex, XrPlaneDetectorPolygonBufferEXT* polygonBuffer);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreatePlaneDetectorEXT(
+    XrSession                                   session,
+    const XrPlaneDetectorCreateInfoEXT*         createInfo,
+    XrPlaneDetectorEXT*                         planeDetector);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPlaneDetectorEXT(
+    XrPlaneDetectorEXT                          planeDetector);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrBeginPlaneDetectionEXT(
+    XrPlaneDetectorEXT                          planeDetector,
+    const XrPlaneDetectorBeginInfoEXT*          beginInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetPlaneDetectionStateEXT(
+    XrPlaneDetectorEXT                          planeDetector,
+    XrPlaneDetectionStateEXT*                   state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetPlaneDetectionsEXT(
+    XrPlaneDetectorEXT                          planeDetector,
+    const XrPlaneDetectorGetInfoEXT*            info,
+    XrPlaneDetectorLocationsEXT*                locations);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetPlanePolygonBufferEXT(
+    XrPlaneDetectorEXT                          planeDetector,
+    uint64_t                                    planeId,
+    uint32_t                                    polygonBufferIndex,
+    XrPlaneDetectorPolygonBufferEXT*            polygonBuffer);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_OPPO_controller_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_OPPO_controller_interaction 1
+#define XR_OPPO_controller_interaction_SPEC_VERSION 1
+#define XR_OPPO_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_OPPO_controller_interaction"
+
+
+// XR_ANDROID_trackables is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_trackables 1
+
+#define XR_NULL_TRACKABLE_ANDROID 0
+
+XR_DEFINE_ATOM(XrTrackableANDROID)
+XR_DEFINE_HANDLE(XrTrackableTrackerANDROID)
+#define XR_ANDROID_trackables_SPEC_VERSION 2
+#define XR_ANDROID_TRACKABLES_EXTENSION_NAME "XR_ANDROID_trackables"
+
+typedef enum XrTrackingStateANDROID {
+    XR_TRACKING_STATE_PAUSED_ANDROID = 0,
+    XR_TRACKING_STATE_STOPPED_ANDROID = 1,
+    XR_TRACKING_STATE_TRACKING_ANDROID = 2,
+    XR_TRACKING_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrTrackingStateANDROID;
+
+typedef enum XrTrackableTypeANDROID {
+    XR_TRACKABLE_TYPE_NOT_VALID_ANDROID = 0,
+    XR_TRACKABLE_TYPE_PLANE_ANDROID = 1,
+    XR_TRACKABLE_TYPE_DEPTH_ANDROID = 1000463000,
+    XR_TRACKABLE_TYPE_OBJECT_ANDROID = 1000466000,
+    XR_TRACKABLE_TYPE_MARKER_ANDROID = 1000707000,
+    XR_TRACKABLE_TYPE_QR_CODE_ANDROID = 1000708000,
+    XR_TRACKABLE_TYPE_IMAGE_ANDROID = 1000709000,
+    XR_TRACKABLE_TYPE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrTrackableTypeANDROID;
+
+typedef enum XrPlaneTypeANDROID {
+    XR_PLANE_TYPE_HORIZONTAL_DOWNWARD_FACING_ANDROID = 0,
+    XR_PLANE_TYPE_HORIZONTAL_UPWARD_FACING_ANDROID = 1,
+    XR_PLANE_TYPE_VERTICAL_ANDROID = 2,
+    XR_PLANE_TYPE_ARBITRARY_ANDROID = 3,
+    XR_PLANE_TYPE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrPlaneTypeANDROID;
+
+typedef enum XrPlaneLabelANDROID {
+    XR_PLANE_LABEL_UNKNOWN_ANDROID = 0,
+    XR_PLANE_LABEL_WALL_ANDROID = 1,
+    XR_PLANE_LABEL_FLOOR_ANDROID = 2,
+    XR_PLANE_LABEL_CEILING_ANDROID = 3,
+    XR_PLANE_LABEL_TABLE_ANDROID = 4,
+    XR_PLANE_LABEL_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrPlaneLabelANDROID;
+typedef struct XrTrackableTrackerCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTrackableTypeANDROID      trackableType;
+} XrTrackableTrackerCreateInfoANDROID;
+
+typedef struct XrTrackableGetInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTrackableANDROID          trackable;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+} XrTrackableGetInfoANDROID;
+
+typedef struct XrTrackablePlaneANDROID {
+    XrStructureType           type;
+    void* XR_MAY_ALIAS        next;
+    XrTrackingStateANDROID    trackingState;
+    XrPosef                   centerPose;
+    XrExtent2Df               extents;
+    XrPlaneTypeANDROID        planeType;
+    XrPlaneLabelANDROID       planeLabel;
+    XrTrackableANDROID        subsumedByPlane;
+    XrTime                    lastUpdatedTime;
+    uint32_t                  vertexCapacityInput;
+    uint32_t*                 vertexCountOutput;
+    XrVector2f*               vertices;
+} XrTrackablePlaneANDROID;
+
+typedef struct XrAnchorSpaceCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrTime                      time;
+    XrPosef                     pose;
+    XrTrackableANDROID          trackable;
+} XrAnchorSpaceCreateInfoANDROID;
+
+// XrSystemTrackablesPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemTrackablesPropertiesANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    supportsAnchor;
+    uint32_t                    maxAnchors;
+} XrSystemTrackablesPropertiesANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedTrackableTypesANDROID)(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t* trackableTypeCountOutput, XrTrackableTypeANDROID* trackableTypes);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedAnchorTrackableTypesANDROID)(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t* trackableTypeCountOutput, XrTrackableTypeANDROID* trackableTypes);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateTrackableTrackerANDROID)(XrSession session, const XrTrackableTrackerCreateInfoANDROID* createInfo, XrTrackableTrackerANDROID* trackableTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyTrackableTrackerANDROID)(XrTrackableTrackerANDROID trackableTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrGetAllTrackablesANDROID)(XrTrackableTrackerANDROID trackableTracker, uint32_t trackableCapacityInput, uint32_t* trackableCountOutput, XrTrackableANDROID* trackables);
+typedef XrResult (XRAPI_PTR *PFN_xrGetTrackablePlaneANDROID)(XrTrackableTrackerANDROID trackableTracker, const XrTrackableGetInfoANDROID* getInfo, XrTrackablePlaneANDROID* planeOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateAnchorSpaceANDROID)(XrSession session, const XrAnchorSpaceCreateInfoANDROID* createInfo, XrSpace* anchorOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedTrackableTypesANDROID(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    trackableTypeCapacityInput,
+    uint32_t*                                   trackableTypeCountOutput,
+    XrTrackableTypeANDROID*                     trackableTypes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedAnchorTrackableTypesANDROID(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    trackableTypeCapacityInput,
+    uint32_t*                                   trackableTypeCountOutput,
+    XrTrackableTypeANDROID*                     trackableTypes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateTrackableTrackerANDROID(
+    XrSession                                   session,
+    const XrTrackableTrackerCreateInfoANDROID*  createInfo,
+    XrTrackableTrackerANDROID*                  trackableTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyTrackableTrackerANDROID(
+    XrTrackableTrackerANDROID                   trackableTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetAllTrackablesANDROID(
+    XrTrackableTrackerANDROID                   trackableTracker,
+    uint32_t                                    trackableCapacityInput,
+    uint32_t*                                   trackableCountOutput,
+    XrTrackableANDROID*                         trackables);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetTrackablePlaneANDROID(
+    XrTrackableTrackerANDROID                   trackableTracker,
+    const XrTrackableGetInfoANDROID*            getInfo,
+    XrTrackablePlaneANDROID*                    planeOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateAnchorSpaceANDROID(
+    XrSession                                   session,
+    const XrAnchorSpaceCreateInfoANDROID*       createInfo,
+    XrSpace*                                    anchorOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_eye_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_eye_tracking 1
+XR_DEFINE_HANDLE(XrEyeTrackerANDROID)
+#define XR_EYE_MAX_ANDROID                2
+#define XR_ANDROID_eye_tracking_SPEC_VERSION 1
+#define XR_ANDROID_EYE_TRACKING_EXTENSION_NAME "XR_ANDROID_eye_tracking"
+
+typedef enum XrEyeIndexANDROID {
+    XR_EYE_INDEX_LEFT_ANDROID = 0,
+    XR_EYE_INDEX_RIGHT_ANDROID = 1,
+    XR_EYE_INDEX_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrEyeIndexANDROID;
+
+typedef enum XrEyeStateANDROID {
+    XR_EYE_STATE_INVALID_ANDROID = 0,
+    XR_EYE_STATE_GAZING_ANDROID = 1,
+    XR_EYE_STATE_SHUT_ANDROID = 2,
+    XR_EYE_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrEyeStateANDROID;
+
+typedef enum XrEyeTrackingModeANDROID {
+    XR_EYE_TRACKING_MODE_NOT_TRACKING_ANDROID = 0,
+    XR_EYE_TRACKING_MODE_RIGHT_ANDROID = 1,
+    XR_EYE_TRACKING_MODE_LEFT_ANDROID = 2,
+    XR_EYE_TRACKING_MODE_BOTH_ANDROID = 3,
+    XR_EYE_TRACKING_MODE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrEyeTrackingModeANDROID;
+// XrSystemEyeTrackingPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemEyeTrackingPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsEyeTracking;
+} XrSystemEyeTrackingPropertiesANDROID;
+
+typedef struct XrEyeANDROID {
+    XrEyeStateANDROID    eyeState;
+    XrPosef              eyePose;
+} XrEyeANDROID;
+
+typedef struct XrEyesANDROID {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    XrEyeANDROID                eyes[XR_EYE_MAX_ANDROID];
+    XrEyeTrackingModeANDROID    mode;
+} XrEyesANDROID;
+
+typedef struct XrEyesGetInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      time;
+    XrSpace                     baseSpace;
+} XrEyesGetInfoANDROID;
+
+typedef struct XrEyeTrackerCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrEyeTrackerCreateInfoANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateEyeTrackerANDROID)(XrSession session, const XrEyeTrackerCreateInfoANDROID* createInfo, XrEyeTrackerANDROID* eyeTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyEyeTrackerANDROID)(XrEyeTrackerANDROID eyeTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrGetFineTrackingEyesInfoANDROID)(XrEyeTrackerANDROID eyeTracker, const XrEyesGetInfoANDROID* getInfo, XrEyesANDROID* eyesOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrGetCoarseTrackingEyesInfoANDROID)(XrEyeTrackerANDROID eyeTracker, const XrEyesGetInfoANDROID* getInfo, XrEyesANDROID* eyesOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateEyeTrackerANDROID(
+    XrSession                                   session,
+    const XrEyeTrackerCreateInfoANDROID*        createInfo,
+    XrEyeTrackerANDROID*                        eyeTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyEyeTrackerANDROID(
+    XrEyeTrackerANDROID                         eyeTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetFineTrackingEyesInfoANDROID(
+    XrEyeTrackerANDROID                         eyeTracker,
+    const XrEyesGetInfoANDROID*                 getInfo,
+    XrEyesANDROID*                              eyesOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetCoarseTrackingEyesInfoANDROID(
+    XrEyeTrackerANDROID                         eyeTracker,
+    const XrEyesGetInfoANDROID*                 getInfo,
+    XrEyesANDROID*                              eyesOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_device_anchor_persistence is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_device_anchor_persistence 1
+XR_DEFINE_HANDLE(XrDeviceAnchorPersistenceANDROID)
+#define XR_ANDROID_device_anchor_persistence_SPEC_VERSION 1
+#define XR_ANDROID_DEVICE_ANCHOR_PERSISTENCE_EXTENSION_NAME "XR_ANDROID_device_anchor_persistence"
+
+typedef enum XrAnchorPersistStateANDROID {
+    XR_ANCHOR_PERSIST_STATE_PERSIST_NOT_REQUESTED_ANDROID = 0,
+    XR_ANCHOR_PERSIST_STATE_PERSIST_PENDING_ANDROID = 1,
+    XR_ANCHOR_PERSIST_STATE_PERSISTED_ANDROID = 2,
+    XR_ANCHOR_PERSIST_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrAnchorPersistStateANDROID;
+typedef struct XrDeviceAnchorPersistenceCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrDeviceAnchorPersistenceCreateInfoANDROID;
+
+typedef struct XrPersistedAnchorSpaceCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrUuidEXT                   anchorId;
+} XrPersistedAnchorSpaceCreateInfoANDROID;
+
+typedef struct XrPersistedAnchorSpaceInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     anchor;
+} XrPersistedAnchorSpaceInfoANDROID;
+
+// XrSystemDeviceAnchorPersistencePropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemDeviceAnchorPersistencePropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsAnchorPersistence;
+} XrSystemDeviceAnchorPersistencePropertiesANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedPersistenceAnchorTypesANDROID)(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t* trackableTypeCountOutput, XrTrackableTypeANDROID* trackableTypes);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateDeviceAnchorPersistenceANDROID)(XrSession session, const XrDeviceAnchorPersistenceCreateInfoANDROID* createInfo, XrDeviceAnchorPersistenceANDROID* outHandle);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyDeviceAnchorPersistenceANDROID)(XrDeviceAnchorPersistenceANDROID handle);
+typedef XrResult (XRAPI_PTR *PFN_xrPersistAnchorANDROID)(XrDeviceAnchorPersistenceANDROID handle, const XrPersistedAnchorSpaceInfoANDROID* persistedInfo, XrUuidEXT* anchorIdOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrGetAnchorPersistStateANDROID)(XrDeviceAnchorPersistenceANDROID handle, const XrUuidEXT* anchorId, XrAnchorPersistStateANDROID* persistState);
+typedef XrResult (XRAPI_PTR *PFN_xrCreatePersistedAnchorSpaceANDROID)(XrDeviceAnchorPersistenceANDROID handle, const XrPersistedAnchorSpaceCreateInfoANDROID* createInfo, XrSpace* anchorOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePersistedAnchorsANDROID)(XrDeviceAnchorPersistenceANDROID handle, uint32_t anchorIdCapacityInput, uint32_t* anchorIdCountOutput, XrUuidEXT* anchorIds);
+typedef XrResult (XRAPI_PTR *PFN_xrUnpersistAnchorANDROID)(XrDeviceAnchorPersistenceANDROID handle, const XrUuidEXT* anchorId);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedPersistenceAnchorTypesANDROID(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    trackableTypeCapacityInput,
+    uint32_t*                                   trackableTypeCountOutput,
+    XrTrackableTypeANDROID*                     trackableTypes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateDeviceAnchorPersistenceANDROID(
+    XrSession                                   session,
+    const XrDeviceAnchorPersistenceCreateInfoANDROID* createInfo,
+    XrDeviceAnchorPersistenceANDROID*           outHandle);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyDeviceAnchorPersistenceANDROID(
+    XrDeviceAnchorPersistenceANDROID            handle);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPersistAnchorANDROID(
+    XrDeviceAnchorPersistenceANDROID            handle,
+    const XrPersistedAnchorSpaceInfoANDROID*    persistedInfo,
+    XrUuidEXT*                                  anchorIdOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetAnchorPersistStateANDROID(
+    XrDeviceAnchorPersistenceANDROID            handle,
+    const XrUuidEXT*                            anchorId,
+    XrAnchorPersistStateANDROID*                persistState);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreatePersistedAnchorSpaceANDROID(
+    XrDeviceAnchorPersistenceANDROID            handle,
+    const XrPersistedAnchorSpaceCreateInfoANDROID* createInfo,
+    XrSpace*                                    anchorOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumeratePersistedAnchorsANDROID(
+    XrDeviceAnchorPersistenceANDROID            handle,
+    uint32_t                                    anchorIdCapacityInput,
+    uint32_t*                                   anchorIdCountOutput,
+    XrUuidEXT*                                  anchorIds);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistAnchorANDROID(
+    XrDeviceAnchorPersistenceANDROID            handle,
+    const XrUuidEXT*                            anchorId);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_face_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_face_tracking 1
+XR_DEFINE_HANDLE(XrFaceTrackerANDROID)
+#define XR_ANDROID_face_tracking_SPEC_VERSION 1
+#define XR_ANDROID_FACE_TRACKING_EXTENSION_NAME "XR_ANDROID_face_tracking"
+#define XR_FACE_PARAMETER_COUNT_ANDROID   68
+#define XR_FACE_REGION_CONFIDENCE_COUNT_ANDROID 3
+
+typedef enum XrFaceParameterIndicesANDROID {
+    XR_FACE_PARAMETER_INDICES_BROW_LOWERER_L_ANDROID = 0,
+    XR_FACE_PARAMETER_INDICES_BROW_LOWERER_R_ANDROID = 1,
+    XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_L_ANDROID = 2,
+    XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_R_ANDROID = 3,
+    XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_L_ANDROID = 4,
+    XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_R_ANDROID = 5,
+    XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_L_ANDROID = 6,
+    XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_R_ANDROID = 7,
+    XR_FACE_PARAMETER_INDICES_CHIN_RAISER_B_ANDROID = 8,
+    XR_FACE_PARAMETER_INDICES_CHIN_RAISER_T_ANDROID = 9,
+    XR_FACE_PARAMETER_INDICES_DIMPLER_L_ANDROID = 10,
+    XR_FACE_PARAMETER_INDICES_DIMPLER_R_ANDROID = 11,
+    XR_FACE_PARAMETER_INDICES_EYES_CLOSED_L_ANDROID = 12,
+    XR_FACE_PARAMETER_INDICES_EYES_CLOSED_R_ANDROID = 13,
+    XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_L_ANDROID = 14,
+    XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_R_ANDROID = 15,
+    XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_L_ANDROID = 16,
+    XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_R_ANDROID = 17,
+    XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_L_ANDROID = 18,
+    XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_R_ANDROID = 19,
+    XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_L_ANDROID = 20,
+    XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_R_ANDROID = 21,
+    XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_L_ANDROID = 22,
+    XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_R_ANDROID = 23,
+    XR_FACE_PARAMETER_INDICES_JAW_DROP_ANDROID = 24,
+    XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_LEFT_ANDROID = 25,
+    XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_RIGHT_ANDROID = 26,
+    XR_FACE_PARAMETER_INDICES_JAW_THRUST_ANDROID = 27,
+    XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_L_ANDROID = 28,
+    XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_R_ANDROID = 29,
+    XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_L_ANDROID = 30,
+    XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_R_ANDROID = 31,
+    XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_L_ANDROID = 32,
+    XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_R_ANDROID = 33,
+    XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LB_ANDROID = 34,
+    XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LT_ANDROID = 35,
+    XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RB_ANDROID = 36,
+    XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RT_ANDROID = 37,
+    XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_L_ANDROID = 38,
+    XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_R_ANDROID = 39,
+    XR_FACE_PARAMETER_INDICES_LIP_PUCKER_L_ANDROID = 40,
+    XR_FACE_PARAMETER_INDICES_LIP_PUCKER_R_ANDROID = 41,
+    XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_L_ANDROID = 42,
+    XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_R_ANDROID = 43,
+    XR_FACE_PARAMETER_INDICES_LIP_SUCK_LB_ANDROID = 44,
+    XR_FACE_PARAMETER_INDICES_LIP_SUCK_LT_ANDROID = 45,
+    XR_FACE_PARAMETER_INDICES_LIP_SUCK_RB_ANDROID = 46,
+    XR_FACE_PARAMETER_INDICES_LIP_SUCK_RT_ANDROID = 47,
+    XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_L_ANDROID = 48,
+    XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_R_ANDROID = 49,
+    XR_FACE_PARAMETER_INDICES_LIPS_TOWARD_ANDROID = 50,
+    XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_L_ANDROID = 51,
+    XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_R_ANDROID = 52,
+    XR_FACE_PARAMETER_INDICES_MOUTH_LEFT_ANDROID = 53,
+    XR_FACE_PARAMETER_INDICES_MOUTH_RIGHT_ANDROID = 54,
+    XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_L_ANDROID = 55,
+    XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_R_ANDROID = 56,
+    XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_L_ANDROID = 57,
+    XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_R_ANDROID = 58,
+    XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_L_ANDROID = 59,
+    XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_R_ANDROID = 60,
+    XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_L_ANDROID = 61,
+    XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_R_ANDROID = 62,
+    XR_FACE_PARAMETER_INDICES_TONGUE_OUT_ANDROID = 63,
+    XR_FACE_PARAMETER_INDICES_TONGUE_LEFT_ANDROID = 64,
+    XR_FACE_PARAMETER_INDICES_TONGUE_RIGHT_ANDROID = 65,
+    XR_FACE_PARAMETER_INDICES_TONGUE_UP_ANDROID = 66,
+    XR_FACE_PARAMETER_INDICES_TONGUE_DOWN_ANDROID = 67,
+    XR_FACE_PARAMETER_INDICES_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrFaceParameterIndicesANDROID;
+
+typedef enum XrFaceTrackingStateANDROID {
+    XR_FACE_TRACKING_STATE_PAUSED_ANDROID = 0,
+    XR_FACE_TRACKING_STATE_STOPPED_ANDROID = 1,
+    XR_FACE_TRACKING_STATE_TRACKING_ANDROID = 2,
+    XR_FACE_TRACKING_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrFaceTrackingStateANDROID;
+
+typedef enum XrFaceConfidenceRegionsANDROID {
+    XR_FACE_CONFIDENCE_REGIONS_LOWER_ANDROID = 0,
+    XR_FACE_CONFIDENCE_REGIONS_LEFT_UPPER_ANDROID = 1,
+    XR_FACE_CONFIDENCE_REGIONS_RIGHT_UPPER_ANDROID = 2,
+    XR_FACE_CONFIDENCE_REGIONS_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrFaceConfidenceRegionsANDROID;
+typedef struct XrFaceTrackerCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrFaceTrackerCreateInfoANDROID;
+
+typedef struct XrFaceStateGetInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      time;
+} XrFaceStateGetInfoANDROID;
+
+typedef struct XrFaceStateANDROID {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    uint32_t                      parametersCapacityInput;
+    uint32_t                      parametersCountOutput;
+    float*                        parameters;
+    XrFaceTrackingStateANDROID    faceTrackingState;
+    XrTime                        sampleTime;
+    XrBool32                      isValid;
+    uint32_t                      regionConfidencesCapacityInput;
+    uint32_t                      regionConfidencesCountOutput;
+    float*                        regionConfidences;
+} XrFaceStateANDROID;
+
+// XrSystemFaceTrackingPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemFaceTrackingPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsFaceTracking;
+} XrSystemFaceTrackingPropertiesANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTrackerANDROID)(XrSession session, const XrFaceTrackerCreateInfoANDROID* createInfo, XrFaceTrackerANDROID* faceTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTrackerANDROID)(XrFaceTrackerANDROID faceTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrGetFaceStateANDROID)(XrFaceTrackerANDROID faceTracker, const XrFaceStateGetInfoANDROID* getInfo, XrFaceStateANDROID* faceStateOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrGetFaceCalibrationStateANDROID)(XrFaceTrackerANDROID faceTracker, XrBool32* faceIsCalibratedOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateFaceTrackerANDROID(
+    XrSession                                   session,
+    const XrFaceTrackerCreateInfoANDROID*       createInfo,
+    XrFaceTrackerANDROID*                       faceTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFaceTrackerANDROID(
+    XrFaceTrackerANDROID                        faceTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetFaceStateANDROID(
+    XrFaceTrackerANDROID                        faceTracker,
+    const XrFaceStateGetInfoANDROID*            getInfo,
+    XrFaceStateANDROID*                         faceStateOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetFaceCalibrationStateANDROID(
+    XrFaceTrackerANDROID                        faceTracker,
+    XrBool32*                                   faceIsCalibratedOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_passthrough_camera_state is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_passthrough_camera_state 1
+#define XR_ANDROID_passthrough_camera_state_SPEC_VERSION 1
+#define XR_ANDROID_PASSTHROUGH_CAMERA_STATE_EXTENSION_NAME "XR_ANDROID_passthrough_camera_state"
+
+typedef enum XrPassthroughCameraStateANDROID {
+    XR_PASSTHROUGH_CAMERA_STATE_DISABLED_ANDROID = 0,
+    XR_PASSTHROUGH_CAMERA_STATE_INITIALIZING_ANDROID = 1,
+    XR_PASSTHROUGH_CAMERA_STATE_READY_ANDROID = 2,
+    XR_PASSTHROUGH_CAMERA_STATE_ERROR_ANDROID = 3,
+    XR_PASSTHROUGH_CAMERA_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrPassthroughCameraStateANDROID;
+// XrSystemPassthroughCameraStatePropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemPassthroughCameraStatePropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsPassthroughCameraState;
+} XrSystemPassthroughCameraStatePropertiesANDROID;
+
+typedef struct XrPassthroughCameraStateGetInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrPassthroughCameraStateGetInfoANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetPassthroughCameraStateANDROID)(XrSession session, const XrPassthroughCameraStateGetInfoANDROID* getInfo, XrPassthroughCameraStateANDROID* cameraStateOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetPassthroughCameraStateANDROID(
+    XrSession                                   session,
+    const XrPassthroughCameraStateGetInfoANDROID* getInfo,
+    XrPassthroughCameraStateANDROID*            cameraStateOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_recommended_resolution is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_recommended_resolution 1
+#define XR_ANDROID_recommended_resolution_SPEC_VERSION 1
+#define XR_ANDROID_RECOMMENDED_RESOLUTION_EXTENSION_NAME "XR_ANDROID_recommended_resolution"
+typedef struct XrEventDataRecommendedResolutionChangedANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrEventDataRecommendedResolutionChangedANDROID;
+
+
+
+// XR_ANDROID_composition_layer_passthrough_mesh is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_composition_layer_passthrough_mesh 1
+XR_DEFINE_HANDLE(XrPassthroughLayerANDROID)
+#define XR_ANDROID_composition_layer_passthrough_mesh_SPEC_VERSION 1
+#define XR_ANDROID_COMPOSITION_LAYER_PASSTHROUGH_MESH_EXTENSION_NAME "XR_ANDROID_composition_layer_passthrough_mesh"
+
+typedef enum XrWindingOrderANDROID {
+    XR_WINDING_ORDER_UNKNOWN_ANDROID = 0,
+    XR_WINDING_ORDER_CW_ANDROID = 1,
+    XR_WINDING_ORDER_CCW_ANDROID = 2,
+    XR_WINDING_ORDER_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrWindingOrderANDROID;
+typedef struct XrPassthroughLayerCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    vertexCapacity;
+    uint32_t                    indexCapacity;
+} XrPassthroughLayerCreateInfoANDROID;
+
+// XrPassthroughLayerMeshANDROID extends XrPassthroughLayerCreateInfoANDROID
+typedef struct XrPassthroughLayerMeshANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrWindingOrderANDROID       windingOrder;
+    uint32_t                    vertexCount;
+    const XrVector3f*           vertices;
+    uint32_t                    indexCount;
+    const uint16_t*             indices;
+} XrPassthroughLayerMeshANDROID;
+
+typedef struct XrCompositionLayerPassthroughANDROID {
+    XrStructureType              type;
+    const void* XR_MAY_ALIAS     next;
+    XrCompositionLayerFlags      layerFlags;
+    XrSpace                      space;
+    XrPosef                      pose;
+    XrVector3f                   scale;
+    float                        opacity;
+    XrPassthroughLayerANDROID    layer;
+} XrCompositionLayerPassthroughANDROID;
+
+// XrSystemPassthroughLayerPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemPassthroughLayerPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsPassthroughLayer;
+    uint32_t              maxMeshIndexCount;
+    uint32_t              maxMeshVertexCount;
+} XrSystemPassthroughLayerPropertiesANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughLayerANDROID)(XrSession session, const XrPassthroughLayerCreateInfoANDROID* createInfo, XrPassthroughLayerANDROID* layer);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughLayerANDROID)(XrPassthroughLayerANDROID layer);
+typedef XrResult (XRAPI_PTR *PFN_xrSetPassthroughLayerMeshANDROID)(XrPassthroughLayerANDROID layer, const XrPassthroughLayerMeshANDROID* mesh);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughLayerANDROID(
+    XrSession                                   session,
+    const XrPassthroughLayerCreateInfoANDROID*  createInfo,
+    XrPassthroughLayerANDROID*                  layer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughLayerANDROID(
+    XrPassthroughLayerANDROID                   layer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetPassthroughLayerMeshANDROID(
+    XrPassthroughLayerANDROID                   layer,
+    const XrPassthroughLayerMeshANDROID*        mesh);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_raycast is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_raycast 1
+#define XR_ANDROID_raycast_SPEC_VERSION   1
+#define XR_ANDROID_RAYCAST_EXTENSION_NAME "XR_ANDROID_raycast"
+typedef struct XrRaycastInfoANDROID {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    uint32_t                            maxResults;
+    uint32_t                            trackerCount;
+    const XrTrackableTrackerANDROID*    trackers;
+    XrVector3f                          origin;
+    XrVector3f                          trajectory;
+    XrSpace                             space;
+    XrTime                              time;
+} XrRaycastInfoANDROID;
+
+typedef struct XrRaycastHitResultANDROID {
+    XrTrackableTypeANDROID    type;
+    XrTrackableANDROID        trackable;
+    XrPosef                   pose;
+} XrRaycastHitResultANDROID;
+
+typedef struct XrRaycastHitResultsANDROID {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    uint32_t                      resultsCapacityInput;
+    uint32_t                      resultsCountOutput;
+    XrRaycastHitResultANDROID*    results;
+} XrRaycastHitResultsANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateRaycastSupportedTrackableTypesANDROID)(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t* trackableTypeCountOutput, XrTrackableTypeANDROID* trackableTypes);
+typedef XrResult (XRAPI_PTR *PFN_xrRaycastANDROID)(XrSession session, const XrRaycastInfoANDROID* rayInfo, XrRaycastHitResultsANDROID* results);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateRaycastSupportedTrackableTypesANDROID(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    trackableTypeCapacityInput,
+    uint32_t*                                   trackableTypeCountOutput,
+    XrTrackableTypeANDROID*                     trackableTypes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRaycastANDROID(
+    XrSession                                   session,
+    const XrRaycastInfoANDROID*                 rayInfo,
+    XrRaycastHitResultsANDROID*                 results);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_performance_metrics is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_performance_metrics 1
+#define XR_ANDROID_performance_metrics_SPEC_VERSION 1
+#define XR_ANDROID_PERFORMANCE_METRICS_EXTENSION_NAME "XR_ANDROID_performance_metrics"
+
+typedef enum XrPerformanceMetricsCounterUnitANDROID {
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_ANDROID = 0,
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_ANDROID = 1,
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_ANDROID = 2,
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_ANDROID = 3,
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_ANDROID = 4,
+    XR_PERFORMANCE_METRICS_COUNTER_UNIT_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrPerformanceMetricsCounterUnitANDROID;
+typedef XrFlags64 XrPerformanceMetricsCounterFlagsANDROID;
+
+// Flag bits for XrPerformanceMetricsCounterFlagsANDROID
+static const XrPerformanceMetricsCounterFlagsANDROID XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_ANDROID = 0x00000001;
+static const XrPerformanceMetricsCounterFlagsANDROID XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_ANDROID = 0x00000002;
+static const XrPerformanceMetricsCounterFlagsANDROID XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_ANDROID = 0x00000004;
+
+typedef struct XrPerformanceMetricsStateANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              enabled;
+} XrPerformanceMetricsStateANDROID;
+
+typedef struct XrPerformanceMetricsCounterANDROID {
+    XrStructureType                            type;
+    void* XR_MAY_ALIAS                         next;
+    XrPerformanceMetricsCounterFlagsANDROID    counterFlags;
+    XrPerformanceMetricsCounterUnitANDROID     counterUnit;
+    uint32_t                                   uintValue;
+    float                                      floatValue;
+} XrPerformanceMetricsCounterANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePerformanceMetricsCounterPathsANDROID)(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t* counterPathCountOutput, XrPath* counterPaths);
+typedef XrResult (XRAPI_PTR *PFN_xrSetPerformanceMetricsStateANDROID)(XrSession session, const XrPerformanceMetricsStateANDROID* state);
+typedef XrResult (XRAPI_PTR *PFN_xrGetPerformanceMetricsStateANDROID)(XrSession session, XrPerformanceMetricsStateANDROID* state);
+typedef XrResult (XRAPI_PTR *PFN_xrQueryPerformanceMetricsCounterANDROID)(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterANDROID* counter);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumeratePerformanceMetricsCounterPathsANDROID(
+    XrInstance                                  instance,
+    uint32_t                                    counterPathCapacityInput,
+    uint32_t*                                   counterPathCountOutput,
+    XrPath*                                     counterPaths);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetPerformanceMetricsStateANDROID(
+    XrSession                                   session,
+    const XrPerformanceMetricsStateANDROID*     state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetPerformanceMetricsStateANDROID(
+    XrSession                                   session,
+    XrPerformanceMetricsStateANDROID*           state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrQueryPerformanceMetricsCounterANDROID(
+    XrSession                                   session,
+    XrPath                                      counterPath,
+    XrPerformanceMetricsCounterANDROID*         counter);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_trackables_object is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_trackables_object 1
+#define XR_ANDROID_trackables_object_SPEC_VERSION 2
+#define XR_ANDROID_TRACKABLES_OBJECT_EXTENSION_NAME "XR_ANDROID_trackables_object"
+
+typedef enum XrObjectLabelANDROID {
+    XR_OBJECT_LABEL_UNKNOWN_ANDROID = 0,
+    XR_OBJECT_LABEL_KEYBOARD_ANDROID = 1,
+    XR_OBJECT_LABEL_MOUSE_ANDROID = 2,
+    XR_OBJECT_LABEL_LAPTOP_ANDROID = 3,
+    XR_OBJECT_LABEL_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrObjectLabelANDROID;
+typedef struct XrTrackableObjectANDROID {
+    XrStructureType           type;
+    void* XR_MAY_ALIAS        next;
+    XrTrackingStateANDROID    trackingState;
+    XrPosef                   centerPose;
+    XrExtent3DfEXT            extents;
+    XrObjectLabelANDROID      objectLabel;
+    XrTime                    lastUpdatedTime;
+} XrTrackableObjectANDROID;
+
+// XrTrackableObjectConfigurationANDROID extends XrTrackableTrackerCreateInfoANDROID
+typedef struct XrTrackableObjectConfigurationANDROID {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    uint32_t                       labelCount;
+    const XrObjectLabelANDROID*    activeLabels;
+} XrTrackableObjectConfigurationANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableObjectANDROID)(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID* getInfo, XrTrackableObjectANDROID* objectOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetTrackableObjectANDROID(
+    XrTrackableTrackerANDROID                   tracker,
+    const XrTrackableGetInfoANDROID*            getInfo,
+    XrTrackableObjectANDROID*                   objectOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_unbounded_reference_space is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_unbounded_reference_space 1
+#define XR_ANDROID_unbounded_reference_space_SPEC_VERSION 1
+#define XR_ANDROID_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME "XR_ANDROID_unbounded_reference_space"
+
+
+// XR_EXT_future is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_future 1
+#define XR_EXT_future_SPEC_VERSION        2
+#define XR_EXT_FUTURE_EXTENSION_NAME      "XR_EXT_future"
+#define XR_NULL_FUTURE_EXT                0
+
+typedef enum XrFutureStateEXT {
+    XR_FUTURE_STATE_PENDING_EXT = 1,
+    XR_FUTURE_STATE_READY_EXT = 2,
+    XR_FUTURE_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrFutureStateEXT;
+typedef struct XrFutureCancelInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrFutureEXT                 future;
+} XrFutureCancelInfoEXT;
+
+typedef struct XrFuturePollInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrFutureEXT                 future;
+} XrFuturePollInfoEXT;
+
+typedef struct XR_MAY_ALIAS XrFutureCompletionBaseHeaderEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrResult              futureResult;
+} XrFutureCompletionBaseHeaderEXT;
+
+typedef struct XrFuturePollResultEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrFutureStateEXT      state;
+} XrFuturePollResultEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrPollFutureEXT)(XrInstance instance, const XrFuturePollInfoEXT* pollInfo, XrFuturePollResultEXT* pollResult);
+typedef XrResult (XRAPI_PTR *PFN_xrCancelFutureEXT)(XrInstance instance, const XrFutureCancelInfoEXT* cancelInfo);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrPollFutureEXT(
+    XrInstance                                  instance,
+    const XrFuturePollInfoEXT*                  pollInfo,
+    XrFuturePollResultEXT*                      pollResult);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCancelFutureEXT(
+    XrInstance                                  instance,
+    const XrFutureCancelInfoEXT*                cancelInfo);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_user_presence is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_user_presence 1
+#define XR_EXT_user_presence_SPEC_VERSION 1
+#define XR_EXT_USER_PRESENCE_EXTENSION_NAME "XR_EXT_user_presence"
+typedef struct XrEventDataUserPresenceChangedEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSession                   session;
+    XrBool32                    isUserPresent;
+} XrEventDataUserPresenceChangedEXT;
+
+// XrSystemUserPresencePropertiesEXT extends XrSystemProperties
+typedef struct XrSystemUserPresencePropertiesEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsUserPresence;
+} XrSystemUserPresencePropertiesEXT;
+
+
+
+// XR_ML_user_calibration is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_user_calibration 1
+#define XR_ML_user_calibration_SPEC_VERSION 1
+#define XR_ML_USER_CALIBRATION_EXTENSION_NAME "XR_ML_user_calibration"
+
+typedef enum XrHeadsetFitStatusML {
+    XR_HEADSET_FIT_STATUS_UNKNOWN_ML = 0,
+    XR_HEADSET_FIT_STATUS_NOT_WORN_ML = 1,
+    XR_HEADSET_FIT_STATUS_GOOD_FIT_ML = 2,
+    XR_HEADSET_FIT_STATUS_BAD_FIT_ML = 3,
+    XR_HEADSET_FIT_STATUS_MAX_ENUM_ML = 0x7FFFFFFF
+} XrHeadsetFitStatusML;
+
+typedef enum XrEyeCalibrationStatusML {
+    XR_EYE_CALIBRATION_STATUS_UNKNOWN_ML = 0,
+    XR_EYE_CALIBRATION_STATUS_NONE_ML = 1,
+    XR_EYE_CALIBRATION_STATUS_COARSE_ML = 2,
+    XR_EYE_CALIBRATION_STATUS_FINE_ML = 3,
+    XR_EYE_CALIBRATION_STATUS_MAX_ENUM_ML = 0x7FFFFFFF
+} XrEyeCalibrationStatusML;
+typedef struct XrEventDataHeadsetFitChangedML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrHeadsetFitStatusML        status;
+    XrTime                      time;
+} XrEventDataHeadsetFitChangedML;
+
+typedef struct XrEventDataEyeCalibrationChangedML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrEyeCalibrationStatusML    status;
+} XrEventDataEyeCalibrationChangedML;
+
+typedef struct XrUserCalibrationEnableEventsInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    enabled;
+} XrUserCalibrationEnableEventsInfoML;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnableUserCalibrationEventsML)(XrInstance instance, const XrUserCalibrationEnableEventsInfoML* enableInfo);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnableUserCalibrationEventsML(
+    XrInstance                                  instance,
+    const XrUserCalibrationEnableEventsInfoML*  enableInfo);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ML_system_notifications is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_system_notifications 1
+#define XR_ML_system_notifications_SPEC_VERSION 1
+#define XR_ML_SYSTEM_NOTIFICATIONS_EXTENSION_NAME "XR_ML_system_notifications"
+typedef struct XrSystemNotificationsSetInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    suppressNotifications;
+} XrSystemNotificationsSetInfoML;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSetSystemNotificationsML)(XrInstance instance, const XrSystemNotificationsSetInfoML* info);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetSystemNotificationsML(
+    XrInstance                                  instance,
+    const XrSystemNotificationsSetInfoML*       info);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ML_world_mesh_detection is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_world_mesh_detection 1
+XR_DEFINE_HANDLE(XrWorldMeshDetectorML)
+#define XR_ML_world_mesh_detection_SPEC_VERSION 1
+#define XR_ML_WORLD_MESH_DETECTION_EXTENSION_NAME "XR_ML_world_mesh_detection"
+
+typedef enum XrWorldMeshDetectorLodML {
+    XR_WORLD_MESH_DETECTOR_LOD_MINIMUM_ML = 0,
+    XR_WORLD_MESH_DETECTOR_LOD_MEDIUM_ML = 1,
+    XR_WORLD_MESH_DETECTOR_LOD_MAXIMUM_ML = 2,
+    XR_WORLD_MESH_DETECTOR_LOD_MAX_ENUM_ML = 0x7FFFFFFF
+} XrWorldMeshDetectorLodML;
+
+typedef enum XrWorldMeshBlockStatusML {
+    XR_WORLD_MESH_BLOCK_STATUS_NEW_ML = 0,
+    XR_WORLD_MESH_BLOCK_STATUS_UPDATED_ML = 1,
+    XR_WORLD_MESH_BLOCK_STATUS_DELETED_ML = 2,
+    XR_WORLD_MESH_BLOCK_STATUS_UNCHANGED_ML = 3,
+    XR_WORLD_MESH_BLOCK_STATUS_MAX_ENUM_ML = 0x7FFFFFFF
+} XrWorldMeshBlockStatusML;
+
+typedef enum XrWorldMeshBlockResultML {
+    XR_WORLD_MESH_BLOCK_RESULT_SUCCESS_ML = 0,
+    XR_WORLD_MESH_BLOCK_RESULT_FAILED_ML = 1,
+    XR_WORLD_MESH_BLOCK_RESULT_PENDING_ML = 2,
+    XR_WORLD_MESH_BLOCK_RESULT_PARTIAL_UPDATE_ML = 3,
+    XR_WORLD_MESH_BLOCK_RESULT_MAX_ENUM_ML = 0x7FFFFFFF
+} XrWorldMeshBlockResultML;
+typedef XrFlags64 XrWorldMeshDetectorFlagsML;
+
+// Flag bits for XrWorldMeshDetectorFlagsML
+static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_POINT_CLOUD_BIT_ML = 0x00000001;
+static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_COMPUTE_NORMALS_BIT_ML = 0x00000002;
+static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_COMPUTE_CONFIDENCE_BIT_ML = 0x00000004;
+static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_PLANARIZE_BIT_ML = 0x00000008;
+static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_REMOVE_MESH_SKIRT_BIT_ML = 0x00000010;
+static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_INDEX_ORDER_CW_BIT_ML = 0x00000020;
+
+typedef struct XrWorldMeshDetectorCreateInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrWorldMeshDetectorCreateInfoML;
+
+typedef struct XrWorldMeshBlockStateML {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    XrUuidEXT                   uuid;
+    XrPosef                     meshBoundingBoxCenter;
+    XrExtent3DfEXT              meshBoundingBoxExtents;
+    XrTime                      lastUpdateTime;
+    XrWorldMeshBlockStatusML    status;
+} XrWorldMeshBlockStateML;
+
+typedef struct XrWorldMeshStateRequestInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+    XrPosef                     boundingBoxCenter;
+    XrExtent3DfEXT              boundingBoxExtents;
+} XrWorldMeshStateRequestInfoML;
+
+typedef struct XrWorldMeshStateRequestCompletionML {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    XrResult                    futureResult;
+    XrTime                      timestamp;
+    uint32_t                    meshBlockStateCapacityInput;
+    uint32_t                    meshBlockStateCountOutput;
+    XrWorldMeshBlockStateML*    meshBlockStates;
+} XrWorldMeshStateRequestCompletionML;
+
+typedef struct XrWorldMeshBufferRecommendedSizeInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    maxBlockCount;
+} XrWorldMeshBufferRecommendedSizeInfoML;
+
+typedef struct XrWorldMeshBufferSizeML {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              size;
+} XrWorldMeshBufferSizeML;
+
+typedef struct XrWorldMeshBufferML {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              bufferSize;
+    void* XR_MAY_ALIAS    buffer;
+} XrWorldMeshBufferML;
+
+typedef struct XrWorldMeshBlockRequestML {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    XrUuidEXT                   uuid;
+    XrWorldMeshDetectorLodML    lod;
+} XrWorldMeshBlockRequestML;
+
+typedef struct XrWorldMeshGetInfoML {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrWorldMeshDetectorFlagsML    flags;
+    float                         fillHoleLength;
+    float                         disconnectedComponentArea;
+    uint32_t                      blockCount;
+    XrWorldMeshBlockRequestML*    blocks;
+} XrWorldMeshGetInfoML;
+
+typedef struct XrWorldMeshBlockML {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    XrUuidEXT                     uuid;
+    XrWorldMeshBlockResultML      blockResult;
+    XrWorldMeshDetectorLodML      lod;
+    XrWorldMeshDetectorFlagsML    flags;
+    uint32_t                      indexCount;
+    uint16_t*                     indexBuffer;
+    uint32_t                      vertexCount;
+    XrVector3f*                   vertexBuffer;
+    uint32_t                      normalCount;
+    XrVector3f*                   normalBuffer;
+    uint32_t                      confidenceCount;
+    float*                        confidenceBuffer;
+} XrWorldMeshBlockML;
+
+typedef struct XrWorldMeshRequestCompletionInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     meshSpace;
+    XrTime                      meshSpaceLocateTime;
+} XrWorldMeshRequestCompletionInfoML;
+
+typedef struct XrWorldMeshRequestCompletionML {
+    XrStructureType        type;
+    void* XR_MAY_ALIAS     next;
+    XrResult               futureResult;
+    uint32_t               blockCount;
+    XrWorldMeshBlockML*    blocks;
+} XrWorldMeshRequestCompletionML;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateWorldMeshDetectorML)(XrSession session, const XrWorldMeshDetectorCreateInfoML* createInfo, XrWorldMeshDetectorML* detector);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyWorldMeshDetectorML)(XrWorldMeshDetectorML detector);
+typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshStateAsyncML)(XrWorldMeshDetectorML detector, const XrWorldMeshStateRequestInfoML* stateRequest, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshStateCompleteML)(XrWorldMeshDetectorML detector, XrFutureEXT future, XrWorldMeshStateRequestCompletionML* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrGetWorldMeshBufferRecommendSizeML)(XrWorldMeshDetectorML detector, const XrWorldMeshBufferRecommendedSizeInfoML* sizeInfo, XrWorldMeshBufferSizeML* size);
+typedef XrResult (XRAPI_PTR *PFN_xrAllocateWorldMeshBufferML)(XrWorldMeshDetectorML detector, const XrWorldMeshBufferSizeML* size, XrWorldMeshBufferML* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrFreeWorldMeshBufferML)(XrWorldMeshDetectorML detector, const XrWorldMeshBufferML* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshAsyncML)(XrWorldMeshDetectorML detector, const XrWorldMeshGetInfoML* getInfo, XrWorldMeshBufferML* buffer, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshCompleteML)(XrWorldMeshDetectorML detector, const XrWorldMeshRequestCompletionInfoML* completionInfo, XrFutureEXT future, XrWorldMeshRequestCompletionML* completion);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateWorldMeshDetectorML(
+    XrSession                                   session,
+    const XrWorldMeshDetectorCreateInfoML*      createInfo,
+    XrWorldMeshDetectorML*                      detector);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyWorldMeshDetectorML(
+    XrWorldMeshDetectorML                       detector);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestWorldMeshStateAsyncML(
+    XrWorldMeshDetectorML                       detector,
+    const XrWorldMeshStateRequestInfoML*        stateRequest,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestWorldMeshStateCompleteML(
+    XrWorldMeshDetectorML                       detector,
+    XrFutureEXT                                 future,
+    XrWorldMeshStateRequestCompletionML*        completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetWorldMeshBufferRecommendSizeML(
+    XrWorldMeshDetectorML                       detector,
+    const XrWorldMeshBufferRecommendedSizeInfoML* sizeInfo,
+    XrWorldMeshBufferSizeML*                    size);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrAllocateWorldMeshBufferML(
+    XrWorldMeshDetectorML                       detector,
+    const XrWorldMeshBufferSizeML*              size,
+    XrWorldMeshBufferML*                        buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrFreeWorldMeshBufferML(
+    XrWorldMeshDetectorML                       detector,
+    const XrWorldMeshBufferML*                  buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestWorldMeshAsyncML(
+    XrWorldMeshDetectorML                       detector,
+    const XrWorldMeshGetInfoML*                 getInfo,
+    XrWorldMeshBufferML*                        buffer,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestWorldMeshCompleteML(
+    XrWorldMeshDetectorML                       detector,
+    const XrWorldMeshRequestCompletionInfoML*   completionInfo,
+    XrFutureEXT                                 future,
+    XrWorldMeshRequestCompletionML*             completion);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ML_facial_expression is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_facial_expression 1
+XR_DEFINE_HANDLE(XrFacialExpressionClientML)
+#define XR_ML_facial_expression_SPEC_VERSION 1
+#define XR_ML_FACIAL_EXPRESSION_EXTENSION_NAME "XR_ML_facial_expression"
+
+typedef enum XrFacialBlendShapeML {
+    XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_L_ML = 0,
+    XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_R_ML = 1,
+    XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_L_ML = 2,
+    XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_R_ML = 3,
+    XR_FACIAL_BLEND_SHAPE_CHIN_RAISER_ML = 4,
+    XR_FACIAL_BLEND_SHAPE_DIMPLER_L_ML = 5,
+    XR_FACIAL_BLEND_SHAPE_DIMPLER_R_ML = 6,
+    XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_L_ML = 7,
+    XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_R_ML = 8,
+    XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_L_ML = 9,
+    XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_R_ML = 10,
+    XR_FACIAL_BLEND_SHAPE_JAW_DROP_ML = 11,
+    XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_L_ML = 12,
+    XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_R_ML = 13,
+    XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_L_ML = 14,
+    XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_R_ML = 15,
+    XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_L_ML = 16,
+    XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_R_ML = 17,
+    XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LB_ML = 18,
+    XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LT_ML = 19,
+    XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RB_ML = 20,
+    XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RT_ML = 21,
+    XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_L_ML = 22,
+    XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_R_ML = 23,
+    XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_L_ML = 24,
+    XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_R_ML = 25,
+    XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_L_ML = 26,
+    XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_R_ML = 27,
+    XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LB_ML = 28,
+    XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LT_ML = 29,
+    XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RB_ML = 30,
+    XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RT_ML = 31,
+    XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_L_ML = 32,
+    XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_R_ML = 33,
+    XR_FACIAL_BLEND_SHAPE_LIPS_TOWARD_ML = 34,
+    XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_L_ML = 35,
+    XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_R_ML = 36,
+    XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_L_ML = 37,
+    XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_R_ML = 38,
+    XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_L_ML = 39,
+    XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_R_ML = 40,
+    XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_L_ML = 41,
+    XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_R_ML = 42,
+    XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_L_ML = 43,
+    XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_R_ML = 44,
+    XR_FACIAL_BLEND_SHAPE_TONGUE_OUT_ML = 45,
+    XR_FACIAL_BLEND_SHAPE_MAX_ENUM_ML = 0x7FFFFFFF
+} XrFacialBlendShapeML;
+typedef XrFlags64 XrFacialExpressionBlendShapePropertiesFlagsML;
+
+// Flag bits for XrFacialExpressionBlendShapePropertiesFlagsML
+static const XrFacialExpressionBlendShapePropertiesFlagsML XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_VALID_BIT_ML = 0x00000001;
+static const XrFacialExpressionBlendShapePropertiesFlagsML XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_TRACKED_BIT_ML = 0x00000002;
+
+// XrSystemFacialExpressionPropertiesML extends XrSystemProperties
+typedef struct XrSystemFacialExpressionPropertiesML {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsFacialExpression;
+} XrSystemFacialExpressionPropertiesML;
+
+typedef struct XrFacialExpressionClientCreateInfoML {
+    XrStructureType                type;
+    const void* XR_MAY_ALIAS       next;
+    uint32_t                       requestedCount;
+    const XrFacialBlendShapeML*    requestedFacialBlendShapes;
+} XrFacialExpressionClientCreateInfoML;
+
+typedef struct XrFacialExpressionBlendShapeGetInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrFacialExpressionBlendShapeGetInfoML;
+
+typedef struct XrFacialExpressionBlendShapePropertiesML {
+    XrStructureType                                  type;
+    void* XR_MAY_ALIAS                               next;
+    XrFacialBlendShapeML                             requestedFacialBlendShape;
+    float                                            weight;
+    XrFacialExpressionBlendShapePropertiesFlagsML    flags;
+    XrTime                                           time;
+} XrFacialExpressionBlendShapePropertiesML;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateFacialExpressionClientML)(XrSession session, const XrFacialExpressionClientCreateInfoML* createInfo, XrFacialExpressionClientML* facialExpressionClient);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyFacialExpressionClientML)(XrFacialExpressionClientML facialExpressionClient);
+typedef XrResult (XRAPI_PTR *PFN_xrGetFacialExpressionBlendShapePropertiesML)(XrFacialExpressionClientML facialExpressionClient, const XrFacialExpressionBlendShapeGetInfoML* blendShapeGetInfo, uint32_t blendShapeCount, XrFacialExpressionBlendShapePropertiesML* blendShapes);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateFacialExpressionClientML(
+    XrSession                                   session,
+    const XrFacialExpressionClientCreateInfoML* createInfo,
+    XrFacialExpressionClientML*                 facialExpressionClient);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFacialExpressionClientML(
+    XrFacialExpressionClientML                  facialExpressionClient);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetFacialExpressionBlendShapePropertiesML(
+    XrFacialExpressionClientML                  facialExpressionClient,
+    const XrFacialExpressionBlendShapeGetInfoML* blendShapeGetInfo,
+    uint32_t                                    blendShapeCount,
+    XrFacialExpressionBlendShapePropertiesML*   blendShapes);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ML_view_configuration_depth_range_change is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_view_configuration_depth_range_change 1
+#define XR_ML_view_configuration_depth_range_change_SPEC_VERSION 1
+#define XR_ML_VIEW_CONFIGURATION_DEPTH_RANGE_CHANGE_EXTENSION_NAME "XR_ML_view_configuration_depth_range_change"
+
+
+// XR_YVR_controller_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_YVR_controller_interaction 1
+#define XR_YVR_controller_interaction_SPEC_VERSION 1
+#define XR_YVR_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_YVR_controller_interaction"
+
+
+// XR_META_boundary_visibility is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_boundary_visibility 1
+#define XR_META_boundary_visibility_SPEC_VERSION 1
+#define XR_META_BOUNDARY_VISIBILITY_EXTENSION_NAME "XR_META_boundary_visibility"
+
+typedef enum XrBoundaryVisibilityMETA {
+    XR_BOUNDARY_VISIBILITY_NOT_SUPPRESSED_META = 1,
+    XR_BOUNDARY_VISIBILITY_SUPPRESSED_META = 2,
+    XR_BOUNDARY_VISIBILITY_MAX_ENUM_META = 0x7FFFFFFF
+} XrBoundaryVisibilityMETA;
+// XrSystemBoundaryVisibilityPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemBoundaryVisibilityPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsBoundaryVisibility;
+} XrSystemBoundaryVisibilityPropertiesMETA;
+
+typedef struct XrEventDataBoundaryVisibilityChangedMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBoundaryVisibilityMETA    boundaryVisibility;
+} XrEventDataBoundaryVisibilityChangedMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrRequestBoundaryVisibilityMETA)(XrSession session, XrBoundaryVisibilityMETA boundaryVisibility);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestBoundaryVisibilityMETA(
+    XrSession                                   session,
+    XrBoundaryVisibilityMETA                    boundaryVisibility);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_simultaneous_hands_and_controllers is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_simultaneous_hands_and_controllers 1
+#define XR_META_simultaneous_hands_and_controllers_SPEC_VERSION 1
+#define XR_META_SIMULTANEOUS_HANDS_AND_CONTROLLERS_EXTENSION_NAME "XR_META_simultaneous_hands_and_controllers"
+// XrSystemSimultaneousHandsAndControllersPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemSimultaneousHandsAndControllersPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsSimultaneousHandsAndControllers;
+} XrSystemSimultaneousHandsAndControllersPropertiesMETA;
+
+typedef struct XrSimultaneousHandsAndControllersTrackingResumeInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSimultaneousHandsAndControllersTrackingResumeInfoMETA;
+
+typedef struct XrSimultaneousHandsAndControllersTrackingPauseInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSimultaneousHandsAndControllersTrackingPauseInfoMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrResumeSimultaneousHandsAndControllersTrackingMETA)(XrSession session, const XrSimultaneousHandsAndControllersTrackingResumeInfoMETA* resumeInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrPauseSimultaneousHandsAndControllersTrackingMETA)(XrSession session, const XrSimultaneousHandsAndControllersTrackingPauseInfoMETA* pauseInfo);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrResumeSimultaneousHandsAndControllersTrackingMETA(
+    XrSession                                   session,
+    const XrSimultaneousHandsAndControllersTrackingResumeInfoMETA* resumeInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPauseSimultaneousHandsAndControllersTrackingMETA(
+    XrSession                                   session,
+    const XrSimultaneousHandsAndControllersTrackingPauseInfoMETA* pauseInfo);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_face_tracking_visemes is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_face_tracking_visemes 1
+#define XR_FACE_TRACKING_VISEME_COUNT_META 15
+#define XR_META_face_tracking_visemes_SPEC_VERSION 1
+#define XR_META_FACE_TRACKING_VISEMES_EXTENSION_NAME "XR_META_face_tracking_visemes"
+
+typedef enum XrFaceTrackingVisemeMETA {
+    XR_FACE_TRACKING_VISEME_SIL_META = 0,
+    XR_FACE_TRACKING_VISEME_PP_META = 1,
+    XR_FACE_TRACKING_VISEME_FF_META = 2,
+    XR_FACE_TRACKING_VISEME_TH_META = 3,
+    XR_FACE_TRACKING_VISEME_DD_META = 4,
+    XR_FACE_TRACKING_VISEME_KK_META = 5,
+    XR_FACE_TRACKING_VISEME_CH_META = 6,
+    XR_FACE_TRACKING_VISEME_SS_META = 7,
+    XR_FACE_TRACKING_VISEME_NN_META = 8,
+    XR_FACE_TRACKING_VISEME_RR_META = 9,
+    XR_FACE_TRACKING_VISEME_AA_META = 10,
+    XR_FACE_TRACKING_VISEME_E_META = 11,
+    XR_FACE_TRACKING_VISEME_IH_META = 12,
+    XR_FACE_TRACKING_VISEME_OH_META = 13,
+    XR_FACE_TRACKING_VISEME_OU_META = 14,
+    XR_FACE_TRACKING_VISEME_MAX_ENUM_META = 0x7FFFFFFF
+} XrFaceTrackingVisemeMETA;
+// XrFaceTrackingVisemesMETA extends XrFaceExpressionWeights2FB
+typedef struct XrFaceTrackingVisemesMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    isValid;
+    float                       visemes[XR_FACE_TRACKING_VISEME_COUNT_META];
+} XrFaceTrackingVisemesMETA;
+
+// XrSystemFaceTrackingVisemesPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemFaceTrackingVisemesPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsVisemes;
+} XrSystemFaceTrackingVisemesPropertiesMETA;
+
+
+
+// XR_META_spatial_entity_semantic_label is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_spatial_entity_semantic_label 1
+#define XR_META_spatial_entity_semantic_label_SPEC_VERSION 1
+#define XR_META_SPATIAL_ENTITY_SEMANTIC_LABEL_EXTENSION_NAME "XR_META_spatial_entity_semantic_label"
+
+typedef enum XrSemanticLabelMETA {
+    XR_SEMANTIC_LABEL_UNKNOWN_META = 0,
+    XR_SEMANTIC_LABEL_FLOOR_META = 1,
+    XR_SEMANTIC_LABEL_CEILING_META = 2,
+    XR_SEMANTIC_LABEL_WALL_FACE_META = 3,
+    XR_SEMANTIC_LABEL_INNER_WALL_FACE_META = 4,
+    XR_SEMANTIC_LABEL_INVISIBLE_WALL_FACE_META = 5,
+    XR_SEMANTIC_LABEL_DOOR_FRAME_META = 6,
+    XR_SEMANTIC_LABEL_WINDOW_FRAME_META = 7,
+    XR_SEMANTIC_LABEL_MAX_ENUM_META = 0x7FFFFFFF
+} XrSemanticLabelMETA;
+
+
+// XR_META_spatial_entity_room_mesh is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_spatial_entity_room_mesh 1
+#define XR_META_spatial_entity_room_mesh_SPEC_VERSION 1
+#define XR_META_SPATIAL_ENTITY_ROOM_MESH_EXTENSION_NAME "XR_META_spatial_entity_room_mesh"
+typedef struct XrRoomMeshFaceMETA {
+    XrUuid                 uuid;
+    XrUuid                 parentUuid;
+    XrSemanticLabelMETA    semanticLabel;
+} XrRoomMeshFaceMETA;
+
+typedef struct XrRoomMeshFaceIndicesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              indexCapacityInput;
+    uint32_t              indexCountOutput;
+    uint32_t*             indices;
+} XrRoomMeshFaceIndicesMETA;
+
+typedef struct XrSpaceRoomMeshGetInfoMETA {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    uint32_t                      recognizedSemanticLabelCount;
+    const XrSemanticLabelMETA*    recognizedSemanticLabels;
+} XrSpaceRoomMeshGetInfoMETA;
+
+typedef struct XrRoomMeshMETA {
+    XrStructureType        type;
+    void* XR_MAY_ALIAS     next;
+    uint32_t               vertexCapacityInput;
+    uint32_t               vertexCountOutput;
+    XrVector3f*            vertices;
+    uint32_t               faceCapacityInput;
+    uint32_t               faceCountOutput;
+    XrRoomMeshFaceMETA*    faces;
+} XrRoomMeshMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceRoomMeshMETA)(XrSpace space, const XrSpaceRoomMeshGetInfoMETA* getInfo, XrRoomMeshMETA* roomMeshOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceRoomMeshFaceIndicesMETA)(XrSpace space, const XrUuid* faceUuid, XrRoomMeshFaceIndicesMETA* roomMeshFaceIndicesOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceRoomMeshMETA(
+    XrSpace                                     space,
+    const XrSpaceRoomMeshGetInfoMETA*           getInfo,
+    XrRoomMeshMETA*                             roomMeshOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceRoomMeshFaceIndicesMETA(
+    XrSpace                                     space,
+    const XrUuid*                               faceUuid,
+    XrRoomMeshFaceIndicesMETA*                  roomMeshFaceIndicesOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_composition_layer_inverted_alpha is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_composition_layer_inverted_alpha 1
+#define XR_EXT_composition_layer_inverted_alpha_SPEC_VERSION 1
+#define XR_EXT_COMPOSITION_LAYER_INVERTED_ALPHA_EXTENSION_NAME "XR_EXT_composition_layer_inverted_alpha"
+
+
+// XR_META_colocation_discovery is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_colocation_discovery 1
+#define XR_MAX_COLOCATION_DISCOVERY_BUFFER_SIZE_META 1024
+#define XR_META_colocation_discovery_SPEC_VERSION 1
+#define XR_META_COLOCATION_DISCOVERY_EXTENSION_NAME "XR_META_colocation_discovery"
+typedef struct XrColocationDiscoveryStartInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrColocationDiscoveryStartInfoMETA;
+
+typedef struct XrColocationDiscoveryStopInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrColocationDiscoveryStopInfoMETA;
+
+typedef struct XrColocationAdvertisementStartInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    bufferSize;
+    uint8_t*                    buffer;
+} XrColocationAdvertisementStartInfoMETA;
+
+typedef struct XrColocationAdvertisementStopInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrColocationAdvertisementStopInfoMETA;
+
+typedef struct XrEventDataStartColocationAdvertisementCompleteMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          advertisementRequestId;
+    XrResult                    result;
+    XrUuid                      advertisementUuid;
+} XrEventDataStartColocationAdvertisementCompleteMETA;
+
+typedef struct XrEventDataStopColocationAdvertisementCompleteMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+} XrEventDataStopColocationAdvertisementCompleteMETA;
+
+typedef struct XrEventDataColocationAdvertisementCompleteMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          advertisementRequestId;
+    XrResult                    result;
+} XrEventDataColocationAdvertisementCompleteMETA;
+
+typedef struct XrEventDataStartColocationDiscoveryCompleteMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          discoveryRequestId;
+    XrResult                    result;
+} XrEventDataStartColocationDiscoveryCompleteMETA;
+
+typedef struct XrEventDataColocationDiscoveryResultMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          discoveryRequestId;
+    XrUuid                      advertisementUuid;
+    uint32_t                    bufferSize;
+    uint8_t                     buffer[XR_MAX_COLOCATION_DISCOVERY_BUFFER_SIZE_META];
+} XrEventDataColocationDiscoveryResultMETA;
+
+typedef struct XrEventDataColocationDiscoveryCompleteMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          discoveryRequestId;
+    XrResult                    result;
+} XrEventDataColocationDiscoveryCompleteMETA;
+
+typedef struct XrEventDataStopColocationDiscoveryCompleteMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrAsyncRequestIdFB          requestId;
+    XrResult                    result;
+} XrEventDataStopColocationDiscoveryCompleteMETA;
+
+// XrSystemColocationDiscoveryPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemColocationDiscoveryPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsColocationDiscovery;
+} XrSystemColocationDiscoveryPropertiesMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrStartColocationDiscoveryMETA)(XrSession session, const XrColocationDiscoveryStartInfoMETA* info, XrAsyncRequestIdFB* discoveryRequestId);
+typedef XrResult (XRAPI_PTR *PFN_xrStopColocationDiscoveryMETA)(XrSession session, const XrColocationDiscoveryStopInfoMETA* info, XrAsyncRequestIdFB* requestId);
+typedef XrResult (XRAPI_PTR *PFN_xrStartColocationAdvertisementMETA)(XrSession session, const XrColocationAdvertisementStartInfoMETA* info, XrAsyncRequestIdFB* advertisementRequestId);
+typedef XrResult (XRAPI_PTR *PFN_xrStopColocationAdvertisementMETA)(XrSession session, const XrColocationAdvertisementStopInfoMETA* info, XrAsyncRequestIdFB* requestId);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrStartColocationDiscoveryMETA(
+    XrSession                                   session,
+    const XrColocationDiscoveryStartInfoMETA*   info,
+    XrAsyncRequestIdFB*                         discoveryRequestId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStopColocationDiscoveryMETA(
+    XrSession                                   session,
+    const XrColocationDiscoveryStopInfoMETA*    info,
+    XrAsyncRequestIdFB*                         requestId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStartColocationAdvertisementMETA(
+    XrSession                                   session,
+    const XrColocationAdvertisementStartInfoMETA* info,
+    XrAsyncRequestIdFB*                         advertisementRequestId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrStopColocationAdvertisementMETA(
+    XrSession                                   session,
+    const XrColocationAdvertisementStopInfoMETA* info,
+    XrAsyncRequestIdFB*                         requestId);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_spatial_entity_group_sharing is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_spatial_entity_group_sharing 1
+#define XR_META_spatial_entity_group_sharing_SPEC_VERSION 1
+#define XR_META_SPATIAL_ENTITY_GROUP_SHARING_EXTENSION_NAME "XR_META_spatial_entity_group_sharing"
+// XrSystemSpatialEntityGroupSharingPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemSpatialEntityGroupSharingPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsSpatialEntityGroupSharing;
+} XrSystemSpatialEntityGroupSharingPropertiesMETA;
+
+typedef struct XrShareSpacesRecipientGroupsMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    groupCount;
+    XrUuid*                     groups;
+} XrShareSpacesRecipientGroupsMETA;
+
+// XrSpaceGroupUuidFilterInfoMETA extends XrSpaceQueryInfoBaseHeaderFB
+typedef struct XrSpaceGroupUuidFilterInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrUuid                      groupUuid;
+} XrSpaceGroupUuidFilterInfoMETA;
+
+
+
+// XR_META_environment_raycast is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_environment_raycast 1
+XR_DEFINE_HANDLE(XrEnvironmentRaycasterMETA)
+#define XR_META_environment_raycast_SPEC_VERSION 1
+#define XR_META_ENVIRONMENT_RAYCAST_EXTENSION_NAME "XR_META_environment_raycast"
+
+typedef enum XrEnvironmentRaycastHitStatusMETA {
+    XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_META = 1,
+    XR_ENVIRONMENT_RAYCAST_HIT_STATUS_NO_HIT_META = 2,
+    XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OCCLUDED_META = 3,
+    XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OUTSIDE_OF_FOV_META = 4,
+    XR_ENVIRONMENT_RAYCAST_HIT_STATUS_RAY_OCCLUDED_META = 5,
+    XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_INVALID_ORIENTATION_META = 6,
+    XR_ENVIRONMENT_RAYCAST_HIT_STATUS_MAX_ENUM_META = 0x7FFFFFFF
+} XrEnvironmentRaycastHitStatusMETA;
+// XrSystemEnvironmentRaycastPropertiesMETA extends XrSystemProperties
+typedef struct XrSystemEnvironmentRaycastPropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsEnvironmentRaycast;
+} XrSystemEnvironmentRaycastPropertiesMETA;
+
+typedef struct XrEnvironmentRaycasterCreateInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrEnvironmentRaycasterCreateInfoMETA;
+
+typedef struct XrEnvironmentRaycasterCreateCompletionMETA {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    XrResult                      futureResult;
+    XrEnvironmentRaycasterMETA    environmentRaycaster;
+} XrEnvironmentRaycasterCreateCompletionMETA;
+
+typedef struct XR_MAY_ALIAS XrEnvironmentRaycastFilterBaseHeaderMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrEnvironmentRaycastFilterBaseHeaderMETA;
+
+typedef struct XrEnvironmentRaycastHitGetInfoMETA {
+    XrStructureType                                            type;
+    const void* XR_MAY_ALIAS                                   next;
+    XrSpace                                                    baseSpace;
+    XrTime                                                     time;
+    XrVector3f                                                 origin;
+    XrVector3f                                                 direction;
+    uint32_t                                                   filterCount;
+    const XrEnvironmentRaycastFilterBaseHeaderMETA* const *    filters;
+} XrEnvironmentRaycastHitGetInfoMETA;
+
+typedef struct XrEnvironmentRaycastHitMETA {
+    XrStructureType                      type;
+    const void* XR_MAY_ALIAS             next;
+    XrEnvironmentRaycastHitStatusMETA    status;
+    XrPosef                              pose;
+} XrEnvironmentRaycastHitMETA;
+
+typedef struct XrEnvironmentRaycastFilterDistanceMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       maxDistance;
+} XrEnvironmentRaycastFilterDistanceMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentRaycasterAsyncMETA)(XrSession session, const XrEnvironmentRaycasterCreateInfoMETA* info, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentRaycasterCompleteMETA)(XrSession session, XrFutureEXT future, XrEnvironmentRaycasterCreateCompletionMETA* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentRaycasterMETA)(XrEnvironmentRaycasterMETA environmentRaycaster);
+typedef XrResult (XRAPI_PTR *PFN_xrPerformEnvironmentRaycastMETA)(XrEnvironmentRaycasterMETA environmentRaycaster, const XrEnvironmentRaycastHitGetInfoMETA* info, XrEnvironmentRaycastHitMETA* hitPoint);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateEnvironmentRaycasterAsyncMETA(
+    XrSession                                   session,
+    const XrEnvironmentRaycasterCreateInfoMETA* info,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateEnvironmentRaycasterCompleteMETA(
+    XrSession                                   session,
+    XrFutureEXT                                 future,
+    XrEnvironmentRaycasterCreateCompletionMETA* completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyEnvironmentRaycasterMETA(
+    XrEnvironmentRaycasterMETA                  environmentRaycaster);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPerformEnvironmentRaycastMETA(
+    XrEnvironmentRaycasterMETA                  environmentRaycaster,
+    const XrEnvironmentRaycastHitGetInfoMETA*   info,
+    XrEnvironmentRaycastHitMETA*                hitPoint);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_tile_properties_hint is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_tile_properties_hint 1
+#define XR_META_tile_properties_hint_SPEC_VERSION 1
+#define XR_META_TILE_PROPERTIES_HINT_EXTENSION_NAME "XR_META_tile_properties_hint"
+typedef struct XrExtent3DiMETA {
+    int32_t    width;
+    int32_t    height;
+    int32_t    depth;
+} XrExtent3DiMETA;
+
+typedef struct XrTilePropertiesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrExtent3DiMETA       tileDimensions;
+    XrExtent2Di           apronDimensions;
+    XrOffset2Di           origin;
+} XrTilePropertiesMETA;
+
+typedef struct XrTilePropertiesHintMETA {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    uint32_t                       propertiesCount;
+    const XrTilePropertiesMETA*    properties;
+} XrTilePropertiesHintMETA;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSetTilePropertiesHintMETA)(XrSession session, const XrTilePropertiesHintMETA* properties);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetTilePropertiesHintMETA(
+    XrSession                                   session,
+    const XrTilePropertiesHintMETA*             properties);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_hand_tracking_unextrapolated_poses is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_hand_tracking_unextrapolated_poses 1
+#define XR_META_hand_tracking_unextrapolated_poses_SPEC_VERSION 1
+#define XR_META_HAND_TRACKING_UNEXTRAPOLATED_POSES_EXTENSION_NAME "XR_META_hand_tracking_unextrapolated_poses"
+// XrHandTrackingUnextrapolatedPosesRequestMETA extends XrHandJointsLocateInfoEXT
+typedef struct XrHandTrackingUnextrapolatedPosesRequestMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrHandTrackingUnextrapolatedPosesRequestMETA;
+
+// XrHandTrackingUnextrapolatedPosesMETA extends XrHandJointLocationsEXT
+typedef struct XrHandTrackingUnextrapolatedPosesMETA {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrTime                captureTime;
+} XrHandTrackingUnextrapolatedPosesMETA;
+
+
+
+// XR_META_hand_tracking_frequency_hint is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_hand_tracking_frequency_hint 1
+#define XR_META_hand_tracking_frequency_hint_SPEC_VERSION 1
+#define XR_META_HAND_TRACKING_FREQUENCY_HINT_EXTENSION_NAME "XR_META_hand_tracking_frequency_hint"
+
+typedef enum XrHandTrackingFrequencyHintMETA {
+    XR_HAND_TRACKING_FREQUENCY_HINT_DEFAULT_META = 1,
+    XR_HAND_TRACKING_FREQUENCY_HINT_HIGH_META = 2,
+    XR_HAND_TRACKING_FREQUENCY_HINT_MAX_ENUM_META = 0x7FFFFFFF
+} XrHandTrackingFrequencyHintMETA;
+typedef XrResult (XRAPI_PTR *PFN_xrSetHandTrackingFrequencyHintMETA)(XrSession session, XrHandTrackingFrequencyHintMETA frequencyHint);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetHandTrackingFrequencyHintMETA(
+    XrSession                                   session,
+    XrHandTrackingFrequencyHintMETA             frequencyHint);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_META_hand_tracking_wide_motion_mode2 is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_hand_tracking_wide_motion_mode2 1
+#define XR_META_hand_tracking_wide_motion_mode2_SPEC_VERSION 1
+#define XR_META_HAND_TRACKING_WIDE_MOTION_MODE2_EXTENSION_NAME "XR_META_hand_tracking_wide_motion_mode2"
+
+
+// XR_ANDROID_light_estimation is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_light_estimation 1
+XR_DEFINE_HANDLE(XrLightEstimatorANDROID)
+#define XR_ANDROID_light_estimation_SPEC_VERSION 1
+#define XR_ANDROID_LIGHT_ESTIMATION_EXTENSION_NAME "XR_ANDROID_light_estimation"
+
+typedef enum XrLightEstimateStateANDROID {
+    XR_LIGHT_ESTIMATE_STATE_VALID_ANDROID = 0,
+    XR_LIGHT_ESTIMATE_STATE_INVALID_ANDROID = 1,
+    XR_LIGHT_ESTIMATE_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrLightEstimateStateANDROID;
+
+typedef enum XrSphericalHarmonicsKindANDROID {
+    XR_SPHERICAL_HARMONICS_KIND_TOTAL_ANDROID = 0,
+    XR_SPHERICAL_HARMONICS_KIND_AMBIENT_ANDROID = 1,
+    XR_SPHERICAL_HARMONICS_KIND_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrSphericalHarmonicsKindANDROID;
+// XrSystemLightEstimationPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemLightEstimationPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsLightEstimation;
+} XrSystemLightEstimationPropertiesANDROID;
+
+typedef struct XrLightEstimatorCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrLightEstimatorCreateInfoANDROID;
+
+typedef struct XrLightEstimateGetInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrTime                      time;
+} XrLightEstimateGetInfoANDROID;
+
+typedef struct XrLightEstimateANDROID {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    XrLightEstimateStateANDROID    state;
+    XrTime                         lastUpdatedTime;
+} XrLightEstimateANDROID;
+
+// XrDirectionalLightANDROID extends XrLightEstimateANDROID
+typedef struct XrDirectionalLightANDROID {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    XrLightEstimateStateANDROID    state;
+    XrVector3f                     intensity;
+    XrVector3f                     direction;
+} XrDirectionalLightANDROID;
+
+// XrAmbientLightANDROID extends XrLightEstimateANDROID
+typedef struct XrAmbientLightANDROID {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    XrLightEstimateStateANDROID    state;
+    XrVector3f                     intensity;
+    XrVector3f                     colorCorrection;
+} XrAmbientLightANDROID;
+
+// XrSphericalHarmonicsANDROID extends XrLightEstimateANDROID
+typedef struct XrSphericalHarmonicsANDROID {
+    XrStructureType                    type;
+    void* XR_MAY_ALIAS                 next;
+    XrLightEstimateStateANDROID        state;
+    XrSphericalHarmonicsKindANDROID    kind;
+    float                              coefficients[9][3];
+} XrSphericalHarmonicsANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateLightEstimatorANDROID)(XrSession session, XrLightEstimatorCreateInfoANDROID* createInfo, XrLightEstimatorANDROID* outHandle);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyLightEstimatorANDROID)(XrLightEstimatorANDROID estimator);
+typedef XrResult (XRAPI_PTR *PFN_xrGetLightEstimateANDROID)(XrLightEstimatorANDROID estimator, const XrLightEstimateGetInfoANDROID* input, XrLightEstimateANDROID* output);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateLightEstimatorANDROID(
+    XrSession                                   session,
+    XrLightEstimatorCreateInfoANDROID*          createInfo,
+    XrLightEstimatorANDROID*                    outHandle);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyLightEstimatorANDROID(
+    XrLightEstimatorANDROID                     estimator);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetLightEstimateANDROID(
+    XrLightEstimatorANDROID                     estimator,
+    const XrLightEstimateGetInfoANDROID*        input,
+    XrLightEstimateANDROID*                     output);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_mouse_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_mouse_interaction 1
+#define XR_ANDROID_mouse_interaction_SPEC_VERSION 1
+#define XR_ANDROID_MOUSE_INTERACTION_EXTENSION_NAME "XR_ANDROID_mouse_interaction"
+
+
+// XR_ANDROID_trackables_marker is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_trackables_marker 1
+#define XR_ANDROID_trackables_marker_SPEC_VERSION 1
+#define XR_ANDROID_TRACKABLES_MARKER_EXTENSION_NAME "XR_ANDROID_trackables_marker"
+
+typedef enum XrTrackableMarkerTrackingModeANDROID {
+    XR_TRACKABLE_MARKER_TRACKING_MODE_DYNAMIC_ANDROID = 0,
+    XR_TRACKABLE_MARKER_TRACKING_MODE_STATIC_ANDROID = 1,
+    XR_TRACKABLE_MARKER_TRACKING_MODE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrTrackableMarkerTrackingModeANDROID;
+
+typedef enum XrTrackableMarkerDictionaryANDROID {
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_50_ANDROID = 0,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_100_ANDROID = 1,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_250_ANDROID = 2,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_1000_ANDROID = 3,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_50_ANDROID = 4,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_100_ANDROID = 5,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_250_ANDROID = 6,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_1000_ANDROID = 7,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_50_ANDROID = 8,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_100_ANDROID = 9,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_250_ANDROID = 10,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_1000_ANDROID = 11,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_50_ANDROID = 12,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_100_ANDROID = 13,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_250_ANDROID = 14,
+    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_1000_ANDROID = 15,
+    XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_16H5_ANDROID = 16,
+    XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_25H9_ANDROID = 17,
+    XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H10_ANDROID = 18,
+    XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H11_ANDROID = 19,
+    XR_TRACKABLE_MARKER_DICTIONARY_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrTrackableMarkerDictionaryANDROID;
+// XrSystemMarkerTrackingPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemMarkerTrackingPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsMarkerTracking;
+    XrBool32              supportsMarkerSizeEstimation;
+    uint16_t              maxMarkerCount;
+} XrSystemMarkerTrackingPropertiesANDROID;
+
+typedef struct XrTrackableMarkerDatabaseEntryANDROID {
+    int32_t    id;
+    float      edgeSize;
+} XrTrackableMarkerDatabaseEntryANDROID;
+
+typedef struct XrTrackableMarkerDatabaseANDROID {
+    XrTrackableMarkerDictionaryANDROID              dictionary;
+    uint32_t                                        entryCount;
+    const XrTrackableMarkerDatabaseEntryANDROID*    entries;
+} XrTrackableMarkerDatabaseANDROID;
+
+// XrTrackableMarkerConfigurationANDROID extends XrTrackableTrackerCreateInfoANDROID
+typedef struct XrTrackableMarkerConfigurationANDROID {
+    XrStructureType                            type;
+    void* XR_MAY_ALIAS                         next;
+    XrTrackableMarkerTrackingModeANDROID       trackingMode;
+    uint32_t                                   databaseCount;
+    const XrTrackableMarkerDatabaseANDROID*    databases;
+} XrTrackableMarkerConfigurationANDROID;
+
+typedef struct XrTrackableMarkerANDROID {
+    XrStructureType                       type;
+    void* XR_MAY_ALIAS                    next;
+    XrTrackingStateANDROID                trackingState;
+    XrTime                                lastUpdatedTime;
+    XrTrackableMarkerDictionaryANDROID    dictionary;
+    int32_t                               markerId;
+    XrPosef                               centerPose;
+    XrExtent2Df                           extents;
+} XrTrackableMarkerANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableMarkerANDROID)(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID* getInfo, XrTrackableMarkerANDROID* markerOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetTrackableMarkerANDROID(
+    XrTrackableTrackerANDROID                   tracker,
+    const XrTrackableGetInfoANDROID*            getInfo,
+    XrTrackableMarkerANDROID*                   markerOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_trackables_qr_code is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_trackables_qr_code 1
+#define XR_ANDROID_trackables_qr_code_SPEC_VERSION 1
+#define XR_ANDROID_TRACKABLES_QR_CODE_EXTENSION_NAME "XR_ANDROID_trackables_qr_code"
+
+typedef enum XrQrCodeTrackingModeANDROID {
+    XR_QR_CODE_TRACKING_MODE_DYNAMIC_ANDROID = 0,
+    XR_QR_CODE_TRACKING_MODE_STATIC_ANDROID = 1,
+    XR_QR_CODE_TRACKING_MODE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrQrCodeTrackingModeANDROID;
+// XrSystemQrCodeTrackingPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemQrCodeTrackingPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsQrCodeTracking;
+    XrBool32              supportsQrCodeSizeEstimation;
+    uint16_t              maxQrCodeCount;
+} XrSystemQrCodeTrackingPropertiesANDROID;
+
+// XrTrackableQrCodeConfigurationANDROID extends XrTrackableTrackerCreateInfoANDROID
+typedef struct XrTrackableQrCodeConfigurationANDROID {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    XrQrCodeTrackingModeANDROID    trackingMode;
+    float                          qrCodeEdgeSize;
+} XrTrackableQrCodeConfigurationANDROID;
+
+typedef struct XrTrackableQrCodeANDROID {
+    XrStructureType           type;
+    void* XR_MAY_ALIAS        next;
+    XrTrackingStateANDROID    trackingState;
+    XrTime                    lastUpdatedTime;
+    XrPosef                   centerPose;
+    XrExtent2Df               extents;
+    uint32_t                  bufferCapacityInput;
+    uint32_t                  bufferCountOutput;
+    char*                     buffer;
+} XrTrackableQrCodeANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableQrCodeANDROID)(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID* getInfo, XrTrackableQrCodeANDROID* qrCodeOutput);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetTrackableQrCodeANDROID(
+    XrTrackableTrackerANDROID                   tracker,
+    const XrTrackableGetInfoANDROID*            getInfo,
+    XrTrackableQrCodeANDROID*                   qrCodeOutput);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_trackables_image is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_trackables_image 1
+XR_DEFINE_HANDLE(XrTrackableImageDatabaseANDROID)
+#define XR_ANDROID_trackables_image_SPEC_VERSION 1
+#define XR_ANDROID_TRACKABLES_IMAGE_EXTENSION_NAME "XR_ANDROID_trackables_image"
+
+typedef enum XrTrackableImageTrackingModeANDROID {
+    XR_TRACKABLE_IMAGE_TRACKING_MODE_DYNAMIC_ANDROID = 1,
+    XR_TRACKABLE_IMAGE_TRACKING_MODE_STATIC_ANDROID = 2,
+    XR_TRACKABLE_IMAGE_TRACKING_MODE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrTrackableImageTrackingModeANDROID;
+
+typedef enum XrTrackableImageFormatANDROID {
+    XR_TRACKABLE_IMAGE_FORMAT_R8G8B8A8_ANDROID = 1,
+    XR_TRACKABLE_IMAGE_FORMAT_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrTrackableImageFormatANDROID;
+// XrSystemImageTrackingPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemImageTrackingPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsImageTracking;
+    XrBool32              supportsPhysicalSizeEstimation;
+    uint32_t              maxTrackedImageCount;
+    uint32_t              maxLoadedImageCount;
+} XrSystemImageTrackingPropertiesANDROID;
+
+typedef struct XrTrackableImageDatabaseEntryANDROID {
+    XrStructureType                        type;
+    const void* XR_MAY_ALIAS               next;
+    XrTrackableImageTrackingModeANDROID    trackingMode;
+    float                                  physicalWidth;
+    uint32_t                               imageWidth;
+    uint32_t                               imageHeight;
+    XrTrackableImageFormatANDROID          format;
+    uint32_t                               bufferSize;
+    const uint8_t*                         buffer;
+} XrTrackableImageDatabaseEntryANDROID;
+
+typedef struct XrTrackableImageDatabaseCreateInfoANDROID {
+    XrStructureType                                type;
+    const void* XR_MAY_ALIAS                       next;
+    uint32_t                                       entryCount;
+    const XrTrackableImageDatabaseEntryANDROID*    entries;
+} XrTrackableImageDatabaseCreateInfoANDROID;
+
+typedef struct XrCreateTrackableImageDatabaseCompletionANDROID {
+    XrStructureType                    type;
+    void* XR_MAY_ALIAS                 next;
+    XrResult                           futureResult;
+    XrTrackableImageDatabaseANDROID    database;
+} XrCreateTrackableImageDatabaseCompletionANDROID;
+
+typedef struct XrTrackableImageConfigurationANDROID {
+    XrStructureType                           type;
+    const void* XR_MAY_ALIAS                  next;
+    uint32_t                                  databaseCount;
+    const XrTrackableImageDatabaseANDROID*    databases;
+} XrTrackableImageConfigurationANDROID;
+
+typedef struct XrTrackableImageANDROID {
+    XrStructureType                    type;
+    const void* XR_MAY_ALIAS           next;
+    XrTrackingStateANDROID             trackingState;
+    XrTime                             lastUpdatedTime;
+    XrTrackableImageDatabaseANDROID    database;
+    uint32_t                           databaseEntryIndex;
+    XrPosef                            centerPose;
+    XrExtent2Df                        extents;
+} XrTrackableImageANDROID;
+
+typedef struct XrEventDataImageTrackingLostANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      time;
+} XrEventDataImageTrackingLostANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateTrackableImageDatabaseAsyncANDROID)(XrSession session, const XrTrackableImageDatabaseCreateInfoANDROID* createInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateTrackableImageDatabaseCompleteANDROID)(XrSession session, XrFutureEXT future, XrCreateTrackableImageDatabaseCompletionANDROID* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyTrackableImageDatabaseANDROID)(XrTrackableImageDatabaseANDROID database);
+typedef XrResult (XRAPI_PTR *PFN_xrAddTrackableImageDatabaseANDROID)(XrTrackableTrackerANDROID tracker, XrTrackableImageDatabaseANDROID database);
+typedef XrResult (XRAPI_PTR *PFN_xrRemoveTrackableImageDatabaseANDROID)(XrTrackableTrackerANDROID tracker, XrTrackableImageDatabaseANDROID database);
+typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableImageANDROID)(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID* getInfo, XrTrackableImageANDROID* trackable);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateTrackableImageDatabaseAsyncANDROID(
+    XrSession                                   session,
+    const XrTrackableImageDatabaseCreateInfoANDROID* createInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateTrackableImageDatabaseCompleteANDROID(
+    XrSession                                   session,
+    XrFutureEXT                                 future,
+    XrCreateTrackableImageDatabaseCompletionANDROID* completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyTrackableImageDatabaseANDROID(
+    XrTrackableImageDatabaseANDROID             database);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrAddTrackableImageDatabaseANDROID(
+    XrTrackableTrackerANDROID                   tracker,
+    XrTrackableImageDatabaseANDROID             database);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRemoveTrackableImageDatabaseANDROID(
+    XrTrackableTrackerANDROID                   tracker,
+    XrTrackableImageDatabaseANDROID             database);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetTrackableImageANDROID(
+    XrTrackableTrackerANDROID                   tracker,
+    const XrTrackableGetInfoANDROID*            getInfo,
+    XrTrackableImageANDROID*                    trackable);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_scene_meshing is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_scene_meshing 1
+XR_DEFINE_HANDLE(XrSceneMeshingTrackerANDROID)
+XR_DEFINE_HANDLE(XrSceneMeshSnapshotANDROID)
+#define XR_ANDROID_scene_meshing_SPEC_VERSION 3
+#define XR_ANDROID_SCENE_MESHING_EXTENSION_NAME "XR_ANDROID_scene_meshing"
+
+typedef enum XrSceneMeshSemanticLabelSetANDROID {
+    XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID = 0,
+    XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID = 1,
+    XR_SCENE_MESH_SEMANTIC_LABEL_SET_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrSceneMeshSemanticLabelSetANDROID;
+
+typedef enum XrSceneMeshTrackingStateANDROID {
+    XR_SCENE_MESH_TRACKING_STATE_INITIALIZING_ANDROID = 0,
+    XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID = 1,
+    XR_SCENE_MESH_TRACKING_STATE_WAITING_ANDROID = 2,
+    XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID = 3,
+    XR_SCENE_MESH_TRACKING_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrSceneMeshTrackingStateANDROID;
+
+typedef enum XrSceneMeshSemanticLabelANDROID {
+    XR_SCENE_MESH_SEMANTIC_LABEL_OTHER_ANDROID = 0,
+    XR_SCENE_MESH_SEMANTIC_LABEL_FLOOR_ANDROID = 1,
+    XR_SCENE_MESH_SEMANTIC_LABEL_CEILING_ANDROID = 2,
+    XR_SCENE_MESH_SEMANTIC_LABEL_WALL_ANDROID = 3,
+    XR_SCENE_MESH_SEMANTIC_LABEL_TABLE_ANDROID = 4,
+    XR_SCENE_MESH_SEMANTIC_LABEL_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrSceneMeshSemanticLabelANDROID;
+// XrSystemSceneMeshingPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemSceneMeshingPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsSceneMeshing;
+} XrSystemSceneMeshingPropertiesANDROID;
+
+typedef struct XrSceneMeshingTrackerCreateInfoANDROID {
+    XrStructureType                       type;
+    const void* XR_MAY_ALIAS              next;
+    XrSceneMeshSemanticLabelSetANDROID    semanticLabelSet;
+    XrBool32                              enableNormals;
+} XrSceneMeshingTrackerCreateInfoANDROID;
+
+typedef struct XrSceneMeshSnapshotCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+    XrBoxf                      boundingBox;
+} XrSceneMeshSnapshotCreateInfoANDROID;
+
+typedef struct XrSceneMeshSnapshotCreationResultANDROID {
+    XrStructureType                    type;
+    const void* XR_MAY_ALIAS           next;
+    XrSceneMeshSnapshotANDROID         snapshot;
+    XrSceneMeshTrackingStateANDROID    trackingState;
+} XrSceneMeshSnapshotCreationResultANDROID;
+
+typedef struct XrSceneSubmeshStateANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrUuid                submeshId;
+    XrTime                lastUpdatedTime;
+    XrPosef               submeshPoseInBaseSpace;
+    XrExtent3Df           bounds;
+} XrSceneSubmeshStateANDROID;
+
+typedef struct XrSceneSubmeshDataANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrUuid                      submeshId;
+    uint32_t                    vertexCapacityInput;
+    uint32_t                    vertexCountOutput;
+    XrVector3f*                 vertexPositions;
+    XrVector3f*                 vertexNormals;
+    uint8_t*                    vertexSemantics;
+    uint32_t                    indexCapacityInput;
+    uint32_t                    indexCountOutput;
+    uint32_t*                   indices;
+} XrSceneSubmeshDataANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedSemanticLabelSetsANDROID)(XrInstance instance, XrSystemId systemId, uint32_t supportedSemanticLabelSetsInputCapacity, uint32_t* supportedSemanticLabelSetsOutputCount, XrSceneMeshSemanticLabelSetANDROID* supportedSemanticLabelSets);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneMeshingTrackerANDROID)(XrSession session, const XrSceneMeshingTrackerCreateInfoANDROID* createInfo, XrSceneMeshingTrackerANDROID* tracker);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneMeshingTrackerANDROID)(XrSceneMeshingTrackerANDROID tracker);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneMeshSnapshotANDROID)(XrSceneMeshingTrackerANDROID tracker, const XrSceneMeshSnapshotCreateInfoANDROID* createInfo, XrSceneMeshSnapshotCreationResultANDROID* outSnapshotCreationResult);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneMeshSnapshotANDROID)(XrSceneMeshSnapshotANDROID snapshot);
+typedef XrResult (XRAPI_PTR *PFN_xrGetAllSubmeshStatesANDROID)(XrSceneMeshSnapshotANDROID snapshot, uint32_t submeshStateCapacityInput, uint32_t* submeshStateCountOutput, XrSceneSubmeshStateANDROID* submeshStates);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSubmeshDataANDROID)(XrSceneMeshSnapshotANDROID snapshot, uint32_t submeshDataCount, XrSceneSubmeshDataANDROID* inoutSubmeshData);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedSemanticLabelSetsANDROID(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    supportedSemanticLabelSetsInputCapacity,
+    uint32_t*                                   supportedSemanticLabelSetsOutputCount,
+    XrSceneMeshSemanticLabelSetANDROID*         supportedSemanticLabelSets);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSceneMeshingTrackerANDROID(
+    XrSession                                   session,
+    const XrSceneMeshingTrackerCreateInfoANDROID* createInfo,
+    XrSceneMeshingTrackerANDROID*               tracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySceneMeshingTrackerANDROID(
+    XrSceneMeshingTrackerANDROID                tracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSceneMeshSnapshotANDROID(
+    XrSceneMeshingTrackerANDROID                tracker,
+    const XrSceneMeshSnapshotCreateInfoANDROID* createInfo,
+    XrSceneMeshSnapshotCreationResultANDROID*   outSnapshotCreationResult);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySceneMeshSnapshotANDROID(
+    XrSceneMeshSnapshotANDROID                  snapshot);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetAllSubmeshStatesANDROID(
+    XrSceneMeshSnapshotANDROID                  snapshot,
+    uint32_t                                    submeshStateCapacityInput,
+    uint32_t*                                   submeshStateCountOutput,
+    XrSceneSubmeshStateANDROID*                 submeshStates);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSubmeshDataANDROID(
+    XrSceneMeshSnapshotANDROID                  snapshot,
+    uint32_t                                    submeshDataCount,
+    XrSceneSubmeshDataANDROID*                  inoutSubmeshData);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_spatial_entity is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_spatial_entity 1
+
+#define XR_NULL_SPATIAL_ENTITY_ID_EXT 0
+
+
+#define XR_NULL_SPATIAL_BUFFER_ID_EXT 0
+
+XR_DEFINE_ATOM(XrSpatialEntityIdEXT)
+XR_DEFINE_ATOM(XrSpatialBufferIdEXT)
+XR_DEFINE_HANDLE(XrSpatialEntityEXT)
+XR_DEFINE_HANDLE(XrSpatialContextEXT)
+XR_DEFINE_HANDLE(XrSpatialSnapshotEXT)
+#define XR_EXT_spatial_entity_SPEC_VERSION 1
+#define XR_EXT_SPATIAL_ENTITY_EXTENSION_NAME "XR_EXT_spatial_entity"
+
+typedef enum XrSpatialCapabilityEXT {
+    XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT = 1000741000,
+    XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT = 1000743000,
+    XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT = 1000743001,
+    XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT = 1000743002,
+    XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT = 1000743003,
+    XR_SPATIAL_CAPABILITY_ANCHOR_EXT = 1000762000,
+    XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT = 1000782000,
+    XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_ANDROID = 1000785000,
+    XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID = 1000786000,
+    XR_SPATIAL_CAPABILITY_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialCapabilityEXT;
+
+typedef enum XrSpatialCapabilityFeatureEXT {
+    XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_FIXED_SIZE_MARKERS_EXT = 1000743000,
+    XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_STATIC_MARKERS_EXT = 1000743001,
+    XR_SPATIAL_CAPABILITY_FEATURE_SPHERE_BOUNDS_FILTER_ANDROID = 1000761000,
+    XR_SPATIAL_CAPABILITY_FEATURE_BOX_BOUNDS_FILTER_ANDROID = 1000761001,
+    XR_SPATIAL_CAPABILITY_FEATURE_FRUSTUM_BOUNDS_FILTER_ANDROID = 1000761002,
+    XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT = 1000782000,
+    XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_STATIC_IMAGES_EXT = 1000782001,
+    XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_FIXED_SIZE_IMAGES_EXT = 1000782002,
+    XR_SPATIAL_CAPABILITY_FEATURE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialCapabilityFeatureEXT;
+
+typedef enum XrSpatialComponentTypeEXT {
+    XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT = 1,
+    XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT = 2,
+    XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT = 3,
+    XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT = 4,
+    XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT = 1000741000,
+    XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT = 1000741001,
+    XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT = 1000741002,
+    XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT = 1000741003,
+    XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT = 1000743000,
+    XR_SPATIAL_COMPONENT_TYPE_ANCHOR_EXT = 1000762000,
+    XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_EXT = 1000763000,
+    XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT = 1000782000,
+    XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_ANDROID = 1000785000,
+    XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID = 1000786000,
+    XR_SPATIAL_COMPONENT_TYPE_SUBSUMED_BY_ANDROID = 1000791000,
+    XR_SPATIAL_COMPONENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialComponentTypeEXT;
+
+typedef enum XrSpatialEntityTrackingStateEXT {
+    XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT = 1,
+    XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT = 2,
+    XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT = 3,
+    XR_SPATIAL_ENTITY_TRACKING_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialEntityTrackingStateEXT;
+
+typedef enum XrSpatialBufferTypeEXT {
+    XR_SPATIAL_BUFFER_TYPE_UNKNOWN_EXT = 0,
+    XR_SPATIAL_BUFFER_TYPE_STRING_EXT = 1,
+    XR_SPATIAL_BUFFER_TYPE_UINT8_EXT = 2,
+    XR_SPATIAL_BUFFER_TYPE_UINT16_EXT = 3,
+    XR_SPATIAL_BUFFER_TYPE_UINT32_EXT = 4,
+    XR_SPATIAL_BUFFER_TYPE_FLOAT_EXT = 5,
+    XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT = 6,
+    XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT = 7,
+    XR_SPATIAL_BUFFER_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialBufferTypeEXT;
+typedef struct XrSpatialCapabilityComponentTypesEXT {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    uint32_t                      componentTypeCapacityInput;
+    uint32_t                      componentTypeCountOutput;
+    XrSpatialComponentTypeEXT*    componentTypes;
+} XrSpatialCapabilityComponentTypesEXT;
+
+typedef struct XR_MAY_ALIAS XrSpatialCapabilityConfigurationBaseHeaderEXT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrSpatialCapabilityEXT              capability;
+    uint32_t                            enabledComponentCount;
+    const XrSpatialComponentTypeEXT*    enabledComponents;
+} XrSpatialCapabilityConfigurationBaseHeaderEXT;
+
+typedef struct XrSpatialContextCreateInfoEXT {
+    XrStructureType                                                type;
+    const void* XR_MAY_ALIAS                                       next;
+    uint32_t                                                       capabilityConfigCount;
+    const XrSpatialCapabilityConfigurationBaseHeaderEXT* const*    capabilityConfigs;
+} XrSpatialContextCreateInfoEXT;
+
+typedef struct XrCreateSpatialContextCompletionEXT {
+    XrStructureType        type;
+    void* XR_MAY_ALIAS     next;
+    XrResult               futureResult;
+    XrSpatialContextEXT    spatialContext;
+} XrCreateSpatialContextCompletionEXT;
+
+typedef struct XrSpatialDiscoverySnapshotCreateInfoEXT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    uint32_t                            componentTypeCount;
+    const XrSpatialComponentTypeEXT*    componentTypes;
+} XrSpatialDiscoverySnapshotCreateInfoEXT;
+
+typedef struct XrCreateSpatialDiscoverySnapshotCompletionInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+    XrFutureEXT                 future;
+} XrCreateSpatialDiscoverySnapshotCompletionInfoEXT;
+
+typedef struct XrCreateSpatialDiscoverySnapshotCompletionEXT {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    XrResult                futureResult;
+    XrSpatialSnapshotEXT    snapshot;
+} XrCreateSpatialDiscoverySnapshotCompletionEXT;
+
+typedef struct XrSpatialComponentDataQueryConditionEXT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    uint32_t                            componentTypeCount;
+    const XrSpatialComponentTypeEXT*    componentTypes;
+} XrSpatialComponentDataQueryConditionEXT;
+
+typedef struct XrSpatialComponentDataQueryResultEXT {
+    XrStructureType                     type;
+    void* XR_MAY_ALIAS                  next;
+    uint32_t                            entityIdCapacityInput;
+    uint32_t                            entityIdCountOutput;
+    XrSpatialEntityIdEXT*               entityIds;
+    uint32_t                            entityStateCapacityInput;
+    uint32_t                            entityStateCountOutput;
+    XrSpatialEntityTrackingStateEXT*    entityStates;
+} XrSpatialComponentDataQueryResultEXT;
+
+typedef struct XrSpatialBufferEXT {
+    XrSpatialBufferIdEXT      bufferId;
+    XrSpatialBufferTypeEXT    bufferType;
+} XrSpatialBufferEXT;
+
+typedef struct XrSpatialBufferGetInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialBufferIdEXT        bufferId;
+} XrSpatialBufferGetInfoEXT;
+
+typedef struct XrSpatialBounded2DDataEXT {
+    XrPosef        center;
+    XrExtent2Df    extents;
+} XrSpatialBounded2DDataEXT;
+
+// XrSpatialComponentBounded2DListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentBounded2DListEXT {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    uint32_t                      boundCount;
+    XrSpatialBounded2DDataEXT*    bounds;
+} XrSpatialComponentBounded2DListEXT;
+
+// XrSpatialComponentBounded3DListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentBounded3DListEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              boundCount;
+    XrBoxf*               bounds;
+} XrSpatialComponentBounded3DListEXT;
+
+// XrSpatialComponentParentListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentParentListEXT {
+    XrStructureType          type;
+    void* XR_MAY_ALIAS       next;
+    uint32_t                 parentCount;
+    XrSpatialEntityIdEXT*    parents;
+} XrSpatialComponentParentListEXT;
+
+typedef struct XrSpatialMeshDataEXT {
+    XrPosef               origin;
+    XrSpatialBufferEXT    vertexBuffer;
+    XrSpatialBufferEXT    indexBuffer;
+} XrSpatialMeshDataEXT;
+
+// XrSpatialComponentMesh3DListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentMesh3DListEXT {
+    XrStructureType          type;
+    void* XR_MAY_ALIAS       next;
+    uint32_t                 meshCount;
+    XrSpatialMeshDataEXT*    meshes;
+} XrSpatialComponentMesh3DListEXT;
+
+typedef struct XrSpatialEntityFromIdCreateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialEntityIdEXT        entityId;
+} XrSpatialEntityFromIdCreateInfoEXT;
+
+typedef struct XrSpatialUpdateSnapshotCreateInfoEXT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    uint32_t                            entityCount;
+    const XrSpatialEntityEXT*           entities;
+    uint32_t                            componentTypeCount;
+    const XrSpatialComponentTypeEXT*    componentTypes;
+    XrSpace                             baseSpace;
+    XrTime                              time;
+} XrSpatialUpdateSnapshotCreateInfoEXT;
+
+typedef struct XrEventDataSpatialDiscoveryRecommendedEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialContextEXT         spatialContext;
+} XrEventDataSpatialDiscoveryRecommendedEXT;
+
+// XrSpatialFilterTrackingStateEXT extends XrSpatialDiscoverySnapshotCreateInfoEXT,XrSpatialComponentDataQueryConditionEXT
+typedef struct XrSpatialFilterTrackingStateEXT {
+    XrStructureType                    type;
+    const void* XR_MAY_ALIAS           next;
+    XrSpatialEntityTrackingStateEXT    trackingState;
+} XrSpatialFilterTrackingStateEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialCapabilitiesEXT)(XrInstance instance, XrSystemId systemId, uint32_t capabilityCapacityInput, uint32_t* capabilityCountOutput, XrSpatialCapabilityEXT* capabilities);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialCapabilityComponentTypesEXT)(XrInstance instance, XrSystemId systemId, XrSpatialCapabilityEXT capability, XrSpatialCapabilityComponentTypesEXT* capabilityComponents);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialCapabilityFeaturesEXT)(XrInstance instance, XrSystemId systemId, XrSpatialCapabilityEXT capability, uint32_t capabilityFeatureCapacityInput, uint32_t* capabilityFeatureCountOutput, XrSpatialCapabilityFeatureEXT* capabilityFeatures);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialContextAsyncEXT)(XrSession session, const XrSpatialContextCreateInfoEXT* createInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialContextCompleteEXT)(XrSession session, XrFutureEXT future, XrCreateSpatialContextCompletionEXT* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialContextEXT)(XrSpatialContextEXT spatialContext);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialDiscoverySnapshotAsyncEXT)(XrSpatialContextEXT spatialContext, const XrSpatialDiscoverySnapshotCreateInfoEXT* createInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialDiscoverySnapshotCompleteEXT)(XrSpatialContextEXT spatialContext, const XrCreateSpatialDiscoverySnapshotCompletionInfoEXT* createSnapshotCompletionInfo, XrCreateSpatialDiscoverySnapshotCompletionEXT* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrQuerySpatialComponentDataEXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialComponentDataQueryConditionEXT* queryCondition, XrSpatialComponentDataQueryResultEXT* queryResult);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialSnapshotEXT)(XrSpatialSnapshotEXT snapshot);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialEntityFromIdEXT)(XrSpatialContextEXT spatialContext, const XrSpatialEntityFromIdCreateInfoEXT* createInfo, XrSpatialEntityEXT* spatialEntity);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialEntityEXT)(XrSpatialEntityEXT spatialEntity);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialUpdateSnapshotEXT)(XrSpatialContextEXT spatialContext, const XrSpatialUpdateSnapshotCreateInfoEXT* createInfo, XrSpatialSnapshotEXT* snapshot);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferStringEXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferUint8EXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, uint8_t* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferUint16EXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, uint16_t* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferUint32EXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, uint32_t* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferFloatEXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, float* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferVector2fEXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, XrVector2f* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferVector3fEXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, XrVector3f* buffer);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialCapabilitiesEXT(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    capabilityCapacityInput,
+    uint32_t*                                   capabilityCountOutput,
+    XrSpatialCapabilityEXT*                     capabilities);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialCapabilityComponentTypesEXT(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrSpatialCapabilityEXT                      capability,
+    XrSpatialCapabilityComponentTypesEXT*       capabilityComponents);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialCapabilityFeaturesEXT(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrSpatialCapabilityEXT                      capability,
+    uint32_t                                    capabilityFeatureCapacityInput,
+    uint32_t*                                   capabilityFeatureCountOutput,
+    XrSpatialCapabilityFeatureEXT*              capabilityFeatures);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialContextAsyncEXT(
+    XrSession                                   session,
+    const XrSpatialContextCreateInfoEXT*        createInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialContextCompleteEXT(
+    XrSession                                   session,
+    XrFutureEXT                                 future,
+    XrCreateSpatialContextCompletionEXT*        completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialContextEXT(
+    XrSpatialContextEXT                         spatialContext);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialDiscoverySnapshotAsyncEXT(
+    XrSpatialContextEXT                         spatialContext,
+    const XrSpatialDiscoverySnapshotCreateInfoEXT* createInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialDiscoverySnapshotCompleteEXT(
+    XrSpatialContextEXT                         spatialContext,
+    const XrCreateSpatialDiscoverySnapshotCompletionInfoEXT* createSnapshotCompletionInfo,
+    XrCreateSpatialDiscoverySnapshotCompletionEXT* completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrQuerySpatialComponentDataEXT(
+    XrSpatialSnapshotEXT                        snapshot,
+    const XrSpatialComponentDataQueryConditionEXT* queryCondition,
+    XrSpatialComponentDataQueryResultEXT*       queryResult);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialSnapshotEXT(
+    XrSpatialSnapshotEXT                        snapshot);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialEntityFromIdEXT(
+    XrSpatialContextEXT                         spatialContext,
+    const XrSpatialEntityFromIdCreateInfoEXT*   createInfo,
+    XrSpatialEntityEXT*                         spatialEntity);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialEntityEXT(
+    XrSpatialEntityEXT                          spatialEntity);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialUpdateSnapshotEXT(
+    XrSpatialContextEXT                         spatialContext,
+    const XrSpatialUpdateSnapshotCreateInfoEXT* createInfo,
+    XrSpatialSnapshotEXT*                       snapshot);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferStringEXT(
+    XrSpatialSnapshotEXT                        snapshot,
+    const XrSpatialBufferGetInfoEXT*            info,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    char*                                       buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferUint8EXT(
+    XrSpatialSnapshotEXT                        snapshot,
+    const XrSpatialBufferGetInfoEXT*            info,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    uint8_t*                                    buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferUint16EXT(
+    XrSpatialSnapshotEXT                        snapshot,
+    const XrSpatialBufferGetInfoEXT*            info,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    uint16_t*                                   buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferUint32EXT(
+    XrSpatialSnapshotEXT                        snapshot,
+    const XrSpatialBufferGetInfoEXT*            info,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    uint32_t*                                   buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferFloatEXT(
+    XrSpatialSnapshotEXT                        snapshot,
+    const XrSpatialBufferGetInfoEXT*            info,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    float*                                      buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferVector2fEXT(
+    XrSpatialSnapshotEXT                        snapshot,
+    const XrSpatialBufferGetInfoEXT*            info,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    XrVector2f*                                 buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferVector3fEXT(
+    XrSpatialSnapshotEXT                        snapshot,
+    const XrSpatialBufferGetInfoEXT*            info,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    XrVector3f*                                 buffer);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_spatial_plane_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_spatial_plane_tracking 1
+#define XR_EXT_spatial_plane_tracking_SPEC_VERSION 1
+#define XR_EXT_SPATIAL_PLANE_TRACKING_EXTENSION_NAME "XR_EXT_spatial_plane_tracking"
+
+typedef enum XrSpatialPlaneAlignmentEXT {
+    XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_UPWARD_EXT = 0,
+    XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_DOWNWARD_EXT = 1,
+    XR_SPATIAL_PLANE_ALIGNMENT_VERTICAL_EXT = 2,
+    XR_SPATIAL_PLANE_ALIGNMENT_ARBITRARY_EXT = 3,
+    XR_SPATIAL_PLANE_ALIGNMENT_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialPlaneAlignmentEXT;
+
+typedef enum XrSpatialPlaneSemanticLabelEXT {
+    XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT = 1,
+    XR_SPATIAL_PLANE_SEMANTIC_LABEL_FLOOR_EXT = 2,
+    XR_SPATIAL_PLANE_SEMANTIC_LABEL_WALL_EXT = 3,
+    XR_SPATIAL_PLANE_SEMANTIC_LABEL_CEILING_EXT = 4,
+    XR_SPATIAL_PLANE_SEMANTIC_LABEL_TABLE_EXT = 5,
+    XR_SPATIAL_PLANE_SEMANTIC_LABEL_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialPlaneSemanticLabelEXT;
+typedef struct XrSpatialCapabilityConfigurationPlaneTrackingEXT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrSpatialCapabilityEXT              capability;
+    uint32_t                            enabledComponentCount;
+    const XrSpatialComponentTypeEXT*    enabledComponents;
+} XrSpatialCapabilityConfigurationPlaneTrackingEXT;
+
+// XrSpatialComponentPlaneAlignmentListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentPlaneAlignmentListEXT {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    uint32_t                       planeAlignmentCount;
+    XrSpatialPlaneAlignmentEXT*    planeAlignments;
+} XrSpatialComponentPlaneAlignmentListEXT;
+
+// XrSpatialComponentMesh2DListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentMesh2DListEXT {
+    XrStructureType          type;
+    void* XR_MAY_ALIAS       next;
+    uint32_t                 meshCount;
+    XrSpatialMeshDataEXT*    meshes;
+} XrSpatialComponentMesh2DListEXT;
+
+typedef struct XrSpatialPolygon2DDataEXT {
+    XrPosef               origin;
+    XrSpatialBufferEXT    vertexBuffer;
+} XrSpatialPolygon2DDataEXT;
+
+// XrSpatialComponentPolygon2DListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentPolygon2DListEXT {
+    XrStructureType               type;
+    void* XR_MAY_ALIAS            next;
+    uint32_t                      polygonCount;
+    XrSpatialPolygon2DDataEXT*    polygons;
+} XrSpatialComponentPolygon2DListEXT;
+
+// XrSpatialComponentPlaneSemanticLabelListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentPlaneSemanticLabelListEXT {
+    XrStructureType                    type;
+    void* XR_MAY_ALIAS                 next;
+    uint32_t                           semanticLabelCount;
+    XrSpatialPlaneSemanticLabelEXT*    semanticLabels;
+} XrSpatialComponentPlaneSemanticLabelListEXT;
+
+
+
+// XR_EXT_stationary_reference_space is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_stationary_reference_space 1
+#define XR_EXT_stationary_reference_space_SPEC_VERSION 1
+#define XR_EXT_STATIONARY_REFERENCE_SPACE_EXTENSION_NAME "XR_EXT_stationary_reference_space"
+typedef struct XrStationaryReferenceSpaceGenerationIdGetInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrStationaryReferenceSpaceGenerationIdGetInfoEXT;
+
+typedef struct XrStationaryReferenceSpaceGenerationIdResultEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrUuid                generationId;
+} XrStationaryReferenceSpaceGenerationIdResultEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetStationaryReferenceSpaceGenerationIdEXT)(XrSession session, const XrStationaryReferenceSpaceGenerationIdGetInfoEXT* getInfo, XrStationaryReferenceSpaceGenerationIdResultEXT* generationIdResult);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetStationaryReferenceSpaceGenerationIdEXT(
+    XrSession                                   session,
+    const XrStationaryReferenceSpaceGenerationIdGetInfoEXT* getInfo,
+    XrStationaryReferenceSpaceGenerationIdResultEXT* generationIdResult);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_spatial_marker_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_spatial_marker_tracking 1
+#define XR_EXT_spatial_marker_tracking_SPEC_VERSION 1
+#define XR_EXT_SPATIAL_MARKER_TRACKING_EXTENSION_NAME "XR_EXT_spatial_marker_tracking"
+
+typedef enum XrSpatialMarkerArucoDictEXT {
+    XR_SPATIAL_MARKER_ARUCO_DICT_4X4_50_EXT = 1,
+    XR_SPATIAL_MARKER_ARUCO_DICT_4X4_100_EXT = 2,
+    XR_SPATIAL_MARKER_ARUCO_DICT_4X4_250_EXT = 3,
+    XR_SPATIAL_MARKER_ARUCO_DICT_4X4_1000_EXT = 4,
+    XR_SPATIAL_MARKER_ARUCO_DICT_5X5_50_EXT = 5,
+    XR_SPATIAL_MARKER_ARUCO_DICT_5X5_100_EXT = 6,
+    XR_SPATIAL_MARKER_ARUCO_DICT_5X5_250_EXT = 7,
+    XR_SPATIAL_MARKER_ARUCO_DICT_5X5_1000_EXT = 8,
+    XR_SPATIAL_MARKER_ARUCO_DICT_6X6_50_EXT = 9,
+    XR_SPATIAL_MARKER_ARUCO_DICT_6X6_100_EXT = 10,
+    XR_SPATIAL_MARKER_ARUCO_DICT_6X6_250_EXT = 11,
+    XR_SPATIAL_MARKER_ARUCO_DICT_6X6_1000_EXT = 12,
+    XR_SPATIAL_MARKER_ARUCO_DICT_7X7_50_EXT = 13,
+    XR_SPATIAL_MARKER_ARUCO_DICT_7X7_100_EXT = 14,
+    XR_SPATIAL_MARKER_ARUCO_DICT_7X7_250_EXT = 15,
+    XR_SPATIAL_MARKER_ARUCO_DICT_7X7_1000_EXT = 16,
+    XR_SPATIAL_MARKER_ARUCO_DICT_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialMarkerArucoDictEXT;
+
+typedef enum XrSpatialMarkerAprilTagDictEXT {
+    XR_SPATIAL_MARKER_APRIL_TAG_DICT_16H5_EXT = 1,
+    XR_SPATIAL_MARKER_APRIL_TAG_DICT_25H9_EXT = 2,
+    XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H10_EXT = 3,
+    XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H11_EXT = 4,
+    XR_SPATIAL_MARKER_APRIL_TAG_DICT_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialMarkerAprilTagDictEXT;
+typedef struct XrSpatialCapabilityConfigurationQrCodeEXT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrSpatialCapabilityEXT              capability;
+    uint32_t                            enabledComponentCount;
+    const XrSpatialComponentTypeEXT*    enabledComponents;
+} XrSpatialCapabilityConfigurationQrCodeEXT;
+
+typedef struct XrSpatialCapabilityConfigurationMicroQrCodeEXT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrSpatialCapabilityEXT              capability;
+    uint32_t                            enabledComponentCount;
+    const XrSpatialComponentTypeEXT*    enabledComponents;
+} XrSpatialCapabilityConfigurationMicroQrCodeEXT;
+
+typedef struct XrSpatialCapabilityConfigurationArucoMarkerEXT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrSpatialCapabilityEXT              capability;
+    uint32_t                            enabledComponentCount;
+    const XrSpatialComponentTypeEXT*    enabledComponents;
+    XrSpatialMarkerArucoDictEXT         arUcoDict;
+} XrSpatialCapabilityConfigurationArucoMarkerEXT;
+
+typedef struct XrSpatialCapabilityConfigurationAprilTagEXT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrSpatialCapabilityEXT              capability;
+    uint32_t                            enabledComponentCount;
+    const XrSpatialComponentTypeEXT*    enabledComponents;
+    XrSpatialMarkerAprilTagDictEXT      aprilDict;
+} XrSpatialCapabilityConfigurationAprilTagEXT;
+
+// XrSpatialMarkerSizeEXT extends XrSpatialCapabilityConfigurationArucoMarkerEXT,XrSpatialCapabilityConfigurationAprilTagEXT,XrSpatialCapabilityConfigurationQrCodeEXT,XrSpatialCapabilityConfigurationMicroQrCodeEXT
+typedef struct XrSpatialMarkerSizeEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       markerSideLength;
+} XrSpatialMarkerSizeEXT;
+
+// XrSpatialMarkerStaticOptimizationEXT extends XrSpatialCapabilityConfigurationArucoMarkerEXT,XrSpatialCapabilityConfigurationAprilTagEXT,XrSpatialCapabilityConfigurationQrCodeEXT,XrSpatialCapabilityConfigurationMicroQrCodeEXT
+typedef struct XrSpatialMarkerStaticOptimizationEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    optimizeForStaticMarker;
+} XrSpatialMarkerStaticOptimizationEXT;
+
+typedef struct XrSpatialMarkerDataEXT {
+    XrSpatialCapabilityEXT    capability;
+    uint32_t                  markerId;
+    XrSpatialBufferEXT        data;
+} XrSpatialMarkerDataEXT;
+
+// XrSpatialComponentMarkerListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentMarkerListEXT {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    uint32_t                   markerCount;
+    XrSpatialMarkerDataEXT*    markers;
+} XrSpatialComponentMarkerListEXT;
+
+
+
+// XR_LOGITECH_mx_ink_stylus_interaction is a preprocessor guard. Do not pass it to API calls.
+#define XR_LOGITECH_mx_ink_stylus_interaction 1
+#define XR_LOGITECH_mx_ink_stylus_interaction_SPEC_VERSION 1
+#define XR_LOGITECH_MX_INK_STYLUS_INTERACTION_EXTENSION_NAME "XR_LOGITECH_mx_ink_stylus_interaction"
+
+
+// XR_BD_dynamic_object_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_dynamic_object_tracking 1
+#define XR_BD_dynamic_object_tracking_SPEC_VERSION 1
+#define XR_BD_DYNAMIC_OBJECT_TRACKING_EXTENSION_NAME "XR_BD_dynamic_object_tracking"
+
+typedef enum XrDynamicObjectTypeBD {
+    XR_DYNAMIC_OBJECT_TYPE_UNKNOWN_BD = 0,
+    XR_DYNAMIC_OBJECT_TYPE_KEYBOARD_BD = 1000747000,
+    XR_DYNAMIC_OBJECT_TYPE_MOUSE_BD = 1000748000,
+    XR_DYNAMIC_OBJECT_TYPE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrDynamicObjectTypeBD;
+// XrSystemDynamicObjectTrackingPropertiesBD extends XrSystemProperties
+typedef struct XrSystemDynamicObjectTrackingPropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsDynamicObjectTracking;
+} XrSystemDynamicObjectTrackingPropertiesBD;
+
+// XrSenseDataProviderCreateInfoDynamicObjectBD extends XrSenseDataProviderCreateInfoBD
+typedef struct XrSenseDataProviderCreateInfoDynamicObjectBD {
+    XrStructureType                 type;
+    const void* XR_MAY_ALIAS        next;
+    uint32_t                        trackingTypeCount;
+    const XrDynamicObjectTypeBD*    trackingTypes;
+} XrSenseDataProviderCreateInfoDynamicObjectBD;
+
+typedef struct XrDynamicObjectDataBD {
+    XrStructureType          type;
+    void* XR_MAY_ALIAS       next;
+    XrDynamicObjectTypeBD    objectType;
+} XrDynamicObjectDataBD;
+
+// XrSpatialEntityComponentDataDynamicObjectBD extends XrSpatialEntityComponentDataBaseHeaderBD
+typedef struct XrSpatialEntityComponentDataDynamicObjectBD {
+    XrStructureType          type;
+    void* XR_MAY_ALIAS       next;
+    XrDynamicObjectDataBD    data;
+} XrSpatialEntityComponentDataDynamicObjectBD;
+
+// XrSenseDataFilterDynamicObjectTypeBD extends XrSenseDataQueryInfoBD
+typedef struct XrSenseDataFilterDynamicObjectTypeBD {
+    XrStructureType                 type;
+    const void* XR_MAY_ALIAS        next;
+    uint32_t                        typeCount;
+    const XrDynamicObjectTypeBD*    types;
+} XrSenseDataFilterDynamicObjectTypeBD;
+
+
+
+// XR_BD_dynamic_object_keyboard is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_dynamic_object_keyboard 1
+#define XR_BD_dynamic_object_keyboard_SPEC_VERSION 1
+#define XR_BD_DYNAMIC_OBJECT_KEYBOARD_EXTENSION_NAME "XR_BD_dynamic_object_keyboard"
+// XrSystemDynamicObjectKeyboardPropertiesBD extends XrSystemProperties
+typedef struct XrSystemDynamicObjectKeyboardPropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsDynamicObjectKeyboard;
+} XrSystemDynamicObjectKeyboardPropertiesBD;
+
+
+
+// XR_BD_dynamic_object_mouse is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_dynamic_object_mouse 1
+#define XR_BD_dynamic_object_mouse_SPEC_VERSION 1
+#define XR_BD_DYNAMIC_OBJECT_MOUSE_EXTENSION_NAME "XR_BD_dynamic_object_mouse"
+// XrSystemDynamicObjectMousePropertiesBD extends XrSystemProperties
+typedef struct XrSystemDynamicObjectMousePropertiesBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsDynamicObjectMouse;
+} XrSystemDynamicObjectMousePropertiesBD;
+
+
+
+// XR_BD_camera_image is a preprocessor guard. Do not pass it to API calls.
+#define XR_BD_camera_image 1
+XR_DEFINE_ATOM(XrCameraIdBD)
+XR_DEFINE_ATOM(XrCameraImageIdBD)
+XR_DEFINE_HANDLE(XrCameraDeviceBD)
+XR_DEFINE_HANDLE(XrCameraCaptureSessionBD)
+#define XR_BD_camera_image_SPEC_VERSION   1
+#define XR_BD_CAMERA_IMAGE_EXTENSION_NAME "XR_BD_camera_image"
+
+typedef enum XrCameraPropertyTypeBD {
+    XR_CAMERA_PROPERTY_TYPE_FACING_BD = 1,
+    XR_CAMERA_PROPERTY_TYPE_POSITION_BD = 2,
+    XR_CAMERA_PROPERTY_TYPE_CAMERA_TYPE_BD = 3,
+    XR_CAMERA_PROPERTY_TYPE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrCameraPropertyTypeBD;
+
+typedef enum XrCameraFacingBD {
+    XR_CAMERA_FACING_WORLD_BD = 1,
+    XR_CAMERA_FACING_MAX_ENUM_BD = 0x7FFFFFFF
+} XrCameraFacingBD;
+
+typedef enum XrCameraPositionBD {
+    XR_CAMERA_POSITION_UNSPECIFIED_BD = 1,
+    XR_CAMERA_POSITION_LEFT_BD = 2,
+    XR_CAMERA_POSITION_RIGHT_BD = 3,
+    XR_CAMERA_POSITION_MAX_ENUM_BD = 0x7FFFFFFF
+} XrCameraPositionBD;
+
+typedef enum XrCameraTypeBD {
+    XR_CAMERA_TYPE_PASSTHROUGH_COLOR_BD = 1,
+    XR_CAMERA_TYPE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrCameraTypeBD;
+
+typedef enum XrCameraCapabilityTypeBD {
+    XR_CAMERA_CAPABILITY_TYPE_IMAGE_RESOLUTION_AND_FRAME_RATE_BD = 1,
+    XR_CAMERA_CAPABILITY_TYPE_IMAGE_FORMAT_BD = 2,
+    XR_CAMERA_CAPABILITY_TYPE_DATA_TRANSFER_TYPE_BD = 3,
+    XR_CAMERA_CAPABILITY_TYPE_CAMERA_MODEL_BD = 4,
+    XR_CAMERA_CAPABILITY_TYPE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrCameraCapabilityTypeBD;
+
+typedef enum XrCameraDataTransferTypeBD {
+    XR_CAMERA_DATA_TRANSFER_TYPE_RAW_BUFFER_BD = 1,
+    XR_CAMERA_DATA_TRANSFER_TYPE_MAX_ENUM_BD = 0x7FFFFFFF
+} XrCameraDataTransferTypeBD;
+
+typedef enum XrCameraImageFormatBD {
+    XR_CAMERA_IMAGE_FORMAT_RGBA_8888_BD = 1,
+    XR_CAMERA_IMAGE_FORMAT_MAX_ENUM_BD = 0x7FFFFFFF
+} XrCameraImageFormatBD;
+
+typedef enum XrCameraModelBD {
+    XR_CAMERA_MODEL_PINHOLE_BD = 1,
+    XR_CAMERA_MODEL_MAX_ENUM_BD = 0x7FFFFFFF
+} XrCameraModelBD;
+typedef struct XR_MAY_ALIAS XrCameraPropertyBaseHeaderBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrCameraPropertyBaseHeaderBD;
+
+typedef struct XrCameraPropertiesBD {
+    XrStructureType                   type;
+    void* XR_MAY_ALIAS                next;
+    uint32_t                          propertyCount;
+    XrCameraPropertyBaseHeaderBD**    properties;
+} XrCameraPropertiesBD;
+
+typedef struct XR_MAY_ALIAS XrCameraCapabilityBaseHeaderBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrCameraCapabilityBaseHeaderBD;
+
+typedef struct XrCameraCapabilitiesBD {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    uint32_t                            capabilityCount;
+    XrCameraCapabilityBaseHeaderBD**    capabilities;
+} XrCameraCapabilitiesBD;
+
+typedef struct XrAvailableCamerasEnumerateInfoBD {
+    XrStructureType                  type;
+    const void* XR_MAY_ALIAS         next;
+    const XrCameraPropertiesBD*      properties;
+    const XrCameraCapabilitiesBD*    capabilities;
+} XrAvailableCamerasEnumerateInfoBD;
+
+typedef struct XrAvailableCameraBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrCameraIdBD          cameraId;
+} XrAvailableCameraBD;
+
+typedef struct XrCameraPropertyTypesEnumerateInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCameraIdBD                cameraId;
+} XrCameraPropertyTypesEnumerateInfoBD;
+
+typedef struct XrCameraPropertyTypesBD {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    uint32_t                   propertyTypeCapacityInput;
+    uint32_t                   propertyTypeCountOutput;
+    XrCameraPropertyTypeBD*    propertyTypes;
+} XrCameraPropertyTypesBD;
+
+typedef struct XrCameraPropertiesGetInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCameraIdBD                cameraId;
+} XrCameraPropertiesGetInfoBD;
+
+typedef struct XrCameraPropertyFacingBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCameraFacingBD            facing;
+} XrCameraPropertyFacingBD;
+
+typedef struct XrCameraPropertyPositionBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCameraPositionBD          position;
+} XrCameraPropertyPositionBD;
+
+typedef struct XrCameraPropertyCameraTypeBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCameraTypeBD              cameraType;
+} XrCameraPropertyCameraTypeBD;
+
+typedef struct XrCameraCapabilityTypesEnumerateInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCameraIdBD                cameraId;
+} XrCameraCapabilityTypesEnumerateInfoBD;
+
+typedef struct XrCameraCapabilityTypesBD {
+    XrStructureType              type;
+    void* XR_MAY_ALIAS           next;
+    uint32_t                     capabilityTypeCapacityInput;
+    uint32_t                     capabilityTypeCountOutput;
+    XrCameraCapabilityTypeBD*    capabilityTypes;
+} XrCameraCapabilityTypesBD;
+
+typedef struct XrCameraSupportedCapabilitiesGetInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCameraIdBD                id;
+} XrCameraSupportedCapabilitiesGetInfoBD;
+
+typedef struct XR_MAY_ALIAS XrCameraSupportedCapabilityBaseHeaderBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+} XrCameraSupportedCapabilityBaseHeaderBD;
+
+typedef struct XrCameraSupportedCapabilitiesBD {
+    XrStructureType                              type;
+    void* XR_MAY_ALIAS                           next;
+    uint32_t                                     capabilityCount;
+    XrCameraSupportedCapabilityBaseHeaderBD**    capabilities;
+} XrCameraSupportedCapabilitiesBD;
+
+typedef struct XrCameraImageResolutionAndFrameRateBD {
+    XrExtent2Di    resolution;
+    uint32_t       frameRate;
+} XrCameraImageResolutionAndFrameRateBD;
+
+typedef struct XrCameraSupportedCapabilityImageResolutionAndFrameRateBD {
+    XrStructureType                           type;
+    void* XR_MAY_ALIAS                        next;
+    uint32_t                                  resolutionAndFrameRateCapacityInput;
+    uint32_t                                  resolutionAndFrameRateCountOutput;
+    XrCameraImageResolutionAndFrameRateBD*    resolutionAndFrameRates;
+} XrCameraSupportedCapabilityImageResolutionAndFrameRateBD;
+
+typedef struct XrCameraCapabilityImageResolutionAndFrameRateBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrExtent2Di                 resolution;
+    uint32_t                    frameRate;
+} XrCameraCapabilityImageResolutionAndFrameRateBD;
+
+typedef struct XrCameraSupportedCapabilityDataTransferTypeBD {
+    XrStructureType                type;
+    void* XR_MAY_ALIAS             next;
+    uint32_t                       transferTypeCapacityInput;
+    uint32_t                       transferTypeCountOutput;
+    XrCameraDataTransferTypeBD*    transferTypes;
+} XrCameraSupportedCapabilityDataTransferTypeBD;
+
+typedef struct XrCameraCapabilityDataTransferTypeBD {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrCameraDataTransferTypeBD    transferType;
+} XrCameraCapabilityDataTransferTypeBD;
+
+typedef struct XrCameraSupportedCapabilityImageFormatBD {
+    XrStructureType           type;
+    void* XR_MAY_ALIAS        next;
+    uint32_t                  formatCapacityInput;
+    uint32_t                  formatCountOutput;
+    XrCameraImageFormatBD*    formats;
+} XrCameraSupportedCapabilityImageFormatBD;
+
+typedef struct XrCameraCapabilityImageFormatBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCameraImageFormatBD       format;
+} XrCameraCapabilityImageFormatBD;
+
+typedef struct XrCameraSupportedCapabilityCameraModelBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              modelCapacityInput;
+    uint32_t              modelCountOutput;
+    XrCameraModelBD*      models;
+} XrCameraSupportedCapabilityCameraModelBD;
+
+typedef struct XrCameraCapabilityCameraModelBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCameraModelBD             model;
+} XrCameraCapabilityCameraModelBD;
+
+typedef struct XrCameraDeviceCreateInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrCameraIdBD                cameraId;
+} XrCameraDeviceCreateInfoBD;
+
+typedef struct XrCreateCameraDeviceCompletionBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrResult              futureResult;
+    XrCameraDeviceBD      device;
+} XrCreateCameraDeviceCompletionBD;
+
+typedef struct XrCameraCaptureSessionCreateInfoBD {
+    XrStructureType                                 type;
+    const void* XR_MAY_ALIAS                        next;
+    XrCameraDeviceBD                                camera;
+    uint32_t                                        configCount;
+    const XrCameraCapabilityBaseHeaderBD* const*    configs;
+} XrCameraCaptureSessionCreateInfoBD;
+
+typedef struct XrCreateCameraCaptureSessionCompletionBD {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    XrResult                    futureResult;
+    XrCameraCaptureSessionBD    captureSession;
+} XrCreateCameraCaptureSessionCompletionBD;
+
+// XrCameraIntrinsicsBD extends XrCameraImageDataBaseHeaderBD
+typedef struct XrCameraIntrinsicsBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrVector2f            focalLength;
+    XrVector2f            principalPoint;
+    XrVector2f            fov;
+} XrCameraIntrinsicsBD;
+
+// XrCameraExtrinsicsBD extends XrCameraImageDataBaseHeaderBD
+typedef struct XrCameraExtrinsicsBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrPosef               pose;
+} XrCameraExtrinsicsBD;
+
+typedef struct XrCameraCaptureBeginInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrCameraCaptureBeginInfoBD;
+
+typedef struct XrCameraImageAcquireInfoBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrTime                      lastCaptureTime;
+} XrCameraImageAcquireInfoBD;
+
+typedef struct XrCameraImageBD {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    available;
+    XrTime                      captureTime;
+    XrCameraImageIdBD           imageId;
+} XrCameraImageBD;
+
+typedef struct XR_MAY_ALIAS XrCameraImageDataBaseHeaderBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+} XrCameraImageDataBaseHeaderBD;
+
+typedef struct XrCameraImageDataRawBufferBD {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              width;
+    uint32_t              height;
+    uint32_t              stride;
+    uint32_t              bytesPerPixel;
+    uint32_t              pixelStride;
+    uint32_t              bufferSize;
+    uint8_t*              buffer;
+} XrCameraImageDataRawBufferBD;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateAvailableCamerasBD)(XrInstance instance, const XrAvailableCamerasEnumerateInfoBD* enumerateInfo, uint32_t cameraCapacityInput, uint32_t* cameraCountOutput, XrAvailableCameraBD* cameras);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateCameraPropertyTypesBD)(XrInstance instance, const XrCameraPropertyTypesEnumerateInfoBD* enumerateInfo, XrCameraPropertyTypesBD* propertyTypes);
+typedef XrResult (XRAPI_PTR *PFN_xrGetCameraPropertiesBD)(XrInstance instance, const XrCameraPropertiesGetInfoBD* getInfo, XrCameraPropertiesBD* properties);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateCameraCapabilityTypesBD)(XrInstance instance, const XrCameraCapabilityTypesEnumerateInfoBD* enumerateInfo, XrCameraCapabilityTypesBD* capabilityTypes);
+typedef XrResult (XRAPI_PTR *PFN_xrGetCameraSupportedCapabilitiesBD)(XrInstance instance, const XrCameraSupportedCapabilitiesGetInfoBD* getInfo, XrCameraSupportedCapabilitiesBD* capabilities);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateCameraDeviceAsyncBD)(XrInstance instance, const XrCameraDeviceCreateInfoBD* createInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateCameraDeviceCompleteBD)(XrInstance instance, XrFutureEXT future, XrCreateCameraDeviceCompletionBD* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyCameraDeviceBD)(XrCameraDeviceBD device);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateCameraCaptureSessionAsyncBD)(XrSession session, const XrCameraCaptureSessionCreateInfoBD* createInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateCameraCaptureSessionCompleteBD)(XrSession session, XrFutureEXT future, XrCreateCameraCaptureSessionCompletionBD* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyCameraCaptureSessionBD)(XrCameraCaptureSessionBD captureSession);
+typedef XrResult (XRAPI_PTR *PFN_xrBeginCameraCaptureBD)(XrCameraCaptureSessionBD captureSession, const XrCameraCaptureBeginInfoBD* beginInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrEndCameraCaptureBD)(XrCameraCaptureSessionBD captureSession);
+typedef XrResult (XRAPI_PTR *PFN_xrAcquireCameraImageBD)(XrCameraCaptureSessionBD captureSession, const XrCameraImageAcquireInfoBD* acquireInfo, XrCameraImageBD* image);
+typedef XrResult (XRAPI_PTR *PFN_xrGetCameraImageDataBD)(XrCameraCaptureSessionBD captureSession, XrCameraImageIdBD imageId, XrCameraImageDataBaseHeaderBD* imageData);
+typedef XrResult (XRAPI_PTR *PFN_xrReleaseCameraImageBD)(XrCameraCaptureSessionBD captureSession, XrCameraImageIdBD imageId);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateAvailableCamerasBD(
+    XrInstance                                  instance,
+    const XrAvailableCamerasEnumerateInfoBD*    enumerateInfo,
+    uint32_t                                    cameraCapacityInput,
+    uint32_t*                                   cameraCountOutput,
+    XrAvailableCameraBD*                        cameras);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateCameraPropertyTypesBD(
+    XrInstance                                  instance,
+    const XrCameraPropertyTypesEnumerateInfoBD* enumerateInfo,
+    XrCameraPropertyTypesBD*                    propertyTypes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetCameraPropertiesBD(
+    XrInstance                                  instance,
+    const XrCameraPropertiesGetInfoBD*          getInfo,
+    XrCameraPropertiesBD*                       properties);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateCameraCapabilityTypesBD(
+    XrInstance                                  instance,
+    const XrCameraCapabilityTypesEnumerateInfoBD* enumerateInfo,
+    XrCameraCapabilityTypesBD*                  capabilityTypes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetCameraSupportedCapabilitiesBD(
+    XrInstance                                  instance,
+    const XrCameraSupportedCapabilitiesGetInfoBD* getInfo,
+    XrCameraSupportedCapabilitiesBD*            capabilities);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateCameraDeviceAsyncBD(
+    XrInstance                                  instance,
+    const XrCameraDeviceCreateInfoBD*           createInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateCameraDeviceCompleteBD(
+    XrInstance                                  instance,
+    XrFutureEXT                                 future,
+    XrCreateCameraDeviceCompletionBD*           completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyCameraDeviceBD(
+    XrCameraDeviceBD                            device);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateCameraCaptureSessionAsyncBD(
+    XrSession                                   session,
+    const XrCameraCaptureSessionCreateInfoBD*   createInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateCameraCaptureSessionCompleteBD(
+    XrSession                                   session,
+    XrFutureEXT                                 future,
+    XrCreateCameraCaptureSessionCompletionBD*   completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyCameraCaptureSessionBD(
+    XrCameraCaptureSessionBD                    captureSession);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrBeginCameraCaptureBD(
+    XrCameraCaptureSessionBD                    captureSession,
+    const XrCameraCaptureBeginInfoBD*           beginInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEndCameraCaptureBD(
+    XrCameraCaptureSessionBD                    captureSession);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrAcquireCameraImageBD(
+    XrCameraCaptureSessionBD                    captureSession,
+    const XrCameraImageAcquireInfoBD*           acquireInfo,
+    XrCameraImageBD*                            image);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetCameraImageDataBD(
+    XrCameraCaptureSessionBD                    captureSession,
+    XrCameraImageIdBD                           imageId,
+    XrCameraImageDataBaseHeaderBD*              imageData);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrReleaseCameraImageBD(
+    XrCameraCaptureSessionBD                    captureSession,
+    XrCameraImageIdBD                           imageId);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_spatial_discovery_bounds is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_spatial_discovery_bounds 1
+#define XR_ANDROID_spatial_discovery_bounds_SPEC_VERSION 1
+#define XR_ANDROID_SPATIAL_DISCOVERY_BOUNDS_EXTENSION_NAME "XR_ANDROID_spatial_discovery_bounds"
+// XrSpatialBoundsSpherefANDROID extends XrSpatialDiscoverySnapshotCreateInfoEXT
+typedef struct XrSpatialBoundsSpherefANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrTime                      time;
+    XrSpheref                   sphere;
+} XrSpatialBoundsSpherefANDROID;
+
+// XrSpatialBoundsBoxfANDROID extends XrSpatialDiscoverySnapshotCreateInfoEXT
+typedef struct XrSpatialBoundsBoxfANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrTime                      time;
+    XrBoxf                      box;
+} XrSpatialBoundsBoxfANDROID;
+
+// XrSpatialBoundsFrustumfANDROID extends XrSpatialDiscoverySnapshotCreateInfoEXT
+typedef struct XrSpatialBoundsFrustumfANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrTime                      time;
+    XrFrustumf                  frustum;
+} XrSpatialBoundsFrustumfANDROID;
+
+
+
+// XR_EXT_spatial_anchor is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_spatial_anchor 1
+#define XR_EXT_spatial_anchor_SPEC_VERSION 1
+#define XR_EXT_SPATIAL_ANCHOR_EXTENSION_NAME "XR_EXT_spatial_anchor"
+typedef struct XrSpatialCapabilityConfigurationAnchorEXT {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrSpatialCapabilityEXT              capability;
+    uint32_t                            enabledComponentCount;
+    const XrSpatialComponentTypeEXT*    enabledComponents;
+} XrSpatialCapabilityConfigurationAnchorEXT;
+
+// XrSpatialComponentAnchorListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentAnchorListEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              locationCount;
+    XrPosef*              locations;
+} XrSpatialComponentAnchorListEXT;
+
+typedef struct XrSpatialAnchorCreateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     baseSpace;
+    XrTime                      time;
+    XrPosef                     pose;
+} XrSpatialAnchorCreateInfoEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorEXT)(XrSpatialContextEXT spatialContext, const XrSpatialAnchorCreateInfoEXT* createInfo, XrSpatialEntityIdEXT* anchorEntityId, XrSpatialEntityEXT* anchorEntity);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorEXT(
+    XrSpatialContextEXT                         spatialContext,
+    const XrSpatialAnchorCreateInfoEXT*         createInfo,
+    XrSpatialEntityIdEXT*                       anchorEntityId,
+    XrSpatialEntityEXT*                         anchorEntity);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_spatial_persistence is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_spatial_persistence 1
+XR_DEFINE_HANDLE(XrSpatialPersistenceContextEXT)
+#define XR_EXT_spatial_persistence_SPEC_VERSION 1
+#define XR_EXT_SPATIAL_PERSISTENCE_EXTENSION_NAME "XR_EXT_spatial_persistence"
+
+typedef enum XrSpatialPersistenceScopeEXT {
+    XR_SPATIAL_PERSISTENCE_SCOPE_SYSTEM_MANAGED_EXT = 1,
+    XR_SPATIAL_PERSISTENCE_SCOPE_LOCAL_ANCHORS_EXT = 1000781000,
+    XR_SPATIAL_PERSISTENCE_SCOPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialPersistenceScopeEXT;
+
+typedef enum XrSpatialPersistenceContextResultEXT {
+    XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_SUCCESS_EXT = 0,
+    XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_ENTITY_NOT_TRACKING_EXT = -1000781001,
+    XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_PERSIST_UUID_NOT_FOUND_EXT = -1000781002,
+    XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialPersistenceContextResultEXT;
+
+typedef enum XrSpatialPersistenceStateEXT {
+    XR_SPATIAL_PERSISTENCE_STATE_LOADED_EXT = 1,
+    XR_SPATIAL_PERSISTENCE_STATE_NOT_FOUND_EXT = 2,
+    XR_SPATIAL_PERSISTENCE_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialPersistenceStateEXT;
+typedef struct XrSpatialPersistenceContextCreateInfoEXT {
+    XrStructureType                 type;
+    const void* XR_MAY_ALIAS        next;
+    XrSpatialPersistenceScopeEXT    scope;
+} XrSpatialPersistenceContextCreateInfoEXT;
+
+typedef struct XrCreateSpatialPersistenceContextCompletionEXT {
+    XrStructureType                         type;
+    void* XR_MAY_ALIAS                      next;
+    XrResult                                futureResult;
+    XrSpatialPersistenceContextResultEXT    createResult;
+    XrSpatialPersistenceContextEXT          persistenceContext;
+} XrCreateSpatialPersistenceContextCompletionEXT;
+
+// XrSpatialContextPersistenceConfigEXT extends XrSpatialContextCreateInfoEXT
+typedef struct XrSpatialContextPersistenceConfigEXT {
+    XrStructureType                          type;
+    const void* XR_MAY_ALIAS                 next;
+    uint32_t                                 persistenceContextCount;
+    const XrSpatialPersistenceContextEXT*    persistenceContexts;
+} XrSpatialContextPersistenceConfigEXT;
+
+// XrSpatialDiscoveryPersistenceUuidFilterEXT extends XrSpatialDiscoverySnapshotCreateInfoEXT,XrSpatialComponentDataQueryConditionEXT
+typedef struct XrSpatialDiscoveryPersistenceUuidFilterEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    persistedUuidCount;
+    const XrUuid*               persistedUuids;
+} XrSpatialDiscoveryPersistenceUuidFilterEXT;
+
+typedef struct XrSpatialPersistenceDataEXT {
+    XrUuid                          persistUuid;
+    XrSpatialPersistenceStateEXT    persistState;
+} XrSpatialPersistenceDataEXT;
+
+// XrSpatialComponentPersistenceListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentPersistenceListEXT {
+    XrStructureType                 type;
+    void* XR_MAY_ALIAS              next;
+    uint32_t                        persistDataCount;
+    XrSpatialPersistenceDataEXT*    persistData;
+} XrSpatialComponentPersistenceListEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialPersistenceScopesEXT)(XrInstance instance, XrSystemId systemId, uint32_t persistenceScopeCapacityInput, uint32_t* persistenceScopeCountOutput, XrSpatialPersistenceScopeEXT* persistenceScopes);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialPersistenceContextAsyncEXT)(XrSession session, const XrSpatialPersistenceContextCreateInfoEXT* createInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialPersistenceContextCompleteEXT)(XrSession session, XrFutureEXT future, XrCreateSpatialPersistenceContextCompletionEXT* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialPersistenceContextEXT)(XrSpatialPersistenceContextEXT persistenceContext);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialPersistenceScopesEXT(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    persistenceScopeCapacityInput,
+    uint32_t*                                   persistenceScopeCountOutput,
+    XrSpatialPersistenceScopeEXT*               persistenceScopes);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialPersistenceContextAsyncEXT(
+    XrSession                                   session,
+    const XrSpatialPersistenceContextCreateInfoEXT* createInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialPersistenceContextCompleteEXT(
+    XrSession                                   session,
+    XrFutureEXT                                 future,
+    XrCreateSpatialPersistenceContextCompletionEXT* completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialPersistenceContextEXT(
+    XrSpatialPersistenceContextEXT              persistenceContext);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_haptic_parametric is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_haptic_parametric 1
+
+#define XR_HAPTIC_PARAMETRIC_MAX_POINTS_TRANSIENTS_EXT 500
+
+
+#define XR_HAPTIC_PARAMETRIC_VIBRATION_EXTEND_DURATION_EXT 50000000
+
+
+#define XR_HAPTIC_PARAMETRIC_FREQUENCY_MIN_HZ_EXT 1
+
+
+#define XR_HAPTIC_PARAMETRIC_FREQUENCY_MAX_HZ_EXT 1000
+
+#define XR_EXT_haptic_parametric_SPEC_VERSION 1
+#define XR_EXT_HAPTIC_PARAMETRIC_EXTENSION_NAME "XR_EXT_haptic_parametric"
+
+typedef enum XrHapticParametricStreamFrameTypeEXT {
+    XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_NONE_EXT = 0,
+    XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_FIRST_FRAME_EXT = 1,
+    XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_INTERMEDIATE_FRAME_EXT = 2,
+    XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_LAST_FRAME_EXT = 3,
+    XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrHapticParametricStreamFrameTypeEXT;
+typedef struct XrHapticParametricPropertiesEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrDuration            idealFrameSubmissionRate;
+    XrDuration            minimumFirstFrameDuration;
+    float                 minFrequencyHz;
+    float                 maxFrequencyHz;
+} XrHapticParametricPropertiesEXT;
+
+typedef struct XrHapticParametricPointEXT {
+    XrDuration    time;
+    float         value;
+} XrHapticParametricPointEXT;
+
+typedef struct XrHapticParametricTransientEXT {
+    XrDuration    time;
+    float         amplitude;
+    float         frequency;
+} XrHapticParametricTransientEXT;
+
+typedef struct XrHapticParametricVibrationEXT {
+    XrStructureType                          type;
+    const void* XR_MAY_ALIAS                 next;
+    uint32_t                                 amplitudePointCount;
+    const XrHapticParametricPointEXT*        amplitudePoints;
+    uint32_t                                 frequencyPointCount;
+    const XrHapticParametricPointEXT*        frequencyPoints;
+    uint32_t                                 transientCount;
+    const XrHapticParametricTransientEXT*    transients;
+    float                                    minFrequencyHz;
+    float                                    maxFrequencyHz;
+    XrHapticParametricStreamFrameTypeEXT     streamFrameType;
+} XrHapticParametricVibrationEXT;
+
+// XrSystemHapticParametricPropertiesEXT extends XrSystemProperties
+typedef struct XrSystemHapticParametricPropertiesEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsParametricHaptics;
+} XrSystemHapticParametricPropertiesEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrHapticParametricGetPropertiesEXT)(XrSession session, const XrHapticActionInfo* hapticActionInfo, XrHapticParametricPropertiesEXT* parametricProperties);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrHapticParametricGetPropertiesEXT(
+    XrSession                                   session,
+    const XrHapticActionInfo*                   hapticActionInfo,
+    XrHapticParametricPropertiesEXT*            parametricProperties);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_SONY_swapchain_color_space is a preprocessor guard. Do not pass it to API calls.
+#define XR_SONY_swapchain_color_space 1
+#define XR_SONY_swapchain_color_space_SPEC_VERSION 1
+#define XR_SONY_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "XR_SONY_swapchain_color_space"
+
+typedef enum XrColorSpaceSONY {
+    XR_COLOR_SPACE_SRGB_NONLINEAR_SONY = 0,
+    XR_COLOR_SPACE_DISPLAY_P3_LINEAR_SONY = 1,
+    XR_COLOR_SPACE_DISPLAY_P3_NONLINEAR_SONY = 2,
+    XR_COLOR_SPACE_DCI_P3_LINEAR_SONY = 3,
+    XR_COLOR_SPACE_DCI_P3_NONLINEAR_SONY = 4,
+    XR_COLOR_SPACE_EXTENDED_SRGB_LINEAR_SONY = 5,
+    XR_COLOR_SPACE_BT709_LINEAR_SONY = 6,
+    XR_COLOR_SPACE_BT709_NONLINEAR_SONY = 7,
+    XR_COLOR_SPACE_BT2020_LINEAR_SONY = 8,
+    XR_COLOR_SPACE_BT2020_PQ_SONY = 9,
+    XR_COLOR_SPACE_BT2020_HLG_SONY = 10,
+    XR_COLOR_SPACE_MAX_ENUM_SONY = 0x7FFFFFFF
+} XrColorSpaceSONY;
+typedef struct XrColorSpacesEnumerateInfoSONY {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    int64_t                     format;
+} XrColorSpacesEnumerateInfoSONY;
+
+// XrSwapchainCreateInfoColorSpaceSONY extends XrSwapchainCreateInfo
+typedef struct XrSwapchainCreateInfoColorSpaceSONY {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrColorSpaceSONY            colorSpace;
+} XrSwapchainCreateInfoColorSpaceSONY;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateColorSpacesSONY)(XrSession session, const XrColorSpacesEnumerateInfoSONY* enumerateInfo, uint32_t colorSpaceCapacityInput, uint32_t* colorSpaceCountOutput, XrColorSpaceSONY* colorSpaces);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateColorSpacesSONY(
+    XrSession                                   session,
+    const XrColorSpacesEnumerateInfoSONY*       enumerateInfo,
+    uint32_t                                    colorSpaceCapacityInput,
+    uint32_t*                                   colorSpaceCountOutput,
+    XrColorSpaceSONY*                           colorSpaces);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_SONY_hdr_metadata is a preprocessor guard. Do not pass it to API calls.
+#define XR_SONY_hdr_metadata 1
+#define XR_SONY_hdr_metadata_SPEC_VERSION 1
+#define XR_SONY_HDR_METADATA_EXTENSION_NAME "XR_SONY_hdr_metadata"
+typedef struct XrXYColorSONY {
+    float    x;
+    float    y;
+} XrXYColorSONY;
+
+typedef struct XrHdrMetadataSONY {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrXYColorSONY               displayPrimaryRed;
+    XrXYColorSONY               displayPrimaryGreen;
+    XrXYColorSONY               displayPrimaryBlue;
+    XrXYColorSONY               whitePoint;
+    float                       maxLuminance;
+    float                       minLuminance;
+    float                       maxContentLightLevel;
+    float                       maxFrameAverageLightLevel;
+} XrHdrMetadataSONY;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSetHdrMetadataSONY)(XrSwapchain swapchain, const XrHdrMetadataSONY* hdrMetadata);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetHdrMetadataSONY(
+    XrSwapchain                                 swapchain,
+    const XrHdrMetadataSONY*                    hdrMetadata);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_spatial_persistence_operations is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_spatial_persistence_operations 1
+#define XR_EXT_spatial_persistence_operations_SPEC_VERSION 1
+#define XR_EXT_SPATIAL_PERSISTENCE_OPERATIONS_EXTENSION_NAME "XR_EXT_spatial_persistence_operations"
+typedef struct XrSpatialEntityPersistInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialContextEXT         spatialContext;
+    XrSpatialEntityIdEXT        spatialEntityId;
+} XrSpatialEntityPersistInfoEXT;
+
+typedef struct XrPersistSpatialEntityCompletionEXT {
+    XrStructureType                         type;
+    void* XR_MAY_ALIAS                      next;
+    XrResult                                futureResult;
+    XrSpatialPersistenceContextResultEXT    persistResult;
+    XrUuid                                  persistUuid;
+} XrPersistSpatialEntityCompletionEXT;
+
+typedef struct XrSpatialEntityUnpersistInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrUuid                      persistUuid;
+} XrSpatialEntityUnpersistInfoEXT;
+
+typedef struct XrUnpersistSpatialEntityCompletionEXT {
+    XrStructureType                         type;
+    void* XR_MAY_ALIAS                      next;
+    XrResult                                futureResult;
+    XrSpatialPersistenceContextResultEXT    unpersistResult;
+} XrUnpersistSpatialEntityCompletionEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialEntityAsyncEXT)(XrSpatialPersistenceContextEXT persistenceContext, const XrSpatialEntityPersistInfoEXT* persistInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialEntityCompleteEXT)(XrSpatialPersistenceContextEXT persistenceContext, XrFutureEXT future, XrPersistSpatialEntityCompletionEXT* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialEntityAsyncEXT)(XrSpatialPersistenceContextEXT persistenceContext, const XrSpatialEntityUnpersistInfoEXT* unpersistInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialEntityCompleteEXT)(XrSpatialPersistenceContextEXT persistenceContext, XrFutureEXT future, XrUnpersistSpatialEntityCompletionEXT* completion);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrPersistSpatialEntityAsyncEXT(
+    XrSpatialPersistenceContextEXT              persistenceContext,
+    const XrSpatialEntityPersistInfoEXT*        persistInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrPersistSpatialEntityCompleteEXT(
+    XrSpatialPersistenceContextEXT              persistenceContext,
+    XrFutureEXT                                 future,
+    XrPersistSpatialEntityCompletionEXT*        completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistSpatialEntityAsyncEXT(
+    XrSpatialPersistenceContextEXT              persistenceContext,
+    const XrSpatialEntityUnpersistInfoEXT*      unpersistInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistSpatialEntityCompleteEXT(
+    XrSpatialPersistenceContextEXT              persistenceContext,
+    XrFutureEXT                                 future,
+    XrUnpersistSpatialEntityCompletionEXT*      completion);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_spatial_image_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_spatial_image_tracking 1
+XR_DEFINE_HANDLE(XrSpatialImageTrackingDatabaseEXT)
+#define XR_EXT_spatial_image_tracking_SPEC_VERSION 1
+#define XR_EXT_SPATIAL_IMAGE_TRACKING_EXTENSION_NAME "XR_EXT_spatial_image_tracking"
+
+typedef enum XrSpatialReferenceImageFormatEXT {
+    XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT = 1,
+    XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGB_888_EXT = 2,
+    XR_SPATIAL_REFERENCE_IMAGE_FORMAT_YUV_420_888_EXT = 3,
+    XR_SPATIAL_REFERENCE_IMAGE_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialReferenceImageFormatEXT;
+typedef struct XrSpatialReferenceImagePlaneEXT {
+    uint32_t          bufferSize;
+    const uint8_t*    buffer;
+    uint32_t          rowStride;
+    uint32_t          pixelStride;
+} XrSpatialReferenceImagePlaneEXT;
+
+typedef struct XrSpatialReferenceImageEXT {
+    XrStructureType                           type;
+    const void* XR_MAY_ALIAS                  next;
+    uint32_t                                  width;
+    uint32_t                                  height;
+    XrSpatialReferenceImageFormatEXT          format;
+    uint32_t                                  planeCount;
+    const XrSpatialReferenceImagePlaneEXT*    planes;
+} XrSpatialReferenceImageEXT;
+
+// XrSpatialImageStaticOptimizationEXT extends XrSpatialReferenceImageEXT,XrSpatialImageTrackingDatabaseCreateInfoEXT
+typedef struct XrSpatialImageStaticOptimizationEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    optimizeForStaticImage;
+} XrSpatialImageStaticOptimizationEXT;
+
+// XrSpatialImageSizeEXT extends XrSpatialReferenceImageEXT,XrSpatialImageTrackingDatabaseCreateInfoEXT
+typedef struct XrSpatialImageSizeEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    float                       physicalWidth;
+} XrSpatialImageSizeEXT;
+
+typedef struct XrSpatialCapabilityConfigurationImageTrackingEXT {
+    XrStructureType                             type;
+    const void* XR_MAY_ALIAS                    next;
+    XrSpatialCapabilityEXT                      capability;
+    uint32_t                                    enabledComponentCount;
+    const XrSpatialComponentTypeEXT*            enabledComponents;
+    uint32_t                                    imageTrackingDatabaseCount;
+    const XrSpatialImageTrackingDatabaseEXT*    imageTrackingDatabases;
+} XrSpatialCapabilityConfigurationImageTrackingEXT;
+
+typedef struct XrSpatialImageTrackingDatabaseCreateInfoEXT {
+    XrStructureType                      type;
+    const void* XR_MAY_ALIAS             next;
+    uint32_t                             spatialReferenceImageCount;
+    const XrSpatialReferenceImageEXT*    spatialReferenceImages;
+} XrSpatialImageTrackingDatabaseCreateInfoEXT;
+
+typedef struct XrSpatialImage2DDataEXT {
+    XrSpatialImageTrackingDatabaseEXT    imageTrackingDatabase;
+    uint32_t                             referenceImageIndex;
+} XrSpatialImage2DDataEXT;
+
+// XrSpatialComponentImage2DListEXT extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentImage2DListEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    imageCount;
+    XrSpatialImage2DDataEXT*    images;
+} XrSpatialComponentImage2DListEXT;
+
+typedef struct XrCreateSpatialImageTrackingDatabaseCompletionEXT {
+    XrStructureType                      type;
+    void* XR_MAY_ALIAS                   next;
+    XrResult                             futureResult;
+    XrSpatialImageTrackingDatabaseEXT    database;
+} XrCreateSpatialImageTrackingDatabaseCompletionEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialReferenceImageFormatsEXT)(XrInstance instance, XrSystemId systemId, XrSpatialCapabilityEXT capability, uint32_t formatCapacityInput, uint32_t* formatCountOutput, XrSpatialReferenceImageFormatEXT* formats);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialImageTrackingDatabaseAsyncEXT)(XrSession session, const XrSpatialImageTrackingDatabaseCreateInfoEXT* createInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialImageTrackingDatabaseCompleteEXT)(XrSession session, XrFutureEXT future, XrCreateSpatialImageTrackingDatabaseCompletionEXT* completion);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialImageTrackingDatabaseEXT)(XrSpatialImageTrackingDatabaseEXT database);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialReferenceImageFormatsEXT(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrSpatialCapabilityEXT                      capability,
+    uint32_t                                    formatCapacityInput,
+    uint32_t*                                   formatCountOutput,
+    XrSpatialReferenceImageFormatEXT*           formats);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialImageTrackingDatabaseAsyncEXT(
+    XrSession                                   session,
+    const XrSpatialImageTrackingDatabaseCreateInfoEXT* createInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialImageTrackingDatabaseCompleteEXT(
+    XrSession                                   session,
+    XrFutureEXT                                 future,
+    XrCreateSpatialImageTrackingDatabaseCompletionEXT* completion);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialImageTrackingDatabaseEXT(
+    XrSpatialImageTrackingDatabaseEXT           database);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_spatial_object_tracking is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_spatial_object_tracking 1
+#define XR_ANDROID_spatial_object_tracking_SPEC_VERSION 2
+#define XR_ANDROID_SPATIAL_OBJECT_TRACKING_EXTENSION_NAME "XR_ANDROID_spatial_object_tracking"
+
+typedef enum XrSpatialObjectSemanticLabelANDROID {
+    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_UNCATEGORIZED_ANDROID = 0,
+    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_KEYBOARD_ANDROID = 1,
+    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_MOUSE_ANDROID = 2,
+    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_LAPTOP_BASE_ANDROID = 3,
+    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrSpatialObjectSemanticLabelANDROID;
+typedef struct XrSpatialCapabilityConfigurationObjectTrackingANDROID {
+    XrStructureType                               type;
+    const void* XR_MAY_ALIAS                      next;
+    XrSpatialCapabilityEXT                        capability;
+    uint32_t                                      enabledComponentCount;
+    const XrSpatialComponentTypeEXT*              enabledComponents;
+    uint32_t                                      activeSemanticLabelCount;
+    const XrSpatialObjectSemanticLabelANDROID*    activeSemanticLabels;
+} XrSpatialCapabilityConfigurationObjectTrackingANDROID;
+
+// XrSpatialComponentObjectSemanticLabelListANDROID extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentObjectSemanticLabelListANDROID {
+    XrStructureType                         type;
+    void* XR_MAY_ALIAS                      next;
+    uint32_t                                semanticLabelCount;
+    XrSpatialObjectSemanticLabelANDROID*    semanticLabels;
+} XrSpatialComponentObjectSemanticLabelListANDROID;
+
+
+
+// XR_ANDROID_spatial_discovery_raycast is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_spatial_discovery_raycast 1
+#define XR_ANDROID_spatial_discovery_raycast_SPEC_VERSION 1
+#define XR_ANDROID_SPATIAL_DISCOVERY_RAYCAST_EXTENSION_NAME "XR_ANDROID_spatial_discovery_raycast"
+typedef struct XrSpatialRaycastResultDataANDROID {
+    XrPosef    hitPose;
+    float      distanceSquared;
+} XrSpatialRaycastResultDataANDROID;
+
+typedef struct XrSpatialCapabilityConfigurationDepthRaycastANDROID {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrSpatialCapabilityEXT              capability;
+    uint32_t                            enabledComponentCount;
+    const XrSpatialComponentTypeEXT*    enabledComponents;
+} XrSpatialCapabilityConfigurationDepthRaycastANDROID;
+
+// XrSpatialRaycastInfoANDROID extends XrSpatialDiscoverySnapshotCreateInfoEXT
+typedef struct XrSpatialRaycastInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrTime                      time;
+    XrVector3f                  origin;
+    XrVector3f                  direction;
+    float                       maxDistance;
+} XrSpatialRaycastInfoANDROID;
+
+// XrSpatialComponentRaycastResultListANDROID extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentRaycastResultListANDROID {
+    XrStructureType                       type;
+    void* XR_MAY_ALIAS                    next;
+    uint32_t                              raycastResultCount;
+    XrSpatialRaycastResultDataANDROID*    raycastResults;
+} XrSpatialComponentRaycastResultListANDROID;
+
+typedef struct XrSpatialRaycastSnapshotCreateInfoANDROID {
+    XrStructureType                       type;
+    const void* XR_MAY_ALIAS              next;
+    uint32_t                              componentTypeCount;
+    const XrSpatialComponentTypeEXT*      componentTypes;
+    const XrSpatialRaycastInfoANDROID*    raycastInfo;
+} XrSpatialRaycastSnapshotCreateInfoANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialRaycastSnapshotANDROID)(XrSpatialContextEXT spatialContext, const XrSpatialRaycastSnapshotCreateInfoANDROID* createInfo, XrSpatialSnapshotEXT* snapshot);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialRaycastSnapshotANDROID(
+    XrSpatialContextEXT                         spatialContext,
+    const XrSpatialRaycastSnapshotCreateInfoANDROID* createInfo,
+    XrSpatialSnapshotEXT*                       snapshot);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_google_cloud_auth is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_google_cloud_auth 1
+#define XR_ANDROID_google_cloud_auth_SPEC_VERSION 1
+#define XR_ANDROID_GOOGLE_CLOUD_AUTH_EXTENSION_NAME "XR_ANDROID_google_cloud_auth"
+
+typedef enum XrGoogleCloudAuthErrorANDROID {
+    XR_GOOGLE_CLOUD_AUTH_ERROR_NONE_ANDROID = 0,
+    XR_GOOGLE_CLOUD_AUTH_ERROR_QUOTA_EXCEEDED_ANDROID = -1,
+    XR_GOOGLE_CLOUD_AUTH_ERROR_UNREACHABLE_ANDROID = -2,
+    XR_GOOGLE_CLOUD_AUTH_ERROR_ANDROID = -3,
+    XR_GOOGLE_CLOUD_AUTH_ERROR_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrGoogleCloudAuthErrorANDROID;
+typedef struct XR_MAY_ALIAS XrGoogleCloudAuthInfoBaseHeaderANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrGoogleCloudAuthInfoBaseHeaderANDROID;
+
+typedef struct XrGoogleCloudAuthInfoApiKeyANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    const char*                 apiKey;
+} XrGoogleCloudAuthInfoApiKeyANDROID;
+
+typedef struct XrGoogleCloudAuthInfoTokenANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    const char*                 authToken;
+} XrGoogleCloudAuthInfoTokenANDROID;
+
+typedef struct XrGoogleCloudAuthInfoKeylessANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrGoogleCloudAuthInfoKeylessANDROID;
+
+// XrGoogleCloudAuthErrorResultANDROID extends XrGoogleCloudAuthInfoBaseHeaderANDROID
+typedef struct XrGoogleCloudAuthErrorResultANDROID {
+    XrStructureType                  type;
+    void* XR_MAY_ALIAS               next;
+    XrGoogleCloudAuthErrorANDROID    error;
+} XrGoogleCloudAuthErrorResultANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrSetGoogleCloudAuthAsyncANDROID)(XrSession session, const XrGoogleCloudAuthInfoBaseHeaderANDROID* authInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrSetGoogleCloudAuthCompleteANDROID)(XrSession session, XrFutureEXT future, XrFutureCompletionEXT* completion);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetGoogleCloudAuthAsyncANDROID(
+    XrSession                                   session,
+    const XrGoogleCloudAuthInfoBaseHeaderANDROID* authInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrSetGoogleCloudAuthCompleteANDROID(
+    XrSession                                   session,
+    XrFutureEXT                                 future,
+    XrFutureCompletionEXT*                      completion);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_geospatial is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_geospatial 1
+XR_DEFINE_HANDLE(XrGeospatialTrackerANDROID)
+#define XR_ANDROID_geospatial_SPEC_VERSION 1
+#define XR_ANDROID_GEOSPATIAL_EXTENSION_NAME "XR_ANDROID_geospatial"
+
+typedef enum XrGeospatialTrackerStateANDROID {
+    XR_GEOSPATIAL_TRACKER_STATE_STOPPED_ANDROID = 0,
+    XR_GEOSPATIAL_TRACKER_STATE_RUNNING_ANDROID = 1,
+    XR_GEOSPATIAL_TRACKER_STATE_INITIALIZATION_FAILED_ANDROID = 2,
+    XR_GEOSPATIAL_TRACKER_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrGeospatialTrackerStateANDROID;
+
+typedef enum XrVPSAvailabilityANDROID {
+    XR_VPS_AVAILABILITY_UNAVAILABLE_ANDROID = 1,
+    XR_VPS_AVAILABILITY_AVAILABLE_ANDROID = 2,
+    XR_VPSAVAILABILITY_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrVPSAvailabilityANDROID;
+typedef XrFlags64 XrGeospatialPoseFlagsANDROID;
+
+// Flag bits for XrGeospatialPoseFlagsANDROID
+static const XrGeospatialPoseFlagsANDROID XR_GEOSPATIAL_POSE_ORIENTATION_VALID_BIT_ANDROID = 0x00000001;
+static const XrGeospatialPoseFlagsANDROID XR_GEOSPATIAL_POSE_POSITION_VALID_BIT_ANDROID = 0x00000002;
+
+typedef struct XrGeospatialPoseANDROID {
+    XrQuaternionf    eastUpSouthOrientation;
+    double           latitude;
+    double           longitude;
+    double           altitude;
+} XrGeospatialPoseANDROID;
+
+// XrSystemGeospatialPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemGeospatialPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsGeospatial;
+} XrSystemGeospatialPropertiesANDROID;
+
+typedef struct XrGeospatialTrackerCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrGeospatialTrackerCreateInfoANDROID;
+
+typedef struct XrEventDataGeospatialTrackerStateChangedANDROID {
+    XrStructureType                    type;
+    const void* XR_MAY_ALIAS           next;
+    XrGeospatialTrackerANDROID         geospatialTracker;
+    XrGeospatialTrackerStateANDROID    state;
+    XrResult                           initializationResult;
+    XrTime                             time;
+} XrEventDataGeospatialTrackerStateChangedANDROID;
+
+typedef struct XrGeospatialPoseFromPoseLocateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrTime                      time;
+    XrPosef                     pose;
+} XrGeospatialPoseFromPoseLocateInfoANDROID;
+
+typedef struct XrGeospatialPoseResultANDROID {
+    XrStructureType                 type;
+    void* XR_MAY_ALIAS              next;
+    XrGeospatialPoseFlagsANDROID    poseFlags;
+    XrGeospatialPoseANDROID         geospatialPose;
+    double                          horizontalAccuracy;
+    double                          verticalAccuracy;
+    double                          orientationYawAccuracy;
+} XrGeospatialPoseResultANDROID;
+
+typedef struct XrGeospatialPoseLocateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrTime                      time;
+    XrGeospatialPoseANDROID     geospatialPose;
+} XrGeospatialPoseLocateInfoANDROID;
+
+typedef struct XrVPSAvailabilityCheckCompletionANDROID {
+    XrStructureType             type;
+    void* XR_MAY_ALIAS          next;
+    XrResult                    futureResult;
+    XrVPSAvailabilityANDROID    availability;
+} XrVPSAvailabilityCheckCompletionANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateGeospatialTrackerANDROID)(XrSession session, const XrGeospatialTrackerCreateInfoANDROID* createInfo, XrGeospatialTrackerANDROID* geospatialTrackerOutput);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroyGeospatialTrackerANDROID)(XrGeospatialTrackerANDROID geospatialTracker);
+typedef XrResult (XRAPI_PTR *PFN_xrLocateGeospatialPoseFromPoseANDROID)(XrGeospatialTrackerANDROID geospatialTracker, const XrGeospatialPoseFromPoseLocateInfoANDROID* locateInfo, XrGeospatialPoseResultANDROID* geospatialPoseResult);
+typedef XrResult (XRAPI_PTR *PFN_xrLocateGeospatialPoseANDROID)(XrGeospatialTrackerANDROID geospatialTracker, const XrGeospatialPoseLocateInfoANDROID* locateInfo, XrSpaceLocation* location);
+typedef XrResult (XRAPI_PTR *PFN_xrCheckVpsAvailabilityAsyncANDROID)(XrSession session, double latitude, double longitude, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCheckVpsAvailabilityCompleteANDROID)(XrSession session, XrFutureEXT future, XrVPSAvailabilityCheckCompletionANDROID* completion);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateGeospatialTrackerANDROID(
+    XrSession                                   session,
+    const XrGeospatialTrackerCreateInfoANDROID* createInfo,
+    XrGeospatialTrackerANDROID*                 geospatialTrackerOutput);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroyGeospatialTrackerANDROID(
+    XrGeospatialTrackerANDROID                  geospatialTracker);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateGeospatialPoseFromPoseANDROID(
+    XrGeospatialTrackerANDROID                  geospatialTracker,
+    const XrGeospatialPoseFromPoseLocateInfoANDROID* locateInfo,
+    XrGeospatialPoseResultANDROID*              geospatialPoseResult);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateGeospatialPoseANDROID(
+    XrGeospatialTrackerANDROID                  geospatialTracker,
+    const XrGeospatialPoseLocateInfoANDROID*    locateInfo,
+    XrSpaceLocation*                            location);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCheckVpsAvailabilityAsyncANDROID(
+    XrSession                                   session,
+    double                                      latitude,
+    double                                      longitude,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCheckVpsAvailabilityCompleteANDROID(
+    XrSession                                   session,
+    XrFutureEXT                                 future,
+    XrVPSAvailabilityCheckCompletionANDROID*    completion);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_spatial_entity_bound_anchor is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_spatial_entity_bound_anchor 1
+#define XR_ANDROID_spatial_entity_bound_anchor_SPEC_VERSION 2
+#define XR_ANDROID_SPATIAL_ENTITY_BOUND_ANCHOR_EXTENSION_NAME "XR_ANDROID_spatial_entity_bound_anchor"
+// XrSpatialAnchorParentANDROID extends XrSpatialAnchorCreateInfoEXT
+typedef struct XrSpatialAnchorParentANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialEntityIdEXT        parentId;
+} XrSpatialAnchorParentANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialAnchorAttachableComponentsANDROID)(XrInstance instance, XrSystemId systemId, uint32_t attachableComponentCapacityInput, uint32_t* attachableComponentCountOutput, XrSpatialComponentTypeEXT* attachableComponents);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialAnchorAttachableComponentsANDROID(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    attachableComponentCapacityInput,
+    uint32_t*                                   attachableComponentCountOutput,
+    XrSpatialComponentTypeEXT*                  attachableComponents);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_spatial_component_subsumed_by is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_spatial_component_subsumed_by 1
+#define XR_ANDROID_spatial_component_subsumed_by_SPEC_VERSION 1
+#define XR_ANDROID_SPATIAL_COMPONENT_SUBSUMED_BY_EXTENSION_NAME "XR_ANDROID_spatial_component_subsumed_by"
+// XrSpatialDiscoveryUniqueEntitiesFilterANDROID extends XrSpatialDiscoverySnapshotCreateInfoEXT
+typedef struct XrSpatialDiscoveryUniqueEntitiesFilterANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpatialDiscoveryUniqueEntitiesFilterANDROID;
+
+// XrSpatialComponentSubsumedByListANDROID extends XrSpatialComponentDataQueryResultEXT
+typedef struct XrSpatialComponentSubsumedByListANDROID {
+    XrStructureType          type;
+    void* XR_MAY_ALIAS       next;
+    uint32_t                 subsumedUniqueIdCount;
+    XrSpatialEntityIdEXT*    subsumedUniqueIds;
+} XrSpatialComponentSubsumedByListANDROID;
+
+
+
+// XR_ANDROID_spatial_anchor_space is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_spatial_anchor_space 1
+#define XR_ANDROID_spatial_anchor_space_SPEC_VERSION 1
+#define XR_ANDROID_SPATIAL_ANCHOR_SPACE_EXTENSION_NAME "XR_ANDROID_spatial_anchor_space"
+typedef struct XrSpatialAnchorSpaceFromIdCreateInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialEntityIdEXT        anchorEntityId;
+} XrSpatialAnchorSpaceFromIdCreateInfoANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorSpaceANDROID)(XrSession session, XrSpatialContextEXT spatialContext, const XrSpatialAnchorCreateInfoEXT* createInfo, XrSpatialEntityIdEXT* anchorEntityId, XrSpace* anchorSpace);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorSpaceFromIdANDROID)(XrSession session, XrSpatialContextEXT spatialContext, const XrSpatialAnchorSpaceFromIdCreateInfoANDROID* createInfo, XrSpace* anchorSpace);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorSpaceANDROID(
+    XrSession                                   session,
+    XrSpatialContextEXT                         spatialContext,
+    const XrSpatialAnchorCreateInfoEXT*         createInfo,
+    XrSpatialEntityIdEXT*                       anchorEntityId,
+    XrSpace*                                    anchorSpace);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorSpaceFromIdANDROID(
+    XrSession                                   session,
+    XrSpatialContextEXT                         spatialContext,
+    const XrSpatialAnchorSpaceFromIdCreateInfoANDROID* createInfo,
+    XrSpace*                                    anchorSpace);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_ANDROID_geospatial_anchor is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_geospatial_anchor 1
+#define XR_ANDROID_geospatial_anchor_SPEC_VERSION 1
+#define XR_ANDROID_GEOSPATIAL_ANCHOR_EXTENSION_NAME "XR_ANDROID_geospatial_anchor"
+
+typedef enum XrSurfaceAnchorTypeANDROID {
+    XR_SURFACE_ANCHOR_TYPE_TERRAIN_ANDROID = 1,
+    XR_SURFACE_ANCHOR_TYPE_ROOFTOP_ANDROID = 2,
+    XR_SURFACE_ANCHOR_TYPE_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} XrSurfaceAnchorTypeANDROID;
+// XrSystemGeospatialAnchorPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemGeospatialAnchorPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              maxSurfaceAnchorCount;
+} XrSystemGeospatialAnchorPropertiesANDROID;
+
+// XrGeospatialTrackerAnchorTrackingInfoANDROID extends XrGeospatialTrackerCreateInfoANDROID
+typedef struct XrGeospatialTrackerAnchorTrackingInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    shouldTrackPlanes;
+} XrGeospatialTrackerAnchorTrackingInfoANDROID;
+
+typedef struct XrGeospatialAnchorCreateInfoANDROID {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrGeospatialTrackerANDROID    geospatialTracker;
+    XrGeospatialPoseANDROID       geospatialPose;
+} XrGeospatialAnchorCreateInfoANDROID;
+
+typedef struct XrSurfaceAnchorCreateInfoANDROID {
+    XrStructureType               type;
+    const void* XR_MAY_ALIAS      next;
+    XrGeospatialTrackerANDROID    geospatialTracker;
+    XrSurfaceAnchorTypeANDROID    surfaceAnchorType;
+    XrQuaternionf                 eastUpSouthOrientation;
+    double                        latitude;
+    double                        longitude;
+    double                        altitudeRelativeToSurface;
+} XrSurfaceAnchorCreateInfoANDROID;
+
+typedef struct XrSurfaceAnchorCreateCompletionANDROID {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    XrResult                futureResult;
+    XrSpatialEntityIdEXT    anchorEntityId;
+} XrSurfaceAnchorCreateCompletionANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateGeospatialAnchorANDROID)(XrSpatialContextEXT spatialContext, const XrGeospatialAnchorCreateInfoANDROID* createInfo, XrSpatialEntityIdEXT* anchorEntityId);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSurfaceAnchorAsyncANDROID)(XrSpatialContextEXT spatialContext, const XrSurfaceAnchorCreateInfoANDROID* createInfo, XrFutureEXT* future);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSurfaceAnchorCompleteANDROID)(XrSpatialContextEXT spatialContext, XrFutureEXT future, XrSurfaceAnchorCreateCompletionANDROID* completion);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateGeospatialAnchorANDROID(
+    XrSpatialContextEXT                         spatialContext,
+    const XrGeospatialAnchorCreateInfoANDROID*  createInfo,
+    XrSpatialEntityIdEXT*                       anchorEntityId);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSurfaceAnchorAsyncANDROID(
+    XrSpatialContextEXT                         spatialContext,
+    const XrSurfaceAnchorCreateInfoANDROID*     createInfo,
+    XrFutureEXT*                                future);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSurfaceAnchorCompleteANDROID(
+    XrSpatialContextEXT                         spatialContext,
+    XrFutureEXT                                 future,
+    XrSurfaceAnchorCreateCompletionANDROID*     completion);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_spatial_container is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_spatial_container 1
+XR_DEFINE_HANDLE(XrSpatialContainerEXT)
+#define XR_EXT_spatial_container_SPEC_VERSION 1
+#define XR_EXT_SPATIAL_CONTAINER_EXTENSION_NAME "XR_EXT_spatial_container"
+
+typedef enum XrSpatialContainerGraphicsPresentationEXT {
+    XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_SELF_RENDERING_EXT = 1000813000,
+    XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialContainerGraphicsPresentationEXT;
+
+typedef enum XrSpatialContainerBoundsModeEXT {
+    XR_SPATIAL_CONTAINER_BOUNDS_MODE_BOUNDED_EXT = 1,
+    XR_SPATIAL_CONTAINER_BOUNDS_MODE_IMMERSIVE_EXT = 2,
+    XR_SPATIAL_CONTAINER_BOUNDS_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialContainerBoundsModeEXT;
+
+typedef enum XrSpatialContainerVolumeClippingEXT {
+    XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_NONE_EXT = 0,
+    XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_STRICT_EXT = 1,
+    XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_MAX_ENUM_EXT = 0x7FFFFFFF
+} XrSpatialContainerVolumeClippingEXT;
+// XrSessionCreateInfoSpatialContainersEXT extends XrSessionCreateInfo
+typedef struct XrSessionCreateInfoSpatialContainersEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSessionCreateInfoSpatialContainersEXT;
+
+typedef struct XrSpatialContainerCreateInfoEXT {
+    XrStructureType                              type;
+    const void* XR_MAY_ALIAS                     next;
+    XrSpatialContainerGraphicsPresentationEXT    graphicsPresentation;
+    XrExtent3Df                                  suggestedBounds;
+} XrSpatialContainerCreateInfoEXT;
+
+typedef struct XrSpatialContainerSpaceCreateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialContainerEXT       spatialContainer;
+} XrSpatialContainerSpaceCreateInfoEXT;
+
+typedef struct XrEventDataSpatialContainerClosedEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialContainerEXT       spatialContainer;
+} XrEventDataSpatialContainerClosedEXT;
+
+// XrSystemSpatialContainerPropertiesEXT extends XrSystemProperties
+typedef struct XrSystemSpatialContainerPropertiesEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              maxSpatialContainerCount;
+    XrBool32              supportsBounded;
+    XrBool32              supportsImmersive;
+} XrSystemSpatialContainerPropertiesEXT;
+
+typedef struct XrSpatialContainerBoundsEXT {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrExtent3Df           bounds;
+    XrBool32              infiniteBounds;
+} XrSpatialContainerBoundsEXT;
+
+typedef struct XrEventDataSpatialContainerBoundsChangedEXT {
+    XrStructureType                    type;
+    const void* XR_MAY_ALIAS           next;
+    XrSpatialContainerEXT              spatialContainer;
+    XrExtent3Df                        bounds;
+    XrBool32                           infiniteBounds;
+    XrSpatialContainerBoundsModeEXT    boundsMode;
+} XrEventDataSpatialContainerBoundsChangedEXT;
+
+typedef struct XrSpatialContainerBoundsGetInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpatialContainerBoundsGetInfoEXT;
+
+typedef struct XrSpatialContainerStateGetInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+} XrSpatialContainerStateGetInfoEXT;
+
+typedef struct XrSpatialContainerVisibleRequestInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrBool32                    visible;
+} XrSpatialContainerVisibleRequestInfoEXT;
+
+typedef struct XrEventDataSpatialContainerVisibleChangedEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialContainerEXT       spatialContainer;
+    XrBool32                    visible;
+} XrEventDataSpatialContainerVisibleChangedEXT;
+
+typedef struct XrEventDataSpatialContainerVisibleRequestDeniedEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialContainerEXT       spatialContainer;
+} XrEventDataSpatialContainerVisibleRequestDeniedEXT;
+
+typedef struct XrEventDataSpatialContainerInteractableChangedEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialContainerEXT       spatialContainer;
+    XrBool32                    interactable;
+} XrEventDataSpatialContainerInteractableChangedEXT;
+
+typedef struct XrSpatialContainerBoundsModeRequestInfoEXT {
+    XrStructureType                    type;
+    const void* XR_MAY_ALIAS           next;
+    XrSpatialContainerBoundsModeEXT    boundsMode;
+} XrSpatialContainerBoundsModeRequestInfoEXT;
+
+typedef struct XrEventDataSpatialContainerBoundsModeRequestDeniedEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialContainerEXT       spatialContainer;
+} XrEventDataSpatialContainerBoundsModeRequestDeniedEXT;
+
+typedef struct XrSpatialContainerStateEXT {
+    XrStructureType                    type;
+    void* XR_MAY_ALIAS                 next;
+    XrBool32                           visible;
+    XrBool32                           interactable;
+    XrSpatialContainerBoundsModeEXT    boundsMode;
+} XrSpatialContainerStateEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialContainerEXT)(XrSession session, const XrSpatialContainerCreateInfoEXT* createInfo, XrSpatialContainerEXT* spatialContainer);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialContainerEXT)(XrSpatialContainerEXT spatialContainer);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialContainerSpaceEXT)(XrSession session, const XrSpatialContainerSpaceCreateInfoEXT* createInfo, XrSpace* space);
+typedef XrResult (XRAPI_PTR *PFN_xrRequestSpatialContainerVisibleEXT)(XrSpatialContainerEXT spatialContainer, const XrSpatialContainerVisibleRequestInfoEXT* info);
+typedef XrResult (XRAPI_PTR *PFN_xrRequestSpatialContainerBoundsModeEXT)(XrSpatialContainerEXT spatialContainer, const XrSpatialContainerBoundsModeRequestInfoEXT* info);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialContainerBoundsEXT)(XrSpatialContainerEXT spatialContainer, const XrSpatialContainerBoundsGetInfoEXT* getInfo, XrSpatialContainerBoundsEXT* bounds);
+typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialContainerStateEXT)(XrSpatialContainerEXT spatialContainer, const XrSpatialContainerStateGetInfoEXT* getInfo, XrSpatialContainerStateEXT* state);
+typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedSpatialContainerGraphicsPresentationsEXT)(XrInstance instance, XrSystemId systemId, uint32_t graphicsPresentationCapacityInput, uint32_t* graphicsPresentationCountOutput, XrSpatialContainerGraphicsPresentationEXT* graphicsPresentations);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialContainerEXT(
+    XrSession                                   session,
+    const XrSpatialContainerCreateInfoEXT*      createInfo,
+    XrSpatialContainerEXT*                      spatialContainer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialContainerEXT(
+    XrSpatialContainerEXT                       spatialContainer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialContainerSpaceEXT(
+    XrSession                                   session,
+    const XrSpatialContainerSpaceCreateInfoEXT* createInfo,
+    XrSpace*                                    space);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestSpatialContainerVisibleEXT(
+    XrSpatialContainerEXT                       spatialContainer,
+    const XrSpatialContainerVisibleRequestInfoEXT* info);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrRequestSpatialContainerBoundsModeEXT(
+    XrSpatialContainerEXT                       spatialContainer,
+    const XrSpatialContainerBoundsModeRequestInfoEXT* info);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialContainerBoundsEXT(
+    XrSpatialContainerEXT                       spatialContainer,
+    const XrSpatialContainerBoundsGetInfoEXT*   getInfo,
+    XrSpatialContainerBoundsEXT*                bounds);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialContainerStateEXT(
+    XrSpatialContainerEXT                       spatialContainer,
+    const XrSpatialContainerStateGetInfoEXT*    getInfo,
+    XrSpatialContainerStateEXT*                 state);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedSpatialContainerGraphicsPresentationsEXT(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    graphicsPresentationCapacityInput,
+    uint32_t*                                   graphicsPresentationCountOutput,
+    XrSpatialContainerGraphicsPresentationEXT*  graphicsPresentations);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_spatial_container_self_rendering is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_spatial_container_self_rendering 1
+#define XR_EXT_spatial_container_self_rendering_SPEC_VERSION 1
+#define XR_EXT_SPATIAL_CONTAINER_SELF_RENDERING_EXTENSION_NAME "XR_EXT_spatial_container_self_rendering"
+typedef struct XrSpatialContainerViewLocateInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrViewConfigurationType     viewConfigurationType;
+    XrSpace                     space;
+    XrSpatialContainerEXT       spatialContainer;
+} XrSpatialContainerViewLocateInfoEXT;
+
+typedef struct XrSpatialContainerViewsLocateInfoEXT {
+    XrStructureType                               type;
+    const void* XR_MAY_ALIAS                      next;
+    XrTime                                        displayTime;
+    uint32_t                                      viewLocateInfoCount;
+    const XrSpatialContainerViewLocateInfoEXT*    viewLocateInfos;
+} XrSpatialContainerViewsLocateInfoEXT;
+
+typedef struct XrSpatialContainerViewStateEXT {
+    XrStructureType            type;
+    void* XR_MAY_ALIAS         next;
+    XrViewStateFlags           viewStateFlags;
+    XrViewConfigurationType    viewConfigurationType;
+    XrBool32                   shouldSubmitLayers;
+    XrExtent2Di                recommendedImageExtent;
+} XrSpatialContainerViewStateEXT;
+
+typedef struct XrSpatialContainerLayerEXT {
+    XrStructureType                               type;
+    const void* XR_MAY_ALIAS                      next;
+    XrSpatialContainerEXT                         spatialContainer;
+    XrBool32                                      retainPreviousSubmission;
+    uint32_t                                      layerCount;
+    const XrCompositionLayerBaseHeader* const*    layers;
+} XrSpatialContainerLayerEXT;
+
+// XrSpatialContainerLayerFrameEndInfoEXT extends XrFrameEndInfo
+typedef struct XrSpatialContainerLayerFrameEndInfoEXT {
+    XrStructureType                      type;
+    const void* XR_MAY_ALIAS             next;
+    uint32_t                             containerLayerCount;
+    const XrSpatialContainerLayerEXT*    containerLayers;
+} XrSpatialContainerLayerFrameEndInfoEXT;
+
+typedef struct XrSpatialContainerBeginInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialContainerEXT       spatialContainer;
+    XrViewConfigurationType     primaryViewConfigurationType;
+} XrSpatialContainerBeginInfoEXT;
+
+typedef struct XrSpatialContainerEndInfoEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialContainerEXT       spatialContainer;
+} XrSpatialContainerEndInfoEXT;
+
+// XrSpatialContainerCompositionLayerViewConfigurationEXT extends XrCompositionLayerProjection
+typedef struct XrSpatialContainerCompositionLayerViewConfigurationEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrViewConfigurationType     viewConfigurationType;
+} XrSpatialContainerCompositionLayerViewConfigurationEXT;
+
+// XrSpatialContainerLayerVolumeClippingEXT extends XrSpatialContainerLayerEXT
+typedef struct XrSpatialContainerLayerVolumeClippingEXT {
+    XrStructureType                        type;
+    const void* XR_MAY_ALIAS               next;
+    XrSpatialContainerVolumeClippingEXT    volumeClipping;
+} XrSpatialContainerLayerVolumeClippingEXT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrBeginSpatialContainerRenderingEXT)(XrSession session, const XrSpatialContainerBeginInfoEXT* beginInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrEndSpatialContainerRenderingEXT)(XrSession session, const XrSpatialContainerEndInfoEXT* endInfo);
+typedef XrResult (XRAPI_PTR *PFN_xrLocateSpatialContainerViewsEXT)(XrSession session, const XrSpatialContainerViewsLocateInfoEXT* locateInfo, uint32_t viewStateCount, XrSpatialContainerViewStateEXT* viewStates, uint32_t viewCount, XrView* views);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrBeginSpatialContainerRenderingEXT(
+    XrSession                                   session,
+    const XrSpatialContainerBeginInfoEXT*       beginInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrEndSpatialContainerRenderingEXT(
+    XrSession                                   session,
+    const XrSpatialContainerEndInfoEXT*         endInfo);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrLocateSpatialContainerViewsEXT(
+    XrSession                                   session,
+    const XrSpatialContainerViewsLocateInfoEXT* locateInfo,
+    uint32_t                                    viewStateCount,
+    XrSpatialContainerViewStateEXT*             viewStates,
+    uint32_t                                    viewCount,
+    XrView*                                     views);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+
+
+// XR_EXT_interaction_profile_battery_state_display is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_interaction_profile_battery_state_display 1
+#define XR_EXT_interaction_profile_battery_state_display_SPEC_VERSION 1
+#define XR_EXT_INTERACTION_PROFILE_BATTERY_STATE_DISPLAY_EXTENSION_NAME "XR_EXT_interaction_profile_battery_state_display"
+typedef XrFlags64 XrBatteryStateDisplayStateFlagsEXT;
+
+// Flag bits for XrBatteryStateDisplayStateFlagsEXT
+static const XrBatteryStateDisplayStateFlagsEXT XR_BATTERY_STATE_DISPLAY_STATE_VALID_BIT_EXT = 0x00000001;
+static const XrBatteryStateDisplayStateFlagsEXT XR_BATTERY_STATE_DISPLAY_STATE_CHARGING_BIT_EXT = 0x00000002;
+static const XrBatteryStateDisplayStateFlagsEXT XR_BATTERY_STATE_DISPLAY_STATE_PLUGGED_IN_BIT_EXT = 0x00000004;
+static const XrBatteryStateDisplayStateFlagsEXT XR_BATTERY_STATE_DISPLAY_STATE_NO_BATTERY_BIT_EXT = 0x00000008;
+
+// XrBatteryStateDisplayEXT extends XrInteractionProfileState
+typedef struct XrBatteryStateDisplayEXT {
+    XrStructureType                       type;
+    void* XR_MAY_ALIAS                    next;
+    XrBatteryStateDisplayStateFlagsEXT    stateFlags;
+    float                                 batteryLevel;
+} XrBatteryStateDisplayEXT;
+
+
+
+// XR_EXT_loader_init_properties is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_loader_init_properties 1
+#define XR_EXT_loader_init_properties_SPEC_VERSION 1
+#define XR_EXT_LOADER_INIT_PROPERTIES_EXTENSION_NAME "XR_EXT_loader_init_properties"
+typedef struct XrLoaderInitPropertyValueEXT {
+    const char*    name;
+    const char*    value;
+} XrLoaderInitPropertyValueEXT;
+
+// XrLoaderInitInfoPropertiesEXT extends XrLoaderInitInfoBaseHeaderKHR
+typedef struct XrLoaderInitInfoPropertiesEXT {
+    XrStructureType                        type;
+    const void* XR_MAY_ALIAS               next;
+    uint32_t                               propertyValueCount;
+    const XrLoaderInitPropertyValueEXT*    propertyValues;
+} XrLoaderInitInfoPropertiesEXT;
+
+
+
+// XR_EXT_view_configuration_views_change is a preprocessor guard. Do not pass it to API calls.
+#define XR_EXT_view_configuration_views_change 1
+#define XR_EXT_view_configuration_views_change_SPEC_VERSION 1
+#define XR_EXT_VIEW_CONFIGURATION_VIEWS_CHANGE_EXTENSION_NAME "XR_EXT_view_configuration_views_change"
+typedef struct XrEventDataViewConfigurationViewsChangedEXT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSystemId                  systemId;
+    XrViewConfigurationType     viewConfigurationType;
+} XrEventDataViewConfigurationViewsChangedEXT;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/frame/openxr-compat/vendor/openxr/openxr_platform.h b/frame/openxr-compat/vendor/openxr/openxr_platform.h
new file mode 100644
index 0000000..9de27ad
--- /dev/null
+++ b/frame/openxr-compat/vendor/openxr/openxr_platform.h
@@ -0,0 +1,819 @@
+#ifndef OPENXR_PLATFORM_H_
+#define OPENXR_PLATFORM_H_ 1
+
+/*
+** Copyright 2017-2026 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0 OR MIT
+*/
+
+/*
+** This header is generated from the Khronos OpenXR XML API Registry.
+**
+*/
+
+#include "openxr.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifdef XR_USE_PLATFORM_ANDROID
+
+// XR_KHR_android_thread_settings is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_android_thread_settings 1
+#define XR_KHR_android_thread_settings_SPEC_VERSION 6
+#define XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME "XR_KHR_android_thread_settings"
+
+typedef enum XrAndroidThreadTypeKHR {
+    XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR = 1,
+    XR_ANDROID_THREAD_TYPE_APPLICATION_WORKER_KHR = 2,
+    XR_ANDROID_THREAD_TYPE_RENDERER_MAIN_KHR = 3,
+    XR_ANDROID_THREAD_TYPE_RENDERER_WORKER_KHR = 4,
+    XR_ANDROID_THREAD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} XrAndroidThreadTypeKHR;
+typedef XrResult (XRAPI_PTR *PFN_xrSetAndroidApplicationThreadKHR)(XrSession session, XrAndroidThreadTypeKHR threadType, uint32_t threadId);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrSetAndroidApplicationThreadKHR(
+    XrSession                                   session,
+    XrAndroidThreadTypeKHR                      threadType,
+    uint32_t                                    threadId);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_PLATFORM_ANDROID */
+
+#ifdef XR_USE_PLATFORM_ANDROID
+
+// XR_KHR_android_surface_swapchain is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_android_surface_swapchain 1
+#define XR_KHR_android_surface_swapchain_SPEC_VERSION 4
+#define XR_KHR_ANDROID_SURFACE_SWAPCHAIN_EXTENSION_NAME "XR_KHR_android_surface_swapchain"
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSwapchainAndroidSurfaceKHR)(XrSession session, const XrSwapchainCreateInfo* info, XrSwapchain* swapchain, jobject* surface);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSwapchainAndroidSurfaceKHR(
+    XrSession                                   session,
+    const XrSwapchainCreateInfo*                info,
+    XrSwapchain*                                swapchain,
+    jobject*                                    surface);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_PLATFORM_ANDROID */
+
+#ifdef XR_USE_PLATFORM_ANDROID
+
+// XR_KHR_android_create_instance is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_android_create_instance 1
+#define XR_KHR_android_create_instance_SPEC_VERSION 3
+#define XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME "XR_KHR_android_create_instance"
+// XrInstanceCreateInfoAndroidKHR extends XrInstanceCreateInfo
+typedef struct XrInstanceCreateInfoAndroidKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    void* XR_MAY_ALIAS          applicationVM;
+    void* XR_MAY_ALIAS          applicationActivity;
+} XrInstanceCreateInfoAndroidKHR;
+
+#endif /* XR_USE_PLATFORM_ANDROID */
+
+#ifdef XR_USE_GRAPHICS_API_VULKAN
+
+// XR_KHR_vulkan_swapchain_format_list is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_vulkan_swapchain_format_list 1
+#define XR_KHR_vulkan_swapchain_format_list_SPEC_VERSION 5
+#define XR_KHR_VULKAN_SWAPCHAIN_FORMAT_LIST_EXTENSION_NAME "XR_KHR_vulkan_swapchain_format_list"
+// XrVulkanSwapchainFormatListCreateInfoKHR extends XrSwapchainCreateInfo
+typedef struct XrVulkanSwapchainFormatListCreateInfoKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    uint32_t                    viewFormatCount;
+    const VkFormat*             viewFormats;
+} XrVulkanSwapchainFormatListCreateInfoKHR;
+
+#endif /* XR_USE_GRAPHICS_API_VULKAN */
+
+#ifdef XR_USE_GRAPHICS_API_OPENGL
+
+// XR_KHR_opengl_enable is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_opengl_enable 1
+#define XR_KHR_opengl_enable_SPEC_VERSION 12
+#define XR_KHR_OPENGL_ENABLE_EXTENSION_NAME "XR_KHR_opengl_enable"
+#ifdef XR_USE_PLATFORM_WIN32
+// XrGraphicsBindingOpenGLWin32KHR extends XrSessionCreateInfo
+typedef struct XrGraphicsBindingOpenGLWin32KHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    HDC                         hDC;
+    HGLRC                       hGLRC;
+} XrGraphicsBindingOpenGLWin32KHR;
+#endif // XR_USE_PLATFORM_WIN32
+
+#ifdef XR_USE_PLATFORM_XLIB
+// XrGraphicsBindingOpenGLXlibKHR extends XrSessionCreateInfo
+typedef struct XrGraphicsBindingOpenGLXlibKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    Display*                    xDisplay;
+    uint32_t                    visualid;
+    GLXFBConfig                 glxFBConfig;
+    GLXDrawable                 glxDrawable;
+    GLXContext                  glxContext;
+} XrGraphicsBindingOpenGLXlibKHR;
+#endif // XR_USE_PLATFORM_XLIB
+
+#ifdef XR_USE_PLATFORM_XCB
+// XrGraphicsBindingOpenGLXcbKHR extends XrSessionCreateInfo
+typedef struct XrGraphicsBindingOpenGLXcbKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    xcb_connection_t*           connection;
+    uint32_t                    screenNumber;
+    xcb_glx_fbconfig_t          fbconfigid;
+    xcb_visualid_t              visualid;
+    xcb_glx_drawable_t          glxDrawable;
+    xcb_glx_context_t           glxContext;
+} XrGraphicsBindingOpenGLXcbKHR;
+#endif // XR_USE_PLATFORM_XCB
+
+#ifdef XR_USE_PLATFORM_WAYLAND
+// XrGraphicsBindingOpenGLWaylandKHR extends XrSessionCreateInfo
+typedef struct XrGraphicsBindingOpenGLWaylandKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    struct wl_display*          display;
+} XrGraphicsBindingOpenGLWaylandKHR;
+#endif // XR_USE_PLATFORM_WAYLAND
+
+typedef struct XrSwapchainImageOpenGLKHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              image;
+} XrSwapchainImageOpenGLKHR;
+
+typedef struct XrGraphicsRequirementsOpenGLKHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrVersion             minApiVersionSupported;
+    XrVersion             maxApiVersionSupported;
+} XrGraphicsRequirementsOpenGLKHR;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetOpenGLGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLKHR* graphicsRequirements);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetOpenGLGraphicsRequirementsKHR(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrGraphicsRequirementsOpenGLKHR*            graphicsRequirements);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_GRAPHICS_API_OPENGL */
+
+#ifdef XR_USE_GRAPHICS_API_OPENGL_ES
+
+// XR_KHR_opengl_es_enable is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_opengl_es_enable 1
+#define XR_KHR_opengl_es_enable_SPEC_VERSION 10
+#define XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME "XR_KHR_opengl_es_enable"
+#ifdef XR_USE_PLATFORM_ANDROID
+// XrGraphicsBindingOpenGLESAndroidKHR extends XrSessionCreateInfo
+typedef struct XrGraphicsBindingOpenGLESAndroidKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    EGLDisplay                  display;
+    EGLConfig                   config;
+    EGLContext                  context;
+} XrGraphicsBindingOpenGLESAndroidKHR;
+#endif // XR_USE_PLATFORM_ANDROID
+
+typedef struct XrSwapchainImageOpenGLESKHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              image;
+} XrSwapchainImageOpenGLESKHR;
+
+typedef struct XrGraphicsRequirementsOpenGLESKHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrVersion             minApiVersionSupported;
+    XrVersion             maxApiVersionSupported;
+} XrGraphicsRequirementsOpenGLESKHR;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetOpenGLESGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLESKHR* graphicsRequirements);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetOpenGLESGraphicsRequirementsKHR(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrGraphicsRequirementsOpenGLESKHR*          graphicsRequirements);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_GRAPHICS_API_OPENGL_ES */
+
+#ifdef XR_USE_GRAPHICS_API_VULKAN
+
+// XR_KHR_vulkan_enable is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_vulkan_enable 1
+#define XR_KHR_vulkan_enable_SPEC_VERSION 10
+#define XR_KHR_VULKAN_ENABLE_EXTENSION_NAME "XR_KHR_vulkan_enable"
+// XrGraphicsBindingVulkanKHR extends XrSessionCreateInfo
+typedef struct XrGraphicsBindingVulkanKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    VkInstance                  instance;
+    VkPhysicalDevice            physicalDevice;
+    VkDevice                    device;
+    uint32_t                    queueFamilyIndex;
+    uint32_t                    queueIndex;
+} XrGraphicsBindingVulkanKHR;
+
+typedef struct XrSwapchainImageVulkanKHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    VkImage               image;
+} XrSwapchainImageVulkanKHR;
+
+typedef struct XrGraphicsRequirementsVulkanKHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrVersion             minApiVersionSupported;
+    XrVersion             maxApiVersionSupported;
+} XrGraphicsRequirementsVulkanKHR;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanInstanceExtensionsKHR)(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanDeviceExtensionsKHR)(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer);
+typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsDeviceKHR)(XrInstance instance, XrSystemId systemId, VkInstance vkInstance, VkPhysicalDevice* vkPhysicalDevice);
+typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR* graphicsRequirements);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanInstanceExtensionsKHR(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    char*                                       buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanDeviceExtensionsKHR(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    uint32_t                                    bufferCapacityInput,
+    uint32_t*                                   bufferCountOutput,
+    char*                                       buffer);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsDeviceKHR(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    VkInstance                                  vkInstance,
+    VkPhysicalDevice*                           vkPhysicalDevice);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsRequirementsKHR(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrGraphicsRequirementsVulkanKHR*            graphicsRequirements);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_GRAPHICS_API_VULKAN */
+
+#ifdef XR_USE_GRAPHICS_API_D3D11
+
+// XR_KHR_D3D11_enable is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_D3D11_enable 1
+#define XR_KHR_D3D11_enable_SPEC_VERSION  11
+#define XR_KHR_D3D11_ENABLE_EXTENSION_NAME "XR_KHR_D3D11_enable"
+// XrGraphicsBindingD3D11KHR extends XrSessionCreateInfo
+typedef struct XrGraphicsBindingD3D11KHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    ID3D11Device*               device;
+} XrGraphicsBindingD3D11KHR;
+
+typedef struct XrSwapchainImageD3D11KHR {
+     XrStructureType      type;
+    void* XR_MAY_ALIAS    next;
+    ID3D11Texture2D*      texture;
+} XrSwapchainImageD3D11KHR;
+
+typedef struct XrGraphicsRequirementsD3D11KHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    LUID                  adapterLuid;
+    D3D_FEATURE_LEVEL     minFeatureLevel;
+} XrGraphicsRequirementsD3D11KHR;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetD3D11GraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsD3D11KHR* graphicsRequirements);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetD3D11GraphicsRequirementsKHR(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrGraphicsRequirementsD3D11KHR*             graphicsRequirements);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_GRAPHICS_API_D3D11 */
+
+#ifdef XR_USE_GRAPHICS_API_D3D12
+
+// XR_KHR_D3D12_enable is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_D3D12_enable 1
+#define XR_KHR_D3D12_enable_SPEC_VERSION  11
+#define XR_KHR_D3D12_ENABLE_EXTENSION_NAME "XR_KHR_D3D12_enable"
+// XrGraphicsBindingD3D12KHR extends XrSessionCreateInfo
+typedef struct XrGraphicsBindingD3D12KHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    ID3D12Device*               device;
+    ID3D12CommandQueue*         queue;
+} XrGraphicsBindingD3D12KHR;
+
+typedef struct XrSwapchainImageD3D12KHR {
+     XrStructureType      type;
+    void* XR_MAY_ALIAS    next;
+    ID3D12Resource*       texture;
+} XrSwapchainImageD3D12KHR;
+
+typedef struct XrGraphicsRequirementsD3D12KHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    LUID                  adapterLuid;
+    D3D_FEATURE_LEVEL     minFeatureLevel;
+} XrGraphicsRequirementsD3D12KHR;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetD3D12GraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsD3D12KHR* graphicsRequirements);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetD3D12GraphicsRequirementsKHR(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrGraphicsRequirementsD3D12KHR*             graphicsRequirements);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_GRAPHICS_API_D3D12 */
+
+#ifdef XR_USE_GRAPHICS_API_METAL
+
+// XR_KHR_metal_enable is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_metal_enable 1
+#define XR_KHR_metal_enable_SPEC_VERSION  3
+#define XR_KHR_METAL_ENABLE_EXTENSION_NAME "XR_KHR_metal_enable"
+// XrGraphicsBindingMetalKHR extends XrSessionCreateInfo
+typedef struct XrGraphicsBindingMetalKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    void* XR_MAY_ALIAS          commandQueue;
+} XrGraphicsBindingMetalKHR;
+
+typedef struct XrSwapchainImageMetalKHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    void* XR_MAY_ALIAS    texture;
+} XrSwapchainImageMetalKHR;
+
+typedef struct XrGraphicsRequirementsMetalKHR {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    void* XR_MAY_ALIAS    metalDevice;
+} XrGraphicsRequirementsMetalKHR;
+
+typedef XrResult (XRAPI_PTR *PFN_xrGetMetalGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsMetalKHR* graphicsRequirements);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetMetalGraphicsRequirementsKHR(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrGraphicsRequirementsMetalKHR*             graphicsRequirements);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_GRAPHICS_API_METAL */
+
+#ifdef XR_USE_PLATFORM_WIN32
+
+// XR_KHR_win32_convert_performance_counter_time is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_win32_convert_performance_counter_time 1
+#define XR_KHR_win32_convert_performance_counter_time_SPEC_VERSION 1
+#define XR_KHR_WIN32_CONVERT_PERFORMANCE_COUNTER_TIME_EXTENSION_NAME "XR_KHR_win32_convert_performance_counter_time"
+typedef XrResult (XRAPI_PTR *PFN_xrConvertWin32PerformanceCounterToTimeKHR)(XrInstance instance, const LARGE_INTEGER* performanceCounter, XrTime* time);
+typedef XrResult (XRAPI_PTR *PFN_xrConvertTimeToWin32PerformanceCounterKHR)(XrInstance instance, XrTime time, LARGE_INTEGER* performanceCounter);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrConvertWin32PerformanceCounterToTimeKHR(
+    XrInstance                                  instance,
+    const LARGE_INTEGER*                        performanceCounter,
+    XrTime*                                     time);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrConvertTimeToWin32PerformanceCounterKHR(
+    XrInstance                                  instance,
+    XrTime                                      time,
+    LARGE_INTEGER*                              performanceCounter);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_PLATFORM_WIN32 */
+
+#ifdef XR_USE_TIMESPEC
+
+// XR_KHR_convert_timespec_time is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_convert_timespec_time 1
+#define XR_KHR_convert_timespec_time_SPEC_VERSION 1
+#define XR_KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME "XR_KHR_convert_timespec_time"
+typedef XrResult (XRAPI_PTR *PFN_xrConvertTimespecTimeToTimeKHR)(XrInstance instance, const struct timespec* timespecTime, XrTime* time);
+typedef XrResult (XRAPI_PTR *PFN_xrConvertTimeToTimespecTimeKHR)(XrInstance instance, XrTime time, struct timespec* timespecTime);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrConvertTimespecTimeToTimeKHR(
+    XrInstance                                  instance,
+    const struct timespec*                      timespecTime,
+    XrTime*                                     time);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrConvertTimeToTimespecTimeKHR(
+    XrInstance                                  instance,
+    XrTime                                      time,
+    struct timespec*                            timespecTime);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_TIMESPEC */
+
+#ifdef XR_USE_PLATFORM_ANDROID
+
+// XR_KHR_loader_init_android is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_loader_init_android 1
+#define XR_KHR_loader_init_android_SPEC_VERSION 1
+#define XR_KHR_LOADER_INIT_ANDROID_EXTENSION_NAME "XR_KHR_loader_init_android"
+typedef struct XrLoaderInitInfoAndroidKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    void* XR_MAY_ALIAS          applicationVM;
+    void* XR_MAY_ALIAS          applicationContext;
+} XrLoaderInitInfoAndroidKHR;
+
+#endif /* XR_USE_PLATFORM_ANDROID */
+
+#ifdef XR_USE_GRAPHICS_API_VULKAN
+
+// XR_KHR_vulkan_enable2 is a preprocessor guard. Do not pass it to API calls.
+#define XR_KHR_vulkan_enable2 1
+#define XR_KHR_vulkan_enable2_SPEC_VERSION 4
+#define XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME "XR_KHR_vulkan_enable2"
+typedef XrFlags64 XrVulkanInstanceCreateFlagsKHR;
+
+// Flag bits for XrVulkanInstanceCreateFlagsKHR
+
+typedef XrFlags64 XrVulkanDeviceCreateFlagsKHR;
+
+// Flag bits for XrVulkanDeviceCreateFlagsKHR
+
+typedef struct XrVulkanInstanceCreateInfoKHR {
+    XrStructureType                   type;
+    const void* XR_MAY_ALIAS          next;
+    XrSystemId                        systemId;
+    XrVulkanInstanceCreateFlagsKHR    createFlags;
+    PFN_vkGetInstanceProcAddr         pfnGetInstanceProcAddr;
+    const VkInstanceCreateInfo*       vulkanCreateInfo;
+    const VkAllocationCallbacks*      vulkanAllocator;
+} XrVulkanInstanceCreateInfoKHR;
+
+typedef struct XrVulkanDeviceCreateInfoKHR {
+    XrStructureType                 type;
+    const void* XR_MAY_ALIAS        next;
+    XrSystemId                      systemId;
+    XrVulkanDeviceCreateFlagsKHR    createFlags;
+    PFN_vkGetInstanceProcAddr       pfnGetInstanceProcAddr;
+    VkPhysicalDevice                vulkanPhysicalDevice;
+    const VkDeviceCreateInfo*       vulkanCreateInfo;
+    const VkAllocationCallbacks*    vulkanAllocator;
+} XrVulkanDeviceCreateInfoKHR;
+
+typedef XrGraphicsBindingVulkanKHR XrGraphicsBindingVulkan2KHR;
+
+typedef struct XrVulkanGraphicsDeviceGetInfoKHR {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSystemId                  systemId;
+    VkInstance                  vulkanInstance;
+} XrVulkanGraphicsDeviceGetInfoKHR;
+
+typedef XrSwapchainImageVulkanKHR XrSwapchainImageVulkan2KHR;
+
+typedef XrGraphicsRequirementsVulkanKHR XrGraphicsRequirementsVulkan2KHR;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanInstanceKHR)(XrInstance instance, const XrVulkanInstanceCreateInfoKHR* createInfo, VkInstance* vulkanInstance, VkResult* vulkanResult);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanDeviceKHR)(XrInstance instance, const XrVulkanDeviceCreateInfoKHR* createInfo, VkDevice* vulkanDevice, VkResult* vulkanResult);
+typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsDevice2KHR)(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR* getInfo, VkPhysicalDevice* vulkanPhysicalDevice);
+typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsRequirements2KHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR* graphicsRequirements);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateVulkanInstanceKHR(
+    XrInstance                                  instance,
+    const XrVulkanInstanceCreateInfoKHR*        createInfo,
+    VkInstance*                                 vulkanInstance,
+    VkResult*                                   vulkanResult);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateVulkanDeviceKHR(
+    XrInstance                                  instance,
+    const XrVulkanDeviceCreateInfoKHR*          createInfo,
+    VkDevice*                                   vulkanDevice,
+    VkResult*                                   vulkanResult);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsDevice2KHR(
+    XrInstance                                  instance,
+    const XrVulkanGraphicsDeviceGetInfoKHR*     getInfo,
+    VkPhysicalDevice*                           vulkanPhysicalDevice);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsRequirements2KHR(
+    XrInstance                                  instance,
+    XrSystemId                                  systemId,
+    XrGraphicsRequirementsVulkanKHR*            graphicsRequirements);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_GRAPHICS_API_VULKAN */
+
+#ifdef XR_USE_PLATFORM_EGL
+
+// XR_MNDX_egl_enable is a preprocessor guard. Do not pass it to API calls.
+#define XR_MNDX_egl_enable 1
+#define XR_MNDX_egl_enable_SPEC_VERSION   2
+#define XR_MNDX_EGL_ENABLE_EXTENSION_NAME "XR_MNDX_egl_enable"
+typedef PFN_xrVoidFunction (*PFN_xrEglGetProcAddressMNDX)(const char *name);
+// XrGraphicsBindingEGLMNDX extends XrSessionCreateInfo
+typedef struct XrGraphicsBindingEGLMNDX {
+    XrStructureType                type;
+    const void* XR_MAY_ALIAS       next;
+    PFN_xrEglGetProcAddressMNDX    getProcAddress;
+    EGLDisplay                     display;
+    EGLConfig                      config;
+    EGLContext                     context;
+} XrGraphicsBindingEGLMNDX;
+
+#endif /* XR_USE_PLATFORM_EGL */
+
+#ifdef XR_USE_PLATFORM_WIN32
+
+// XR_MSFT_perception_anchor_interop is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_perception_anchor_interop 1
+#define XR_MSFT_perception_anchor_interop_SPEC_VERSION 1
+#define XR_MSFT_PERCEPTION_ANCHOR_INTEROP_EXTENSION_NAME "XR_MSFT_perception_anchor_interop"
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFromPerceptionAnchorMSFT)(XrSession session, IUnknown* perceptionAnchor, XrSpatialAnchorMSFT* anchor);
+typedef XrResult (XRAPI_PTR *PFN_xrTryGetPerceptionAnchorFromSpatialAnchorMSFT)(XrSession session, XrSpatialAnchorMSFT anchor, IUnknown** perceptionAnchor);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorFromPerceptionAnchorMSFT(
+    XrSession                                   session,
+    IUnknown*                                   perceptionAnchor,
+    XrSpatialAnchorMSFT*                        anchor);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrTryGetPerceptionAnchorFromSpatialAnchorMSFT(
+    XrSession                                   session,
+    XrSpatialAnchorMSFT                         anchor,
+    IUnknown**                                  perceptionAnchor);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_PLATFORM_WIN32 */
+
+#ifdef XR_USE_PLATFORM_WIN32
+
+// XR_MSFT_holographic_window_attachment is a preprocessor guard. Do not pass it to API calls.
+#define XR_MSFT_holographic_window_attachment 1
+#define XR_MSFT_holographic_window_attachment_SPEC_VERSION 1
+#define XR_MSFT_HOLOGRAPHIC_WINDOW_ATTACHMENT_EXTENSION_NAME "XR_MSFT_holographic_window_attachment"
+#ifdef XR_USE_PLATFORM_WIN32
+// XrHolographicWindowAttachmentMSFT extends XrSessionCreateInfo
+typedef struct XrHolographicWindowAttachmentMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    IUnknown*                   holographicSpace;
+    IUnknown*                   coreWindow;
+} XrHolographicWindowAttachmentMSFT;
+#endif // XR_USE_PLATFORM_WIN32
+
+#endif /* XR_USE_PLATFORM_WIN32 */
+
+#ifdef XR_USE_PLATFORM_ANDROID
+
+// XR_FB_android_surface_swapchain_create is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_android_surface_swapchain_create 1
+#define XR_FB_android_surface_swapchain_create_SPEC_VERSION 1
+#define XR_FB_ANDROID_SURFACE_SWAPCHAIN_CREATE_EXTENSION_NAME "XR_FB_android_surface_swapchain_create"
+typedef XrFlags64 XrAndroidSurfaceSwapchainFlagsFB;
+
+// Flag bits for XrAndroidSurfaceSwapchainFlagsFB
+static const XrAndroidSurfaceSwapchainFlagsFB XR_ANDROID_SURFACE_SWAPCHAIN_SYNCHRONOUS_BIT_FB = 0x00000001;
+static const XrAndroidSurfaceSwapchainFlagsFB XR_ANDROID_SURFACE_SWAPCHAIN_USE_TIMESTAMPS_BIT_FB = 0x00000002;
+
+#ifdef XR_USE_PLATFORM_ANDROID
+// XrAndroidSurfaceSwapchainCreateInfoFB extends XrSwapchainCreateInfo
+typedef struct XrAndroidSurfaceSwapchainCreateInfoFB {
+    XrStructureType                     type;
+    const void* XR_MAY_ALIAS            next;
+    XrAndroidSurfaceSwapchainFlagsFB    createFlags;
+} XrAndroidSurfaceSwapchainCreateInfoFB;
+#endif // XR_USE_PLATFORM_ANDROID
+
+#endif /* XR_USE_PLATFORM_ANDROID */
+
+#ifdef XR_USE_PLATFORM_ML
+
+// XR_ML_compat is a preprocessor guard. Do not pass it to API calls.
+#define XR_ML_compat 1
+#define XR_ML_compat_SPEC_VERSION         1
+#define XR_ML_COMPAT_EXTENSION_NAME       "XR_ML_compat"
+typedef struct XrCoordinateSpaceCreateInfoML {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    MLCoordinateFrameUID        cfuid;
+    XrPosef                     poseInCoordinateSpace;
+} XrCoordinateSpaceCreateInfoML;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpaceFromCoordinateFrameUIDML)(XrSession session, const XrCoordinateSpaceCreateInfoML *createInfo, XrSpace* space);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpaceFromCoordinateFrameUIDML(
+    XrSession                                   session,
+    const XrCoordinateSpaceCreateInfoML *       createInfo,
+    XrSpace*                                    space);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_PLATFORM_ML */
+
+#ifdef XR_USE_PLATFORM_WIN32
+
+// XR_OCULUS_audio_device_guid is a preprocessor guard. Do not pass it to API calls.
+#define XR_OCULUS_audio_device_guid 1
+#define XR_OCULUS_audio_device_guid_SPEC_VERSION 1
+#define XR_OCULUS_AUDIO_DEVICE_GUID_EXTENSION_NAME "XR_OCULUS_audio_device_guid"
+#define XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS 128
+typedef XrResult (XRAPI_PTR *PFN_xrGetAudioOutputDeviceGuidOculus)(XrInstance instance, wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]);
+typedef XrResult (XRAPI_PTR *PFN_xrGetAudioInputDeviceGuidOculus)(XrInstance instance, wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrGetAudioOutputDeviceGuidOculus(
+    XrInstance                                  instance,
+    wchar_t                                     buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrGetAudioInputDeviceGuidOculus(
+    XrInstance                                  instance,
+    wchar_t                                     buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_PLATFORM_WIN32 */
+
+#ifdef XR_USE_GRAPHICS_API_VULKAN
+
+// XR_FB_foveation_vulkan is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_foveation_vulkan 1
+#define XR_FB_foveation_vulkan_SPEC_VERSION 1
+#define XR_FB_FOVEATION_VULKAN_EXTENSION_NAME "XR_FB_foveation_vulkan"
+// XrSwapchainImageFoveationVulkanFB extends XrSwapchainImageVulkanKHR
+typedef struct XrSwapchainImageFoveationVulkanFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    VkImage               image;
+    uint32_t              width;
+    uint32_t              height;
+} XrSwapchainImageFoveationVulkanFB;
+
+#endif /* XR_USE_GRAPHICS_API_VULKAN */
+
+#ifdef XR_USE_PLATFORM_ANDROID
+
+// XR_FB_swapchain_update_state_android_surface is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_swapchain_update_state_android_surface 1
+#define XR_FB_swapchain_update_state_android_surface_SPEC_VERSION 1
+#define XR_FB_SWAPCHAIN_UPDATE_STATE_ANDROID_SURFACE_EXTENSION_NAME "XR_FB_swapchain_update_state_android_surface"
+#ifdef XR_USE_PLATFORM_ANDROID
+typedef struct XrSwapchainStateAndroidSurfaceDimensionsFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    uint32_t              width;
+    uint32_t              height;
+} XrSwapchainStateAndroidSurfaceDimensionsFB;
+#endif // XR_USE_PLATFORM_ANDROID
+
+#endif /* XR_USE_PLATFORM_ANDROID */
+
+#ifdef XR_USE_GRAPHICS_API_OPENGL_ES
+
+// XR_FB_swapchain_update_state_opengl_es is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_swapchain_update_state_opengl_es 1
+#define XR_FB_swapchain_update_state_opengl_es_SPEC_VERSION 1
+#define XR_FB_SWAPCHAIN_UPDATE_STATE_OPENGL_ES_EXTENSION_NAME "XR_FB_swapchain_update_state_opengl_es"
+#ifdef XR_USE_GRAPHICS_API_OPENGL_ES
+typedef struct XrSwapchainStateSamplerOpenGLESFB {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    EGLenum               minFilter;
+    EGLenum               magFilter;
+    EGLenum               wrapModeS;
+    EGLenum               wrapModeT;
+    EGLenum               swizzleRed;
+    EGLenum               swizzleGreen;
+    EGLenum               swizzleBlue;
+    EGLenum               swizzleAlpha;
+    float                 maxAnisotropy;
+    XrColor4f             borderColor;
+} XrSwapchainStateSamplerOpenGLESFB;
+#endif // XR_USE_GRAPHICS_API_OPENGL_ES
+
+#endif /* XR_USE_GRAPHICS_API_OPENGL_ES */
+
+#ifdef XR_USE_GRAPHICS_API_VULKAN
+
+// XR_FB_swapchain_update_state_vulkan is a preprocessor guard. Do not pass it to API calls.
+#define XR_FB_swapchain_update_state_vulkan 1
+#define XR_FB_swapchain_update_state_vulkan_SPEC_VERSION 1
+#define XR_FB_SWAPCHAIN_UPDATE_STATE_VULKAN_EXTENSION_NAME "XR_FB_swapchain_update_state_vulkan"
+#ifdef XR_USE_GRAPHICS_API_VULKAN
+typedef struct XrSwapchainStateSamplerVulkanFB {
+    XrStructureType         type;
+    void* XR_MAY_ALIAS      next;
+    VkFilter                minFilter;
+    VkFilter                magFilter;
+    VkSamplerMipmapMode     mipmapMode;
+    VkSamplerAddressMode    wrapModeS;
+    VkSamplerAddressMode    wrapModeT;
+    VkComponentSwizzle      swizzleRed;
+    VkComponentSwizzle      swizzleGreen;
+    VkComponentSwizzle      swizzleBlue;
+    VkComponentSwizzle      swizzleAlpha;
+    float                   maxAnisotropy;
+    XrColor4f               borderColor;
+} XrSwapchainStateSamplerVulkanFB;
+#endif // XR_USE_GRAPHICS_API_VULKAN
+
+#endif /* XR_USE_GRAPHICS_API_VULKAN */
+
+#ifdef XR_USE_GRAPHICS_API_VULKAN
+
+// XR_META_vulkan_swapchain_create_info is a preprocessor guard. Do not pass it to API calls.
+#define XR_META_vulkan_swapchain_create_info 1
+#define XR_META_vulkan_swapchain_create_info_SPEC_VERSION 1
+#define XR_META_VULKAN_SWAPCHAIN_CREATE_INFO_EXTENSION_NAME "XR_META_vulkan_swapchain_create_info"
+// XrVulkanSwapchainCreateInfoMETA extends XrSwapchainCreateInfo
+typedef struct XrVulkanSwapchainCreateInfoMETA {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    VkImageCreateFlags          additionalCreateFlags;
+    VkImageUsageFlags           additionalUsageFlags;
+} XrVulkanSwapchainCreateInfoMETA;
+
+#endif /* XR_USE_GRAPHICS_API_VULKAN */
+
+#ifdef XR_USE_PLATFORM_ANDROID
+
+// XR_ANDROID_anchor_sharing_export is a preprocessor guard. Do not pass it to API calls.
+#define XR_ANDROID_anchor_sharing_export 1
+#define XR_ANDROID_anchor_sharing_export_SPEC_VERSION 1
+#define XR_ANDROID_ANCHOR_SHARING_EXPORT_EXTENSION_NAME "XR_ANDROID_anchor_sharing_export"
+typedef struct XrAnchorSharingInfoANDROID {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     anchor;
+} XrAnchorSharingInfoANDROID;
+
+typedef struct XrAnchorSharingTokenANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    struct AIBinder*      token;
+} XrAnchorSharingTokenANDROID;
+
+// XrSystemAnchorSharingExportPropertiesANDROID extends XrSystemProperties
+typedef struct XrSystemAnchorSharingExportPropertiesANDROID {
+    XrStructureType       type;
+    void* XR_MAY_ALIAS    next;
+    XrBool32              supportsAnchorSharingExport;
+} XrSystemAnchorSharingExportPropertiesANDROID;
+
+typedef XrResult (XRAPI_PTR *PFN_xrShareAnchorANDROID)(XrSession session, const XrAnchorSharingInfoANDROID* sharingInfo, XrAnchorSharingTokenANDROID* anchorToken);
+typedef XrResult (XRAPI_PTR *PFN_xrUnshareAnchorANDROID)(XrSession session, XrSpace anchor);
+
+#ifndef XR_NO_PROTOTYPES
+#ifdef XR_EXTENSION_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrShareAnchorANDROID(
+    XrSession                                   session,
+    const XrAnchorSharingInfoANDROID*           sharingInfo,
+    XrAnchorSharingTokenANDROID*                anchorToken);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrUnshareAnchorANDROID(
+    XrSession                                   session,
+    XrSpace                                     anchor);
+#endif /* XR_EXTENSION_PROTOTYPES */
+#endif /* !XR_NO_PROTOTYPES */
+#endif /* XR_USE_PLATFORM_ANDROID */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/frame/openxr-compat/vendor/openxr/openxr_platform_defines.h b/frame/openxr-compat/vendor/openxr/openxr_platform_defines.h
new file mode 100644
index 0000000..79c5b2c
--- /dev/null
+++ b/frame/openxr-compat/vendor/openxr/openxr_platform_defines.h
@@ -0,0 +1,114 @@
+/*
+** Copyright (c) 2017-2026 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0 OR MIT
+*/
+
+#ifndef OPENXR_PLATFORM_DEFINES_H_
+#define OPENXR_PLATFORM_DEFINES_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Platform-specific calling convention macros.
+ *
+ * Platforms should define these so that OpenXR clients call OpenXR functions
+ * with the same calling conventions that the OpenXR implementation expects.
+ *
+ * XRAPI_ATTR - Placed before the return type in function declarations.
+ *              Useful for C++11 and GCC/Clang-style function attribute syntax.
+ * XRAPI_CALL - Placed after the return type in function declarations.
+ *              Useful for MSVC-style calling convention syntax.
+ * XRAPI_PTR  - Placed between the '(' and '*' in function pointer types.
+ *
+ * Function declaration:  XRAPI_ATTR void XRAPI_CALL xrFunction(void);
+ * Function pointer type: typedef void (XRAPI_PTR *PFN_xrFunction)(void);
+ */
+#if defined(_WIN32)
+#define XRAPI_ATTR
+// On Windows, functions use the stdcall convention
+#define XRAPI_CALL __stdcall
+#define XRAPI_PTR XRAPI_CALL
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
+#error "API not supported for the 'armeabi' NDK ABI"
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
+// On Android 32-bit ARM targets, functions use the "hardfloat"
+// calling convention, i.e. float parameters are passed in registers. This
+// is true even if the rest of the application passes floats on the stack,
+// as it does by default when compiling for the armeabi-v7a NDK ABI.
+#define XRAPI_ATTR __attribute__((pcs("aapcs-vfp")))
+#define XRAPI_CALL
+#define XRAPI_PTR XRAPI_ATTR
+#else
+// On other platforms, use the default calling convention
+#define XRAPI_ATTR
+#define XRAPI_CALL
+#define XRAPI_PTR
+#endif
+
+#include <stddef.h>
+
+#if !defined(XR_NO_STDINT_H)
+#if defined(_MSC_VER) && (_MSC_VER < 1600)
+typedef signed __int8 int8_t;
+typedef unsigned __int8 uint8_t;
+typedef signed __int16 int16_t;
+typedef unsigned __int16 uint16_t;
+typedef signed __int32 int32_t;
+typedef unsigned __int32 uint32_t;
+typedef signed __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#else
+#include <stdint.h>
+#endif
+#endif  // !defined( XR_NO_STDINT_H )
+
+// XR_PTR_SIZE (in bytes)
+#if (defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__))
+#define XR_PTR_SIZE 8
+#else
+#define XR_PTR_SIZE 4
+#endif
+
+// Needed so we can use clang __has_feature portably.
+#if !defined(XR_COMPILER_HAS_FEATURE)
+#if defined(__clang__)
+#define XR_COMPILER_HAS_FEATURE(x) __has_feature(x)
+#else
+#define XR_COMPILER_HAS_FEATURE(x) 0
+#endif
+#endif
+
+// Identifies if the current compiler has C++11 support enabled.
+// Does not by itself identify if any given C++11 feature is present.
+#if !defined(XR_CPP11_ENABLED) && defined(__cplusplus)
+#if defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__)
+#define XR_CPP11_ENABLED 1
+#elif defined(_MSC_VER) && (_MSC_VER >= 1600)
+#define XR_CPP11_ENABLED 1
+#elif (__cplusplus >= 201103L) // 201103 is the first C++11 version.
+#define XR_CPP11_ENABLED 1
+#endif
+#endif
+
+// Identifies if the current compiler supports C++11 nullptr.
+#if !defined(XR_CPP_NULLPTR_SUPPORTED)
+#if defined(XR_CPP11_ENABLED) &&                                              \
+    ((defined(__clang__) && XR_COMPILER_HAS_FEATURE(cxx_nullptr)) ||          \
+     (defined(__GNUC__) && (((__GNUC__ * 1000) + __GNUC_MINOR__) >= 4006)) || \
+     (defined(_MSC_VER) && (_MSC_VER >= 1600)) ||                             \
+     (defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403)))
+#define XR_CPP_NULLPTR_SUPPORTED 1
+#endif
+#endif
+
+#if !defined(XR_CPP_NULLPTR_SUPPORTED)
+#define XR_CPP_NULLPTR_SUPPORTED 0
+#endif  // !defined(XR_CPP_NULLPTR_SUPPORTED)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

From 8d75ede0ab6404acf5a868c90d7709a23e3ec8a0 Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 16:29:06 +1000
Subject: [PATCH 04/12] OpenXR compat layer: keep the current refresh rate when
 SteamVR refuses a request

Quest apps ask for 72/90/120/144 Hz; SteamVR offers only the current rate and
Wolvic aborted on XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB. Verified on
the Frame: Wolvic's Quest build now reaches XR_SESSION_STATE_SYNCHRONIZED.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 frame/openxr-compat/README.md                 |   2 +-
 frame/openxr-compat/layer.cpp                 |  14 ++++++++++++++
 .../arm64-v8a/libXrApiLayer_FRAME_compat.so   | Bin 98248 -> 98936 bytes
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/frame/openxr-compat/README.md b/frame/openxr-compat/README.md
index 6c366c9..4d5eb60 100644
--- a/frame/openxr-compat/README.md
+++ b/frame/openxr-compat/README.md
@@ -238,7 +238,7 @@ from the binary; runtime execution of those paths remains unverified.
 Prebuilt library SHA-256:
 
 ```
-57abbcec6fbc6df7c79e2b9a46db1a5d8613b4db3c0d7e49bf87cb3172280d10
+aace99b7bcdb3c79fa844d75a9483f8f4b16bd6e669fb3003515df8c673ce54b
 ```
 
 APK SHA-256:
diff --git a/frame/openxr-compat/layer.cpp b/frame/openxr-compat/layer.cpp
index 3d6f9df..a5433a7 100644
--- a/frame/openxr-compat/layer.cpp
+++ b/frame/openxr-compat/layer.cpp
@@ -21,6 +21,7 @@ struct Dispatch {
     PFN_xrPathToString pathToString{};
     PFN_xrSuggestInteractionProfileBindings suggest{};
     PFN_xrSetAndroidApplicationThreadKHR thread{};
+    PFN_xrRequestDisplayRefreshRateFB refresh{};
     frame::Names enabled, stubbed;
     XrInstance instance{};
     bool promote{}, palm{};
@@ -131,6 +132,17 @@ XrResult XRAPI_CALL threadSettings(XrSession s, XrAndroidThreadTypeKHR type, uin
     }
     return d->thread ? d->thread(s, type, tid) : XR_ERROR_FUNCTION_UNSUPPORTED;
 } GUARD_END
+// SteamVR offers only the current refresh rate; Quest apps ask for 72/90/120 Hz
+// and abort on the error, so keep the current rate and report success.
+XrResult XRAPI_CALL requestRefreshRate(XrSession s, float hz) try {
+    auto d = get(s); if (!d) return XR_ERROR_HANDLE_INVALID;
+    auto r = d->refresh(s, hz);
+    if (r == XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB) {
+        LOG("xrRequestDisplayRefreshRateFB %.1f Hz unsupported; keeping the current rate", hz);
+        return XR_SUCCESS;
+    }
+    return r;
+} GUARD_END
 XrResult XRAPI_CALL stringToPath(XrInstance i, const char* path, XrPath* out) try {
     auto d = get(i); if (!d) return XR_ERROR_HANDLE_INVALID;
     if (!path) return XR_ERROR_VALIDATION_FAILURE;
@@ -224,6 +236,7 @@ XrResult XRAPI_CALL createLayer(const XrInstanceCreateInfo* info, const XrApiLay
         LOAD(suggest, xrSuggestInteractionProfileBindings);
         if (frame::has(d->enabled, "XR_KHR_locate_spaces")) LOAD(locate, xrLocateSpacesKHR);
         if (frame::has(d->enabled, frame::stubs[0])) LOAD(thread, xrSetAndroidApplicationThreadKHR);
+        if (frame::has(d->enabled, "XR_FB_display_refresh_rate")) LOAD(refresh, xrRequestDisplayRefreshRateFB);
 #undef LOAD
         if (!d->createSession || !d->destroySession || !d->stringToPath || !d->pathToString || !d->suggest) {
             d->destroy(*instance); *instance = XR_NULL_HANDLE; return XR_ERROR_INITIALIZATION_FAILED;
@@ -249,6 +262,7 @@ XrResult XRAPI_CALL gipa(XrInstance i, const char* name, PFN_xrVoidFunction* out
     RETURN_PROC("xrSuggestInteractionProfileBindings", suggest)
     if (d->locate && d->promote) { RETURN_PROC("xrLocateSpaces", locateSpaces) }
     if (frame::has(d->stubbed, frame::stubs[0])) { RETURN_PROC("xrSetAndroidApplicationThreadKHR", threadSettings) }
+    if (d->refresh) { RETURN_PROC("xrRequestDisplayRefreshRateFB", requestRefreshRate) }
 #undef RETURN_PROC
     // Includes xrGetInstanceProperties: report the actual runtime's identity.
     return d->gipa(i, name, out);
diff --git a/frame/openxr-compat/prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so b/frame/openxr-compat/prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so
index e58d223fe68c2b5c12c44da3652ca3ab908612a9..a58721a065638dde82d73ca8f733cde852743df4 100755
GIT binary patch
delta 24450
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

delta 23881
zcmc(Hdt6l2*Z$dO1{_9^0R|YZGh75jR8&M%#9=feGbOdcONzI|OG$-Ed6_}2Fs&Fj
zIaXw7T7Z`@P_V4Pw5ZImOs%ZY>KmpOCK=;bo8Pm~MUSW6&+otYozG`_&U)6`Yp=cb
zI(zSPhU{A7-Qw{oOX6FKoyiZ`+vXFFePraUg2*w}Tfw(gOLh{L=|wwBh=}TTg+-!$
zVdt$_AelFH7cOWh2?)$76m4>9Wu!w%!elw5|6kW)BaX}cxoD0SUhBt;eW=m5o5=gt
z?I(%E*l*RRr{2D@__6&{2lX&+-r;wC-^NsWj6~KMG?TTYq;5gCl^VO;w}v^!N0!^A
zG{}6>a8ci(;%!!u?^5x-M~ggHBStU#sTwBoI+3??vLbw>s4%D+Od2ZkCKbOdTjVV&
z{x``!NySf)29SCSZ|AsfqeMp;w<tJnsl;1VeCBPUeU6I1XRyfUs`!L-k<U}{U)jK;
ze=c98@EIgFC{Xc7B)(9^UzGS_72kTh=*OYrPh^OEDR|cZjVX{Dl&Kn6rMcXs;${0P
z6@N;SYgK&vS7OJFH+i9du1iuh-BbvcDJR4REh;|g7m;sO@y3%PF9#skR?}{=2-{Tl
zkLQT}bL}cc;SRAuhl;O}il|G)znm#{%t`I!j^C53UB$mPLbNy7Rf@sVoS9U-T)h?*
zFBfT&ikFKqRmBTMhrTl;-Y!Qf7nfDlV7D}~92FmzC5|9h#mhC3r{ecWcTN7SyqznQ
z=BD6Q1$WmNu>*N3<Uo_&6sM+GWj|lCFIDk!hm|TmV<+>2`L9wb@~(&-*Q)rOKSjP#
z#ZS8=@=Yo}U-HwU;)^7{mGP|p<dHQ>ic_ivi=+<PRlH6Z0mpTy_|i@>pe_|(Ch?rq
zj`b_l|Fx@P1KFV*kbK)16b+c=^HQo!D*n_iacV3oUiOou;;YAq{d1`*MXn@^b96I9
zvLma?{sSqX92GAIBKwmECf8ivPP-VftoT)ORG@NnN|Fmze3DztT(OGJk$8uSFP8W+
znYT;ZZj(f8k`)p!cTlO~D<wx&D!x_XYgN2F;zkv354cktfgFIG2|3j*ss_=LeXEL>
zGbE$hPn*hqu;|CmwW}0z<XtM>Dis$eq1-{6G-92K&yb4RpyCT8-Xid*f7y{-y-BJD
zMN)%Q6@NtHGgQ2MH^~9Z{^gA3DDBz(cbk;bT%`iMoQZrD?~vpI6)$I^P{r&1D;24V
zXPFT0f7zir(o$7}d!#_iRJ=UWN)_KE$yF*|4zzX`5&FL|1sPJLjj9InoXHN=fwrjZ
zACQYw#mj-pQ?1d8{d4l%w5b{_l^nIJczJ5NRJ=*r%s2_<K;;_JsrUlBG-88FAs3PC
zP<A8-YEjv*l>$vt@$yJhRlMvcJ42<|EIG2Oc!#v@=BW54+Uy@{e_v{qr_##Z7N~gH
zi@Yq!!>hO^m8#0VUg8}pew)bKxl)y4r_`WK#gDo!cCbmsm->ktL8XfC(20DNieE20
zKXP27z|#i;0_}22)njQ<HT_8ntyRTKW8qGzczGyoDqbE+yU5>sk{abJ#@wN5kl9V-
zyHvc9h&(4vu{;2IKsptFMw)EHE&M=^%aI&gZc%Vtfh5aEH@Slf+CMPVZj`1ZL)A*o
zhgHSP`N&c6az1iZyh$$(FHglgGy-qu@>Pl|DIap!a=3Cn3RU*rW2K^1@p3vGDqb%7
zQh~<`BzMq9a#X2maA1Hqf+`h%NaAZ%{1J(7RPly^qMs%u&sM-LNztNIfNx0?8?>tU
z(-MD5#b1#4HWhzO;@efcDP4L3?NBN5p<tgb6~9R0Iq5};oVj9&*Qxkz5^qrP?HQtf
zQ>|(T>XZ}~RfBwo5D%B6;&UZFRmES65j)6G@m296Z@s}wJCODpu>;*(qJcazhqS{O
zRJ^>0npAwAWN%UN^7$@F#V6UN^HZuyA@8*rDqil`s^T|E9p|X{%HPF-<*Io3plHui
zDdfF1U&WiG)ulki%X@2~itmsDDpvE-!O|h}H`h&*)Sy(=piO#?DpT?DbJivmuai2c
zRPkk<;?!2%!ejnRB}MHm3cMKlQ*6+v=A{mrRJ{DK(4yi?CHqq<K9yyZ)nA)RA+KER
zDt^%%F(CP!r(C4+Toy|Mk@>U`(cYor<wtHdaH0O?29CePVv$oN^G#hMze(k2^-z&-
zQt_!>V#h821K)a+7w^ARju$+&N+TwC{t6X+3;)&Ci4J-2;+3d0D0tC>$eR?rM&ZYz
z;KfHgv41W}q3}{PNLBFcb+!D-Q1H@gUqNM6@H*KTn4{o*6nw5-q0lQ7c?!O}g3nj*
zz6!oT!TTxrLIvML!52%sou$-Yp>QY~7!-V|f)7yeWePq}!EaLVK?=T7!5gI~AVFQF
zPy{O))GGK81>dOPO$xqA!G|gM76l)EgU9^0Dijen6dZR-!AC0iHU%H0;M)~^w1V$Y
z@MZ<y#dubKYziz21y_Hw+G7;FPQk}2c!PqEQ}8AQAFtpo3f|sRp-56F5)^!@f=^WN
z845m0!CMu4F9n~Y;FCpO{4FI{q3Eq>kf-2N6nwsd@1x)g>gmw<DEk2~O$BeL^3v?&
zeb;ztI(UP_OXJYAVTm9dzXAuF&&3SOO+6J3p8P_Zi19$6rk(gYf;63^3N{rQU1gA_
zQRBNaNYk$ItqRhVYIXI2nhRP(RiLKI%g_N!FT;f(O_R5wJxJ5aPNVjUZl-O4nnOD6
zwjfQ5E{EgFeB$A<-Y1Xa*6TAH12tWGLuDW-?e6OcBnP_Jl9oVn&DU@(fUNiP?Ft}G
zeg-gYeumBf(&6XZ5kR)}V9bRcz83;WR}bG)0i?p;3P<h!TJW9zCS30f&^98FfL^AS
zAkC?OQpDdD7`Z-3b1e`zNO_R9B8Y4XVyP3e(0P<T*K;(#^C&&ha{ym_l<E^6;&n&q
z6A1(O<Db#p3FG)RpV7Y)rtnFh(J6_^{Iw(Wsl>kgkt22ACqCxuEYsCZO1sUsuHO17
zse8rtuD0&=+rKAutM7PNQ`a^20<r&n$>V8n_jtbS^mxt#3xPAvdpwRVk7qT$r!RUu
z*DrfKPvN>Jt{;WI|F0g;383kM$Mfp%9?w!-bNFs@dpuWu@pvM^Ya!ou6>b0Uc<%kp
z<5>pz^*=qHwa_m_KX%B^|LU=O3K4)D#CIV7cfa<V9e#t(2}b%GqD#U^S3{nH$j|-d
z@od0|FM)pw+*)L!6W7VGjYaU!Vnh`fxfXII@D7anHDtwtED(&|7wuyqccIN<d=p^b
zn`IJh<LxjS1n1YFAQ75jI_y+!DEW$1tT(vc2}}dl19O16{ZXF43&2*O4iA;nunx2j
z;<!p+niX%mft{n^1iM@OXpS3|$Z^GY;1C7u7{_s^fd_Iq&V=>AUO18C=HQ|gb>9d~
znF1$h*a9p7PMZoxSRnH5M+cCrfTw`*`5b4!Hffo~abtn0zyjbXU=HldfomWi0`3HM
z0gnJ{=b$Zi(X<EPQ;)T^3K!)dBIh9p;Mf9=D};l#1stcvw%Q4-hdgQ_I)hvUJPo;W
z5ga8W&_Z+w-uf`dIe?RZ6~F>uG4z>_V6?!pCon+p8OsoOZ^&5IFLcL$QcEyu?9&H;
zbD*eQ&2ft$C#}I~ftd`!r#*$yKpq7=1uO<~*vIpqM(4l+;3QyqDICK-^BGJP<Xm7C
zuoak@g1**q+;L|AJf_W#i_(p72E}Qh5eERH3l4#iz)8R&U>VQ>+y*<{CXV|FSOJXh
zgYS#rq1U|xAHdv~5j@Td+kn%6MXw+L;Bw#rU?cDXuxm5sKh*%?Rg4^td@ErLIRm%}
zavrb}a@7`e2y6s)0WDiGm(ZuZhBkdMnr#Ro0G$IffWF(|510a+1bsPh4dg?>THv<V
zF>>I}*D?RsaM1+9fRl;#4WtNY0Zsy@0oTAm5wHMqDX<E1BXBw7Bfv7CZ#8NJm;yWw
z%mrQp76FrRvRMwy1eODHfro(0fyb*c|7Ezi0Ad?3vIg@6OacA`Tmv-X2viTW0-J!7
zfTkVL0ds)0z)8SEz%{@QU_CGrC#0W%Il%Uv2nN^zECqG}D}bDR7aZUs6?ht$57glZ
zRR&B0*6v0z0#DUq<iPwrm_uMEuoZZu4w(yu(*{fzFmpfB3Y_ycItP{=z+kYm9Df%h
z2A+Bk!2#QVzBqc>+i_vRMF-FUyap@>THZ$^q`DAj=m+B_WB`~7tb)E0SOi(u3}=w%
z0JY%=1h^A?(LszFnD+r{1N;%7DHWMI3=Xmbn460EcYKHuf*5-QBLgl6wgKahqT>iu
z@aOmfbB<w(fNOv)z$Rcj<G(<#IQz8$CjmQ;<F*5?{|eay9snK!UI3l~MxMYmko^*#
z8HM>@^fjDDAp^iF;HYn504xR?qcIv_Ca?vV3v30>0dl9&3D5xC2DAVhfvLbFz*E3$
zz)9aBb7p+MM|OadfEB<3V67b&Rk%3K4B9Yi3sU+cIsh7g#Xu8qJ#ZSZ5;*E7j0kA_
z85sa30j~iwfQA@k1Q-vT^B;5q+zDI`Yy_484*|CUJAn2hxJWyPPGb=OFcLTxm<sH=
zh=#z{E{q<iy^72Ljo08H4#9XJ0}JpvFeM&^)}3(0K&}Vjnt+-9gwys!;0D6w0^<V-
zR{>lfM7VZfsgcBTNeP&<V8XSaD)aF)+yyKErlF`(LkYKtuDH(}T+|C=gJ<?(n1XL1
z-E&_MnL~Z@hHc2xkps9GNsRQayng(JOu8~}0N-&p)#ruNBY7sTya}jl>X&DtWO4*w
zJBdb5PUl-D(R%^D_tEDj5A`~d2j7%T3!-h4wb4zGa3>?(Jq)9KqYRt*SF~(w%XuVg
zGTl5inp&plc*A6xJSCcspG?P0xz}sW6x0%Za9SumFvY|lpGr?m8Or-k0}Rlk__-Dh
z{7s|drVfZcKI7m0o3xmOeE3iBDxQl15Mn+vHG*%POaGo4&ezVR;nTvsS|38;Ko?4L
zr<wSQN9lrTSzgzQkX%}Fe<(dPEuPO@N`IX;bU^Xae|E%Dc)$yZe*9)y+2C5i&3T;O
zdw&97_&8m8e^!|32@Dq+_DREctT)yIa4FO|Ih_7}e;8l2oa(2C^OehK!t~^j+!dI2
z41s-;@NI*AaS453dNSWsN;kmb2=+(WV+Jh7cEinFO23#sH2gGFzN{ratg{NJil4zs
z#?ih7;nX_A#K*6rQ)Z0uvaH9AMElP&(dHSUymdYOX2zJ1L(ksy%nGC)-84Q+hvxV7
zVk#?*nQ5YxkL&2O`DVW9Il4RF=2P~(SWF!Cb42K^Xtl`)_vQ06dZsPpK-taoBtg{y
zRbv@_Y-Vyu6}{OPQ>E$=E~Q6j$0kQYoCdKHCKg<CeR6J=5JYCa9C}?jGuN|$RzdVF
zr+sIoC)bzXbj+ry6RIk3MqINGYpv_fIQrbI<a?W-VjapK)?_TyhZId1mk&<+!c8}f
zD*~6M;4I)u1&;QZ9UGgw@!#WTg>nRDxf|&dv!iL@Y#l$AT_*P$g%&z!*@tzIhRMtT
zhg(|su-J3JWl}OLj&{t}^|C_CEZK))DbuQ2RDiQeEwte+kXS!*s}!_4%`7(3S#$c5
zf*XbzepuUK2%Yd@hGW6a*+{>D;d<FHj2+I(6oxFy1K>&pi?X>|uXaeHec4<cDU*5H
zG*`=)Z=@g2P0m{6x^?J|9>}?hD+f18!Lg32z~#7T-v^TUu`c@1+yv@)K+EU4Zj?rf
zKWjwadLW(8+(dtUU}$pEONdPvl9+{hSX6++j0>Mk{I>;M<jZv2yez)Hf<8BIv{zCk
zZU}n!ylDE@y#8LLTTn@mf~l<_+PiowZUUZ8pAkpb7MQ)JZ9|HojG~_u^yPE6)2jvP
z;gPT393V?&Qveq9>qs$2A1boY1@rY;`4DwN2x4Gb9Knukzm+qAYf^A&uulP(a-F_4
zKRx?^%0)3$1u&N<k<I#gaQWa^9kLH|Q3=k02n(?$gi+gqaNhC;oxUJ8HV;Qc!4Nm0
zCC4|)LbaQ{U(s=?XcUPPUP?9Hx?n&^XALfyGknJ4I|nM?o%GiQ<M`4&bm+oZzI+dz
zzOXOvTSuQ;IEL@4qu(qX%~$NDv5R8)`n`1YqG-N#FMVK9I&axWH!m8%uh~bxfRx`z
z^$*5o9dE=MA-ETFb08SYiHd6l=ez%=9Sh_qa7p{=f(OU(t^4WQ502*B-l6<MvAp#F
zO?b%0=e|o9Je0ssV-QViAJQckynAy+VCl*UMOwhgGsChm4cwe}>Dh-8Y>S{`X7Yz!
zR|x8xJmYG?<tuDiwhn<q&tn$%^%4%4bmoE(N*DLyecz++Egqd*``)b!PB|6=B`4ef
z0!RB6Ci92hqf-h;^TsB+wJ<BI;^57gSpbDN5R|F7HQ?5O8wEZ4Sn%BhuKpm6emIsd
z{(#yZjvXC;=+-bgVZk_g*bH^yXszI^;3C0Af{P>&Cef0`LG;~+6SF!&<$z%y*0cy_
zNr!K((NgA4!NtR_0-WhEjeR76k33ArJTf#n{-ax486(h{f@8fTfir$YcRw<QFZz^T
z1#l<m=tpCD!%4c}(S6<pr*KDT=*q<*G_xp$-}x<FP?W`|eMf7G#(1-%-*NHAj#^^o
zGtSYhB{r|rUlE*e^S`uY0Ixkyk1iR*J1)@h$Hwp#7wH3!WsS)D?PeLu+Y5OjckBd?
zERXJ9v1BDn34)FAHFH*6u<>p4#dgmlmHl?p#mmk7Se}+GH-;2IWyNwd78{u^ZnsDH
zjG~^RXpLSohmKzwrO(8KG-;teNgrD}Mt>?A>BdP(_bL5k=}>)p3{C-F5Z|FaipS`E
z6S1nGdl=6u9-yy45!JI^Kc}0EZF+5Qlqoa*lKu)~Ln<ni8GlQ&9?#NG8i1oR6W^y#
zJ)R!KqBfwT&J65kxYoU~oBBTy=AQxXcotSv=J)yCbnp{{{Fj5v$d>FDGP__}_Jr27
z4SX5+6y|oKJiH$HwCwRv`T?9>fI*QB6Uhc>-c8Rxaa#{7uG>eW6V~Z3G;3LU*cwp9
zw`1TsP#^4)($u4t(2}LmbjPx&9;aYoL6~{W(Rq4e*=YY1j5PON41jh1&MuaAI%au@
ze<Aqwc{sr{-o^Mq{`KH0r(wro+@rf_-STXItvBqZBSkEZVY{eiMIV1FINbsS!nn{~
zbi|4%|3%=AgDYj+z+LoBM>u_QMX3Ky@R19}tw-nCDe#BEUjSbSUa<dM<h@pg`locm
zGW`gK!Te}y>5P>zftVpKAN(en|BFsvnc!azYHSf|pM@K-htie(dmIO6S%P6O?sxjd
z%Ax*|NLTA)*d&-o^BzPHHJEuH3%;rtmB;vzbz(Z%L5%X7kw4)WRS26?uwfDC2G-HV
z_9*`faHGnkX{L1;eF)uS5A|p7yz;<TFx$m-^rSt;Ux(x1A#m}Gn_5S^IePkMf{S-b
z@eHe@KRAMEuEXeG1pYYq3(VFm`d#Y?^{)lLW&=Cof={eN{4xG*;CABh$lea?o@YLK
z`I~U}B)tG5#;p_E_bKV^XC3Qf*foSR&WP81l|bi~jPP3-#~Ir+#v0<~n6QlQDKV2Y
zdaNXZJWel`O!T`?p`9dX{RHg<Xv65%Rj~m{KVMI6(~z1o8eL7NhOfDgezj_6>QCX$
zJNmDE$!yVl^$g(*2R)t+TX~Grr<znV?p!EmaBz+Z-2=G&KEa$jp6*#a*q$B0)nA4S
z9@xoTdOT$@ty(7w&(3ph{SdCa(uYeE_~Uwk_X6ht*Nh%wmWK-*2QD96`)m$!aLp7g
zSKj4sb?5nT^@3ge0Kx7`23OvuliDuoV;9IvAS*!%og88gj5Qa)<;#YqD1rM0oJF?F
z^B1_Y%wadY5Dl`rlL#ItG`1mTFYe)H+#W*5ogsqVDdrD$0@peS9Or!9r#p^htBLar
zgyr<onuw5Xv0V8Hj!PFpDew}S9?GCuPlmJKc#JHOEtfrp0;HzDB<JWkLGB~TNz+8R
z7vy~62*eI7v}=Dxc!MTfCvE2pSa5~w(pJuZby>XrUU+3IT(?~247f?f>j9)YTLuL|
z7fpYAGMe<Geow`bM`-`2`jMyT%%|e|<|24zbQu%bso`qcFd4u2s5s=d0CpE+>03{Y
zwl`;U_51K;H82a9#98;71GtAtHa96ri)*BEi&eOGn@e<;ve~t7wp(ZA>V1fH|A=7d
zM{tvTyl@TMZ1LJXVvF|DnJjKn@LH>TZx*KIS*yDM*fKPGe*q4JEnBVb_Tikd{!9?(
zW`*W?nsW<tvpk%xd%722??d-JeJ?RnztVpCP)wdVp4)RagN`nZCNI;urDpOZeX_J)
z)SMn%Idi(#n{$@Oa?ba8-T4px_Dtf8jtLHWtklFeC)4w#VOsN8&P{b|d-l!ehqR9*
z&bHYa%)7?96b}CU@{a2FdE<Et&rQN_0cC&vC){}o)oofmlulh6g%=kA&jiu+YXkJM
z;-ff0Q7tG=DHMy1f?^{S<{p~|bLEFOV5Hp~U)(X9W<8T=z+EcbnPbzP>~35^mpn6@
zKNnBGc_u-h6VL5!`eVhHf233Wx`cq~XuT0zXPYJjw|Zzz49#8_nF0rA5u)v<Fu}o(
znxNz?7`6d_#@wHe;M`b)jX|6v@HAb!ZXg*(-(A-`qRH4bIG?w=L;R6zGw0^+l=2-v
zfd2k$h#k|=Zsh8Py8+qx6W>;U+#Np>=ayNV^D|rv)3ZLy+4dvnJlRdUb8x*2*X=)A
zhhR+%^qI#Gslxr!ZnnDH60L6Hwr@CY!L5g`S+|0ZMSYxS(XNRfae~?5#oEKPX}zC5
zlyeLB-64*?xjun6MFFDqaZ;<+Uep6N&!5Fhhd-+`R;3HEY*fUuh{ik@5n7HOml7^r
z?p5&G>dP8N%0aL-070x!G@d9lUiNQ|3%t-cj4paEWqxH=cf(E-SAOOL9?L^eO%YOa
zuA9}3VRx|gp>lY4gU>GBy_?yv<y4-rLlNSXr*q|(HOAx+%#y4ZN@7jCG^563rhk-@
z=Pj&Wgz2s~3(9%4|MQ`-83?frGn8)tA`JY_gaXhw4>1{aeb7J`JRcjJ$jnd|1))}V
zwPr?_nfRQKp<ABsm%YUsFT{Pha;1iV`#JDdZl)JEiN^}URueWh%fRl2sTfxn4J+%%
zU&T?TES>bAC1r_ThtXLNx~nYIXEnRR;NGC0m5sEwn7MMCYm7Lkv4g_R#R>7BN9tJo
zQ>FOFOYz^uaGBLziRy1(jY_g}ZoI+#bT53d&EYHH6!c=(a}VdB&^fQt@U<RKsAr_t
zvFpqHtFJ9KR9~GJP~9~nkUsCs*3W$SdMX>jJA>#q&hT(9zPsUMC|8adYh|Ny#C11>
z?6SGP3#C0aWRYI<t_^SSV-C?P8=}b~8cZjW#dJQM$A6nfzn~MsGY4_y?l1Z3%P1w~
z{dql_W|jB5afe5W(;Y%rl-r4(UN4`@?~A5WUYH*J0*2d;%~2POd09POn3rtqR|~)&
zN~0%Uu=za|EspecU~k%U<A^v1*WJ+GjdQ;p!Ze(d5XS_J$vrPX9EfhMjXu3`0RN<o
zzOykVxapeS&^dl&^`F=muP@84_GpN68@;q~vCp|UuKa5xYX+U~n&{v3r`|9ZE?F+P
zEjIe8D=Kac;&6C8d)r2e-Tc`dYl_rO1MFB=-8b1-SK~Lm&d)T`zc$s_H`v@S1X|te
z2<Ltk3%bsWJJ!B|cQ3)Fyafw0j+Gmxq3bq|+gpXzfSnR_K2|qJMx0>RTY|(9vqO<H
z3JHS00%pr53Ad9lQ9tSp-v^@{ak~}4Z;9l0H2hM_OD3|84tc2`d6mw8DKX0OgWkY)
z!ne_YC5-bDJHRgq<vw)ROUruaf1@`%1MSx=9BHg>j5QtQ$GT-DQv(cr#YQK-Y~x?F
zQP<0pgT5TVl_z2C{uAm0P*-SzsivZ5_XcdM`ymgB3#J1rme_HoD*p>M%$4aCo7=;i
z&d=9!liL4Y@nw53x7UrOzD*NW^D_J~n=aULFWTIu7kM|bRL@3y;;7!x;*E9m(uyyS
zMsnq+5b8eIo;Yj7;$y<TU`{>@A19IVZUedUk73(OkGsa3t4n-^5VDo_+H8r1S2Mgi
z;I(D5P4Kn^-hSB3vt>&d;KI!V*Z^PM9B$lhbNBM%oIcydtmnV0H|(N!ZwVs7^vvc6
zGKF5>O#9<xfMpDa3?!}#*X;ggGK<=}Pj4tP-sIRanMIpljq|#KUPsV#uf_%M!4;d9
z*EHg^BtqUvV=9CA&$KkXGMNxMvog-?cvEi}2v_p_bYgzmuw}EbeK0StRa&*JIt2bp
z<^6tr5Qorzwcg+>L|jChUyI=P2hdepl5acO|K>{8wq2}_4wN09Hf~*-5Y_;Mb<0@_
z%T8ScSDryHZJ9xkj;#|(0^PpV999mmjkt?F3(_-4H`|c*)i}Y%an9ZJyRD%<<I#qd
z_bPgQ>j<)n4u37uD4qdoZMvb-f{*hueeksrAu%wn$3m^F?e8o!`lWCZOTT+<BzcL(
zYzxv~$1r=N*H1MxYuo6U^Wiu?&*qLj$^SECZ+Kisw{Nq@{0EJ$Xt-oYc-P=|UOXh9
z!Fi|hNAB2}SmNwOZ`&RpAcwZIj}Y3)RQkmBRiu_)-#)C@6>qLQh7Ax)NgD?FCC>O*
zoyGkg%S>B@xZfAinXgYI+vwicQ*I13FWC8`CZgsiO?XW){qyyyB!k}lMkpCT=f5$V
zKi!WWeIq&G_EfGM4{!Btnn=`jSdE_gR4pF!TNoyL^|TC3csj7Fa`pXP>{QVXz7A=B
z6zjlDX&u<c_6MvP1;Y9gq*z~qYR>u7gH>brCZ6`F4)LCjvHaeTCReWv+X_eRv$Mrv
z^usU)i^Hg(&DBADT>nG&PVkkhxnsSFIKOW~PNSsePMpQ>sxe8sK&`D}u#m`2bV<!T
z5<<VLi6B#{yJkf4!hT{gvU`9nQzy88&fa}+dOD2G+VK>*kDl8xlBCl<JBN|IbpB3r
zSOgr{7o=r$j<;1`xi7o=`mztInlv*`JVCeY95&!Ais3ITlPA4#sM9(ol=sCs+2g6z
z9UJ5{7vph_Gz}+bnliC04<~Jo%&rG$k6n)>vxALU6LvlymC@|+w6ens4kxX)X~9yh
z8k2v*k>b<7v}RWV*+h@+8bR)$0lOo}bF|Oyfn*DvxjTqfyqQFPrib4&ljypi-`v5I
zAE@)K56Gyxd+PECpV6JZS)U%M&34;#+3we{6SI|;EfO<v%{KT3O7=#O78<qJ>TQ6T
zF`LfbyPs^JQTy&B*XjIy6NB4Rm}w{~#aMF|C*%x`Y2CN<*uDZDtHQ8`zHBjD*bvTR
z(R#Y!tthN%>@frD+A+4SDR(74lHS|6ia!&<ZZz82m`4uLyY|oHt-sTK`_0VV$^F9G
zh<%kfXrH%N`^>;?#rDvz=>E3{hu_~@$ZeUfImr1jPJAr4Y-@}0qxyHuymct;{mx|n
zw_(L~=hB)m3)n*`eP=SMq!-`WM6~p&0|!I5!)GdNt}lDP`Z|h2uxt0HGu};)G$99(
z+3uxm?~_tBNZ8hlHS6e}cO&>5{8IJqRFX-P-wW?snv9dDurY+zuuUqA3tdOxnH|Hh
zAtmF@x$#epxyFreQx<*Xy^UUj(0LQ}dq34DxOq70q)gX`j($Hmc<6#|hU(SkE<9rI
zx@Y0iE>=nz^vU<v5f=?;ni0o_+siA=8A_~gRpEB9VCX~7SiAm<lgSbsi1%(yqO|D+
zayRYOyp+VzEzNh5&Gcfk8H4saxR_j{D-PCq^~MUej}H1^JeGwgKZxu7N-tqSR;Hqi
zYxj2!zvgi%(o@EvlD_<)KY50F9U2dh_Z%{l1$4=wf#fq<eP|g!Z4^y798HGO+YXN)
zjr7UGs7Jc}@In$w13nDm`Cc^P!*TlGlEkM=TOT^^a5_$W%<c>N)rbA`pGc}zy#!T`
zpxRC6el!w~-_;+P$qV%3j~>M@Rl{4pCHK&<k1rDw_50*=@>AV+pG5Fp`%%xM==CGl
z_;oh=-_Hi{Pupm}qm#)}y7p)!Kif#(I2zS`3XWe`_c|(88|mjqS2EM_pNHKxB0*TN
zYb;OO-04r>JQAead~O^G9>q!J1Qt7?`ABvoV2_IINDx}{0;XVR-LB7*NHjc*fCsky
z=d2UA|46i)v5t4&i{37`_Dz6^&*MwG*7A4<K&<Xk+$(7~$(155AE$I4aPsu_V|%<F
zN4(m)>&HIl$$#i)$K%L&dg=Hua+LP@ioMCYOZe}DU+wUE7$tg*Mx7{Scl;YCwv*BH
zu9JymH(hda80kazoHP?kj|u<1baID(E4KNm@pu5iPY^mhweL6;9^9Oa#gVJgah$sk
zwi~ua;13ACIc4_Cw7Qw*I07!P(daMIY3A2HQCWD+FdBzLoA|&$a8f85V0EWyV3p3S
z0z3S$FyhwD2VF1}rs=fi>%?w&U2w(^f7n&q9sVzTUBRa4n_=X8dia|k*<61+4~NTu
z(=_xb4h)lV-jwUG67LCE9lmoqZ2rWR-Uco{TR5wp`ATOvi*Sd-7Vi!hvvWzw37x^%
z@x}ypZRvkq(5G3r{T7bfHBe>8Y}(R98>VM=o#WXuf3PZv4*%{xEUhnmH&x5GjHQ2^
zS-{U9Pp6+v=Xcy*xAE*0Z>{C>)m+-yKE#}gr6Vod?bP2~I>zIgt+Lxu1GLa%r1|G`
ze9}<5;M{1kgYG$(A2}Rvc(OSsOFMhfsKK)qTS&M$obx%_{A&c(;O~Boql<pkX{RtJ
z9p@r7y6kM~`Zdb$du+n8@qEGf6pVXo2Z@F;k=eI8KcKL`U9jKBocn|d^KGmNqR#V)
z<Q2OAyd7^yhg|p(_h!_^(BPqHSBHvrXpHO5;9Majo8ECTj-=2BFD@eib>}YPAFlZb
zPf%7(@Vad55A3A;0S);5PMm1&|GjtccIfuPMZP8!E<)fUxTcc6^7}%vmil!3K<=XF
zI?Mql@xX8fXKmI28`vE*?9x(_NS&8vAgoK5dJ`Ru`XiKFrGx$$i0x+nALc&S(FV8M
zpzF(;tKN^(e8o0qHlxjtT}@5LkzoWlxq`0Hy?@+J+UfN_BFIG=cG;5Jqo=c!w+_(}
zZqQcj7B-`gaH1p*$Alj>A<3OMT^>gVYz`ZFZvP%S|MD=BO1ED&la2K7<vWdbXy3w@
zy>n*WR_?u8NaH(`!o5LOVa+~w*K-r{^>__5q<J`#b;0z3PCH)|Mt|wt>s5w(B!X`F
za~ST0@7Sv#8gs==JT&{teSA_Aed)?puOyh%(d@q_>awqQ!(R`f2%0XMX#HRPBgdlR
za<bh&;)o@0R(RhaMEe&dT_>>_eBJdvsiH5s6ZxbI^q@N#Tm411CB8Jl8Gz(m#!(fw
zRT-B#%;^XD<=;Fmc_an2|J8}wrd1eE>DA$V@3Oh8Lac7~{zZ7Zf%g?cOYIQncZjKg
z=bicZ_2(@1Q!XW&UcQ>Z-({l_|4p!){P6mZ9UX#d4#Kh&Rz&4(3!cdZZ%O@}%&rl3
zY?oF}9&1-EY=W6ipSyVXYLCaI)U)h6zUyXq8gEgQ#Xy_>Yasdb*ni{roEPc1Yq8XH
zt*0SA#mOo~9&8J}>spTHT9lKfT#qv0rZj5t)&Msq9(<3nn-izEz$5gtYs*czss2s*
zM%~QoiA38r75Q5KcZ_a9wtMwKtuvbL{d<^S5XMph$%<DAMtc2k^AP+wUwI|oOawAy
z=akZLWQpx3=HviyTcO*6(Z<9NbXxHU%<P$$v-BR%4?zXUh43O7sCy7qP?-I~?PPC^
zki&{#r_eGt+R1YA+PCi9vzd+w<B_k-hA2W3dF@*`?z&nv#Mm%RLsB*5l<Qe<5<!kN
zRC^PbhMae0>xr5C*f3L1o+rfay3`%o;s!ro5=zK`hMs<;H&5PZxZ9r$CS<Z}t$}<>
zUUJ<NKo*k3hUNhBC?R89gMtVp{aqgikvECk^|+DrBlo+ijpPmTx$Ev=kdL}Z2pO#X
z6T1;x99_8~L>uAg(anHgP1xSl+T&xJ`zTh8`MB;?675<XLP8?<ggC4HD<A3cG4KAE
zaQo-?;GDnWc*TZ#-nAu!tO-B@O4y0IHA_gq$OKn<C`t5117^f|cQbtKnjcCc3)F^j
z?m}CjW5RB?$HgA9hyCJl$q(9<nr?=D?CBWQi5D*AY0$~VQ>yJ|Fym*)4^YJ{Y+VU5
z57`Ep`RR0Fc{KNJ;<_1Lh6`rmgOQ!XhKk=2TgSkB1knpm0`f>wh-;{c*rN0vZ-Wtm
z_agc`d#&In;?(fCQ0UjZ4J%wPn#e#>>iWz?O#H{Z>lYJwA*vsOW6M<xiiWMSy(O8g
zy6LVL!^p6xuv<*RYl0Of7T2XP5*l@$Z3)p_{Z*{O%$pu2IB5#kml}G86Mvq+V`D>l
zB$>{W?;Bo-CVvsHa=g=|E~kYo<}WXH@iF8>65#qch9rBpw!MD){^2fn3~Jy(SFc!N
zwtK-i0m;G7nyuwq#Zqnd<qWL1S<pFboD+XEQ~sFV>b}C^Nt0#m>yhqsyf2v#UC7rO
zclz~LTd?S~a&6Jh>v#vW6xXb$K(uSR>e<^e8awO7<r_>s+_B)xE558myJ65-x^b?L
zVo5;Q88l)qnAjnVHDv45CU4HIab1cf6G^!1wm8z8)VUsxBSB=J>&ZA0H{>(4IfCz}
z_<n*fs{#a9t1Fo<{2rD~xJhhX`g{EQ!q0&N>%9&6-q!uyTxa5lC8bOpDy$6nvmy2n
zJ&3jLg(!SVqKEw5ExYS|X&c+=>Jv{=eYfAf|L^+_3Y*(@*Zg>-@MG7D@g(B@g8`h8
z_2l`09Q%79)+pXF;h5mlIvBT1?cW2f?hz&CA<#QzpR9PA>bea0HOR@LH*2|vKSjj2
zVQOPilbvngZCIr~as~7x#%NV*mMhtFQi<6$vM0&v*}r-CI<#JoZyCORA3yr#sy@xb
z$*40A&5mjw9^bQhxOceg^`0crC#HFLYp>?vKl!*$^d!A~1~m_liQGPJR6v71fs7#h
zpBmSli6oZ)bEIo=A_*Jbwi$t9Ly2R7;<t;7xS?(Y3Z4aOfzE+Hk!6Dq#x=WPts2LK
zK-b|!(i=Ys-u$qcDnwokt7f?Vn@IZdz}`s$HcU+--|!*xx>6s-!o3Q^uvMfwvBk8`
z-bP$^_9ov4&$yv$wHZU1u6DMiAuEN<=e1?JlB|XueaRs{sTF@Z?i_`}9%Qw4rKfVv
zd;a$9b-<X*NO0osD2&4O*uf31{^SwD=bK#J2cqlR$cA4Ak|`u4^hP(eSU*@dWwY~B
z8txlJ5=e;O4P}|_TDqv5mh7VG<n0je8@gIsl9#M&m_3+m<h^I&!D6nh!83$>;uUi6
zFL{(@wp5d7nbY6(!w3>Rrdgr8*@H75o0oTY{JI3hUtE^&z`=GRHXl|_CGX#8qwLvr
zyOqr3T}v8jti)gEo#*4!&ChndpF=_xGzB^PA`?k?<jH4;dP7g9b2sZ86Ew|Q=UAmK
zKTOnh6Lq&qI%Khon-(SLN~CryyUeGcTW=8h8*v8-u{Q+@c4s6XsY?Gj!v$T8kLbUb
z(nqehpkpzeK_9WV=t7<BuaRzyAvM!!kmQ-{=Xz6w(Dtk*qQ-Un4iX%4z~W@DKW{YH
zWM&2~4+4x%9eAT7B6Q@Kkfmcw6W76P296;^$2|B~YPndOWvnn}qZ1T{(}5XT09%HO
zfd2TVp&gqUvglvixEjWg=#T~ft~<|k1^=pRFyBd{NyrRwx@RE(R)j(z(~=t|j>UQ(
zlB-a5risdyWLLj&@H$SRQ#71Cj#&6eA>iiB8>OTir0dmOl9VS{Y#FMsD2x_6NJ|q6
z^b4GQS%Dr0F2&dEgP+%NP8}$vqdDW&w!*zt*v)0Wo0#l^_n5)AS_oq^h6vvGN!}ZQ
zQ}LC(mJGVJjo|gTpU|dSYO@14PSNJfz+2nQ_6)&nR*VoDRY;9C1G5#4vInRe32hpF
zzniQiV|t28%u1`RDVF7>b#`N-;4oQom;(G98#y9x70M(2U)mf`bu~;RYx!@!ZLm!u
zBfEwCbVXP#gy|ORt`&9XdU+~l^v8eKeGc82Gykd+0@CAj!6wQV_$FTe-w3GfMw?ct
zv|49leH%QD#D;vY&>in5PJF7)wV3Hn|3lY0`*@1$4W|3%AG(g&mC>#rrXj|!|3#O=
z2{C?%xLAz%-xSIhDq<`-sc0isu@K|!_ah%){kv}2{iH@-f_qOVPmz#$HuoJ1@lz3g
zCw>htfTv<cmdv)fKAJ&n-m`h=c$a@ZiRS0=4gK=*zxMjJ3X4jr#)&n+_2W!ZBrvTp
zDM^fJm_3U`YeSyB(S5D0u(wzP+j_WM50K=Lb^p-S&aSk$PCh_-g`OMtmmz6#RilOI
z*0HA|EXu81yl+G3JTjM%0@sQH5*IV%SMfA_^e2xi2D>O$!&-J4j!DAvM}D?@hpV}O
z%pfCNG4shVAH8J#s%!3iV$n%9#ja=PlSuDX*=_^x>w0rO*5;>h9qa3~@a7X(mumx_
zfoxOA&q1E0kT*bHrI0s5-l~vaf_zXRZ-#tUA#a7u``zfz9`HJd*qcN^4P=`_-VJ${
zLVgSKDuuic@>YfXHspf}`8~*I74kvId=EJQdu_mnAYyM2wE>?%wkhPJkY_36FCec{
z$R{9gRmk5!KB$nthkRBcpM}i(O99xC^8bK{l?lkdLbfU7-yqLY$bUdyrI4>c-l~wV
zLO!UF|Au^4A@eo_U=RbavpM$$5i1c))<d=_<Q|Y`Dda%Ns}ynw<gE%h9P&Yh91Z!b
zLXL&Z2M7V+|GPtn2_RxcLXeXo+Z1wN$g>pk0LZHpaysO#qTG=E5ZOkkL8EmoT0wjp
zavvg9TG~c@1?t)(<T&5)mg|d0$wRU7KLdnwgzzy*h`)^%K9<^sSw-YtV()kWuYK_O
zKSKNeRmW1lbN^RHPGiOmYRFwmTD<ude^>ZQ(l^k8gB1J7SRUb;0zTj$|CF}t#g(LA
zK-0aVxs0W*uUC@P0EfutN|^VvE8I@{>Z|68lUg;`HNj5O^*1NiwSmd<zpdRi-}MEP
zEz&;%Whrz8Iv~r{lUnGSz~meMTzH{t1Cw>qKTe~2#PtP}J0!W|5m#UdNe?Wn7yFn0
zY4Wn}t|=vmOaAA23X5DDV5e{E6zxtGxxOeNSv)Xs70J@SjKBM0pCsa%vVuhaKduQb
ABLDyZ


From 064cf95f6d6c12211c80e54eea8eb1bf13ea04d7 Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 16:29:11 +1000
Subject: [PATCH 05/12] VR APK notes: Lepton's missing clipboard also stops the
 Godot XR Tools demo

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 docs/vr-apks.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/docs/vr-apks.md b/docs/vr-apks.md
index 45ecd56..aeced96 100644
--- a/docs/vr-apks.md
+++ b/docs/vr-apks.md
@@ -73,7 +73,11 @@ not being worn, so it did not reach `FOCUSED`).
    inside the APK that asks the runtime for 1.0 and maps the 1.1 core
    functions to the extensions the runtime does have (`XR_KHR_locate_spaces`,
    `XR_EXT_local_floor`, `XR_EXT_uuid`, `XR_EXT_palm_pose`).
-3. **Not yet reached:** required Meta-only extensions (each app differs),
+3. **Lepton's missing clipboard service** still applies to VR apps. The Godot
+   XR Tools demo's Quest build (itch.io) dies in `Godot.<init>` casting the
+   null clipboard service to `ClipboardManager`, before any OpenXR call. See
+   the clipboard table in [apks.md](apks.md).
+4. **Not yet reached:** required Meta-only extensions (each app differs),
    swapchain formats (the Lynx Wolvic build needed `GL_SRGB8_ALPHA8`), and
    Meta platform services.
 

From 50d5e1453963565ff4b71ee0458d2bcdd7315e44 Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 16:33:14 +1000
Subject: [PATCH 06/12] Inject the OpenXR compatibility layer into VR APKs on
 install

VR apps with an arm64 OpenXR loader get frame/openxr-compat's layer unless
--no-xr-compat; the app bundle ships the layer. Verified on the Frame: Wolvic's
Quest build gets through OpenXR start-up, Open Brush still reaches FOCUSED.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 app/package.json           |  8 ++++++++
 docs/vr-apks.md            | 24 ++++++++++++++++++++++++
 tests/test_frame_apk_vr.py | 37 ++++++++++++++++++++++++++++++++++++-
 ui/frame_android.py        | 38 +++++++++++++++++++++++++++++++-------
 4 files changed, 99 insertions(+), 8 deletions(-)

diff --git a/app/package.json b/app/package.json
index bd5701a..c9b80b3 100644
--- a/app/package.json
+++ b/app/package.json
@@ -64,6 +64,14 @@
           "*.py"
         ]
       },
+      {
+        "from": "../frame/openxr-compat",
+        "to": "frame/openxr-compat",
+        "filter": [
+          "XrApiLayer_FRAME_compat.json",
+          "prebuilt/**/*.so"
+        ]
+      },
       {
         "from": "../frame/devkit-utils",
         "to": "frame/devkit-utils",
diff --git a/docs/vr-apks.md b/docs/vr-apks.md
index aeced96..8d31cc3 100644
--- a/docs/vr-apks.md
+++ b/docs/vr-apks.md
@@ -109,6 +109,30 @@ in Frame Control's per-user app-data directory as `apk-signing-key.json`
 updates. A re-signed APK cannot update an installation signed by its original
 publisher; Android also treats it as a different signer for signature checks.
 
+VR apps with an arm64 OpenXR loader also get the OpenXR compatibility layer
+([frame/openxr-compat](../frame/openxr-compat/README.md)): an implicit API
+layer in the APK's `assets/openxr/1/api_layers/implicit.d/`, which the app's
+own loader picks up next to Valve's layer. It asks SteamVR for OpenXR 1.0 when
+the app wants 1.1 and enables the extensions that became 1.1 core; maps
+`xrLocateSpaces` to `xrLocateSpacesKHR` and `grip_surface` to `palm_ext`; drops
+1.1 controller profiles SteamVR doesn't know; stubs
+`XR_KHR_android_thread_settings` and `XR_OCULUS_android_session_state_enable`;
+and keeps the current refresh rate when SteamVR refuses a requested one.
+`meta.json` records `"patched": ["openxr-compat"]`. Skip it with
+`install … --no-xr-compat`. Its decisions go to logcat under `FrameXrCompat`.
+
+Verified on the headset (2026-09-28):
+
+- **Wolvic 1.9, Quest build**, installed as downloaded: Frame Control added
+  `LAUNCHER` and the layer. The layer turned OpenXR 1.1.48 into 1.0.63, the
+  instance and session were created, and a 144 Hz refresh request that SteamVR
+  refused was kept at the current rate. The session reached `SYNCHRONIZED`;
+  then Wolvic's Gecko engine crashed (null SIGSEGV on its Gecko thread, the
+  same crash its Lynx build has), which is Wolvic's, not OpenXR's.
+- **Open Brush, Quest build**, with the layer: 1.1.54 → 1.0.63, the thread
+  settings stub in use, `bytedance/pico4_controller` bindings dropped, and the
+  session reached `FOCUSED`, the same as without the layer.
+
 Inspect or prepare an APK without contacting the headset:
 
 ```sh
diff --git a/tests/test_frame_apk_vr.py b/tests/test_frame_apk_vr.py
index c13e856..186ae58 100644
--- a/tests/test_frame_apk_vr.py
+++ b/tests/test_frame_apk_vr.py
@@ -174,7 +174,10 @@ class VRTests(unittest.TestCase):
     def test_install_auto_and_override(self):
         base = {'package': 'org.test.vr', 'label': 'VR', 'abis': [], 'min_sdk': None,
                 'vr': True, 'vr_activity': True, 'launchable': False}
-        with patch.object(frame_android, 'apk_info', return_value=base), patch.object(frame_android, 'patch') as repair, patch.object(frame_android, '_install', return_value={}) as install:
+        with patch.object(frame_android, 'apk_info', return_value=base), \
+                patch.object(frame_android, 'xr_compat_files', return_value={}), \
+                patch.object(frame_android, 'patch', return_value={'patched': ['launcher']}) as repair, \
+                patch.object(frame_android, '_install', return_value={}) as install:
             frame_android.install('original.apk')
             repair.assert_called_once()
             self.assertFalse(install.call_args.args[3])
@@ -182,6 +185,38 @@ class VRTests(unittest.TestCase):
             frame_android.install('original.apk', flatscreen=True)
             self.assertTrue(install.call_args.args[3])
 
+    def test_xr_compat_layer(self):
+        with tempfile.TemporaryDirectory() as d:
+            apk = Path(d) / 'a.apk'
+            with zipfile.ZipFile(apk, 'w') as z:
+                z.writestr('lib/arm64-v8a/libopenxr_loader.so', b'')
+            add = frame_android.xr_compat_files(str(apk))
+            self.assertEqual(set(add), set(frame_android.XR_COMPAT_FILES))
+            self.assertIn(b'XR_APILAYER_FRAME_compat', add['assets/openxr/1/api_layers/implicit.d/XrApiLayer_FRAME_compat.json'])
+            self.assertTrue(add['lib/arm64-v8a/libXrApiLayer_FRAME_compat.so'].startswith(b'\x7fELF'))
+            with zipfile.ZipFile(apk, 'a') as z:  # already injected: nothing more to add
+                z.writestr('lib/arm64-v8a/libXrApiLayer_FRAME_compat.so', b'')
+            self.assertEqual(frame_android.xr_compat_files(str(apk)), {})
+            flat = Path(d) / 'flat.apk'
+            with zipfile.ZipFile(flat, 'w') as z:
+                z.writestr('classes.dex', b'')
+            self.assertEqual(frame_android.xr_compat_files(str(flat)), {})
+
+    def test_install_adds_layer_to_vr_apps(self):
+        base = {'package': 'org.test.vr', 'label': 'VR', 'abis': [], 'min_sdk': None,
+                'vr': True, 'vr_activity': True, 'launchable': True}
+        layer = {'x': b''}
+        with patch.object(frame_android, 'apk_info', return_value=dict(base)), \
+                patch.object(frame_android, 'xr_compat_files', return_value=layer), \
+                patch.object(frame_android, 'patch', return_value={'patched': ['openxr-compat']}) as repair, \
+                patch.object(frame_android, '_install', return_value={}) as install:
+            frame_android.install('game.apk')
+            self.assertIs(repair.call_args.args[2], layer)
+            self.assertEqual(install.call_args.args[1]['patched'], ['openxr-compat'])
+            repair.reset_mock()
+            frame_android.install('game.apk', xr_compat=False)  # launchable, no layer: install as is
+            repair.assert_not_called()
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/ui/frame_android.py b/ui/frame_android.py
index 39e9161..cec2e07 100644
--- a/ui/frame_android.py
+++ b/ui/frame_android.py
@@ -7,7 +7,7 @@ in the Steam library and gets its own SteamVR panel. Nothing goes through
 Lepton Development, which wipes its apps on exit. See docs/apks.md.
 
 Python stdlib only. CLI: python3 ui/frame_android.py
-  install APK [--vr|--flat] | info APK | patch SRC DST [--add NAME=PATH ...]
+  install APK [--vr|--flat] [--no-xr-compat] | info APK | patch SRC DST [--add NAME=PATH ...]
   list | launch PKG | stop PKG | remove PKG | probe PKG
 """
 import json, os, re, shlex, shutil, subprocess, sys, threading, time, zlib
@@ -26,6 +26,13 @@ COMPAT = '.local/share/Steam/steamapps/compatdata'
 SHADERS = '.local/share/Steam/steamapps/shadercache'
 LAUNCHER = os.path.join(ROOT, 'frame', 'android', 'lepton-app.sh')
 SHORTCUTS = os.path.join(ROOT, 'frame', 'android', 'steam_shortcuts.py')
+# OpenXR API layer that lets OpenXR 1.1 apps run on SteamVR's 1.0-only Android
+# runtime (frame/openxr-compat, docs/vr-apks.md). Injected into VR APKs.
+XR_COMPAT = os.path.join(ROOT, 'frame', 'openxr-compat')
+XR_COMPAT_FILES = {
+    'assets/openxr/1/api_layers/implicit.d/XrApiLayer_FRAME_compat.json': 'XrApiLayer_FRAME_compat.json',
+    'lib/arm64-v8a/libXrApiLayer_FRAME_compat.so': 'prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so',
+}
 PKG_RE = re.compile(r'^[A-Za-z][\w]*(\.[A-Za-z_][\w]*)+$')
 SSH_OPTS = ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=8']
 
@@ -71,6 +78,19 @@ def apk_info(path):
         raise FrameError(f'{os.path.basename(path)}: {e}')
 
 
+def xr_compat_files(apk_path):
+    """The layer's files to add, or {} if the APK has no OpenXR loader or already has the layer."""
+    with zipfile.ZipFile(apk_path) as z:
+        names = set(z.namelist())
+    if 'lib/arm64-v8a/libopenxr_loader.so' not in names or names & set(XR_COMPAT_FILES):
+        return {}
+    add = {}
+    for entry, rel in XR_COMPAT_FILES.items():
+        with open(os.path.join(XR_COMPAT, rel), 'rb') as f:
+            add[entry] = f.read()
+    return add
+
+
 def check_installable(info):
     if info['min_sdk'] and info['min_sdk'] > 30:
         raise FrameError(f"{info['label']} needs Android API {info['min_sdk']}; Lepton is Android 11 (API 30)")
@@ -112,7 +132,7 @@ def _write_meta(d, meta):
     ssh(f'cat > {d}/meta.json.tmp && mv {d}/meta.json.tmp {d}/meta.json', input=json.dumps(meta, indent=1))
 
 
-def install(apk_path, flatscreen=None, name=None, source=None, icon_png=None):
+def install(apk_path, flatscreen=None, name=None, source=None, icon_png=None, xr_compat=None):
     info = apk_info(apk_path)
     if icon_png:
         info['icon_png'] = icon_png
@@ -122,12 +142,14 @@ def install(apk_path, flatscreen=None, name=None, source=None, icon_png=None):
         raise FrameError(f'unexpected package name {pkg!r}')
     if flatscreen is None:
         flatscreen = not info['vr']
+    # VR apps get the OpenXR compatibility layer unless told otherwise; it only
+    # changes calls SteamVR would otherwise reject.
+    add = xr_compat_files(apk_path) if (info['vr'] if xr_compat is None else xr_compat) else {}
     with _install_lock:
-        if not info['launchable'] and info['vr_activity']:
+        if add or (not info['launchable'] and info['vr_activity']):
             with tempfile.TemporaryDirectory(prefix='frame-vr-') as tmp:
                 patched = os.path.join(tmp, 'app.apk')
-                patch(apk_path, patched)
-                info['patched'] = ['launcher']
+                info['patched'] = patch(apk_path, patched, add)['patched']
                 info['launchable'] = True
                 return _install(patched, info, pkg, flatscreen, name, source or os.path.basename(apk_path))
         return _install(apk_path, info, pkg, flatscreen, name, source)
@@ -301,7 +323,8 @@ def patch(src, dst, add=None):
         repack(src, dst, replace={'AndroidManifest.xml': manifest}, add=add)
         result = apk_info(dst)
         result.pop('icon_png', None)
-        result['patched'] = ['launcher'] if manifest != original else []
+        result['patched'] = (['launcher'] if manifest != original else []) + \
+            (['openxr-compat'] if add and set(XR_COMPAT_FILES) <= set(add) else [])
         return result
     except (OSError, ValueError, zipfile.BadZipFile, frame_apk.ApkError) as e:
         raise FrameError(str(e)) from e
@@ -311,7 +334,8 @@ def main():
     cmd, *args = sys.argv[1:] or ['help']
     try:
         if cmd == 'install':
-            r = install(args[0], flatscreen=False if '--vr' in args else True if '--flat' in args else None)
+            r = install(args[0], flatscreen=False if '--vr' in args else True if '--flat' in args else None,
+                        xr_compat=False if '--no-xr-compat' in args else None)
         elif cmd in ('info', 'describe'):
             r = apk_info(args[0])
             r.pop('icon_png', None)

From f10282294d45934d99e834d55de35db718c867c8 Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 17:47:35 +1000
Subject: [PATCH 07/12] Fix the cross-provider review's findings on VR APK
 support

patch() turns corrupt-manifest struct/index errors into FrameError; a missing
layer build says so; the signing key falls back to a rename where hard links
aren't supported and explains how to recover from a bad cached key; the layer
nulls an instance it can't destroy and logs xrLocateSpaces once.

Not changed: the 1.1 Meta profile names match xr.xml's promoted names
(meta/touch_pro_controller, meta/touch_plus_controller), and grip_surface is
palm_ext renamed, so the rewrite stays (now commented).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 frame/openxr-compat/README.md                 |   2 +-
 frame/openxr-compat/compat_logic.h            |   1 +
 frame/openxr-compat/layer.cpp                 |   7 +++++--
 .../arm64-v8a/libXrApiLayer_FRAME_compat.so   | Bin 98936 -> 99864 bytes
 tests/test_frame_apk_vr.py                    |  14 ++++++++++++++
 ui/frame_android.py                           |  11 +++++++----
 ui/frame_apk_sign.py                          |  13 +++++++++----
 7 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/frame/openxr-compat/README.md b/frame/openxr-compat/README.md
index 4d5eb60..5978979 100644
--- a/frame/openxr-compat/README.md
+++ b/frame/openxr-compat/README.md
@@ -238,7 +238,7 @@ from the binary; runtime execution of those paths remains unverified.
 Prebuilt library SHA-256:
 
 ```
-aace99b7bcdb3c79fa844d75a9483f8f4b16bd6e669fb3003515df8c673ce54b
+479d31c374f137906e03f73209b581d65d7e6a41b8476e6425fa55a6aa40bd68
 ```
 
 APK SHA-256:
diff --git a/frame/openxr-compat/compat_logic.h b/frame/openxr-compat/compat_logic.h
index a5c6e57..9d94fbc 100644
--- a/frame/openxr-compat/compat_logic.h
+++ b/frame/openxr-compat/compat_logic.h
@@ -35,6 +35,7 @@ inline ExtensionPlan extensions(const Names& requested, const Names& available,
     }
     return p;
 }
+// 1.1's grip_surface is XR_EXT_palm_pose's palm_ext renamed (same pose), not the grip pose.
 inline std::string rewritePath(std::string p, bool palm) {
     const std::string suffix = "/input/grip_surface/pose";
     if (palm && (p == "/user/hand/left" + suffix || p == "/user/hand/right" + suffix))
diff --git a/frame/openxr-compat/layer.cpp b/frame/openxr-compat/layer.cpp
index a5433a7..79b858c 100644
--- a/frame/openxr-compat/layer.cpp
+++ b/frame/openxr-compat/layer.cpp
@@ -121,7 +121,8 @@ XrResult XRAPI_CALL destroySession(XrSession s) try {
 XrResult XRAPI_CALL locateSpaces(XrSession s, const XrSpacesLocateInfo* in, XrSpaceLocations* out) try {
     auto d = get(s); if (!d) return XR_ERROR_HANDLE_INVALID;
     if (!d->locate) return XR_ERROR_FUNCTION_UNSUPPORTED;
-    LOG("xrLocateSpaces -> xrLocateSpacesKHR (core/KHR type aliases)");
+    static std::once_flag logged;  // called every frame
+    std::call_once(logged, [] { LOG("xrLocateSpaces -> xrLocateSpacesKHR (core/KHR type aliases)"); });
     return frame::locate(d->locate, s, in, out);
 } GUARD_END
 XrResult XRAPI_CALL threadSettings(XrSession s, XrAndroidThreadTypeKHR type, uint32_t tid) try {
@@ -226,7 +227,9 @@ XrResult XRAPI_CALL createLayer(const XrInstanceCreateInfo* info, const XrApiLay
     d->gipa = next; d->instance = *instance;
     d->destroy = proc<PFN_xrDestroyInstance>(next, *instance, "xrDestroyInstance");
     // A successful runtime instance must expose xrDestroyInstance.
-    if (!d->destroy) { LOG("invalid downstream: missing xrDestroyInstance"); return XR_ERROR_INITIALIZATION_FAILED; }
+    if (!d->destroy) {  // nothing could ever destroy it, so don't hand it out
+        LOG("invalid downstream: missing xrDestroyInstance"); *instance = XR_NULL_HANDLE; return XR_ERROR_INITIALIZATION_FAILED;
+    }
     try {
         d->enabled = std::move(plan.downstream); d->stubbed = std::move(plan.stubbed);
         d->palm = frame::has(d->enabled, "XR_EXT_palm_pose");
diff --git a/frame/openxr-compat/prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so b/frame/openxr-compat/prebuilt/arm64-v8a/libXrApiLayer_FRAME_compat.so
index a58721a065638dde82d73ca8f733cde852743df4..608cdd13bf350b8be3133f782a78d0342c888f3d 100755
GIT binary patch
delta 27945
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
Zl7W2EGMn!zGR*DL3aOdcCafS4{|{UVG422W

delta 27385
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

diff --git a/tests/test_frame_apk_vr.py b/tests/test_frame_apk_vr.py
index 186ae58..8b801bc 100644
--- a/tests/test_frame_apk_vr.py
+++ b/tests/test_frame_apk_vr.py
@@ -202,6 +202,20 @@ class VRTests(unittest.TestCase):
                 z.writestr('classes.dex', b'')
             self.assertEqual(frame_android.xr_compat_files(str(flat)), {})
 
+    def test_xr_compat_layer_missing(self):
+        with tempfile.TemporaryDirectory() as d:
+            apk = Path(d) / 'a.apk'
+            with zipfile.ZipFile(apk, 'w') as z:
+                z.writestr('lib/arm64-v8a/libopenxr_loader.so', b'')
+            with patch.object(frame_android, 'XR_COMPAT', d):
+                with self.assertRaisesRegex(frame_android.FrameError, 'build.sh'):
+                    frame_android.xr_compat_files(str(apk))
+
+    def test_patch_rejects_corrupt_manifest_cleanly(self):
+        with patch.object(frame_android, 'apk_info', side_effect=struct.error('bad')):
+            with self.assertRaises(frame_android.FrameError):
+                frame_android.patch('x.apk', 'y.apk')
+
     def test_install_adds_layer_to_vr_apps(self):
         base = {'package': 'org.test.vr', 'label': 'VR', 'abis': [], 'min_sdk': None,
                 'vr': True, 'vr_activity': True, 'launchable': True}
diff --git a/ui/frame_android.py b/ui/frame_android.py
index cec2e07..f709a9d 100644
--- a/ui/frame_android.py
+++ b/ui/frame_android.py
@@ -10,7 +10,7 @@ Python stdlib only. CLI: python3 ui/frame_android.py
   install APK [--vr|--flat] [--no-xr-compat] | info APK | patch SRC DST [--add NAME=PATH ...]
   list | launch PKG | stop PKG | remove PKG | probe PKG
 """
-import json, os, re, shlex, shutil, subprocess, sys, threading, time, zlib
+import json, os, re, shlex, shutil, struct, subprocess, sys, threading, time, zlib
 
 import frame_apk
 import frame_host
@@ -86,8 +86,11 @@ def xr_compat_files(apk_path):
         return {}
     add = {}
     for entry, rel in XR_COMPAT_FILES.items():
-        with open(os.path.join(XR_COMPAT, rel), 'rb') as f:
-            add[entry] = f.read()
+        try:
+            with open(os.path.join(XR_COMPAT, rel), 'rb') as f:
+                add[entry] = f.read()
+        except OSError:
+            raise FrameError("the OpenXR compatibility layer isn't built; run frame/openxr-compat/build.sh")
     return add
 
 
@@ -326,7 +329,7 @@ def patch(src, dst, add=None):
         result['patched'] = (['launcher'] if manifest != original else []) + \
             (['openxr-compat'] if add and set(XR_COMPAT_FILES) <= set(add) else [])
         return result
-    except (OSError, ValueError, zipfile.BadZipFile, frame_apk.ApkError) as e:
+    except (OSError, ValueError, IndexError, struct.error, zipfile.BadZipFile, frame_apk.ApkError) as e:
         raise FrameError(str(e)) from e
 
 
diff --git a/ui/frame_apk_sign.py b/ui/frame_apk_sign.py
index 091820d..68580c5 100644
--- a/ui/frame_apk_sign.py
+++ b/ui/frame_apk_sign.py
@@ -126,15 +126,20 @@ def signing_key(path=None):
                 f.flush()
                 os.fsync(f.fileno())
             try:
-                os.link(tmp, path)
+                os.link(tmp, path)  # never replaces a key another process wrote first
             except FileExistsError:
                 pass
+            except OSError:  # no hard links (FAT/exFAT): plain rename
+                if not path.exists():
+                    os.replace(tmp, path)
         finally:
-            os.unlink(tmp)
-    os.chmod(path, 0o600)
+            if os.path.exists(tmp):
+                os.unlink(tmp)
+    os.chmod(path, 0o600)  # Windows ignores this; the per-user app-data folder is the protection there
     key = json.loads(path.read_text())
     if key['n'].bit_length() != 2048 or key['e'] != 65537:
-        raise ValueError('invalid cached APK signing key')
+        raise ValueError(f'invalid cached APK signing key; delete {path} to make a new one '
+                         '(re-signed apps then need reinstalling)')
     rsa_verify(b'key check', rsa_sign(b'key check', key), key['n'], key['e'])
     return key
 

From 077eab2b79384d084fd5c0eb8c39119b4e97e9d8 Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 20:19:38 +1000
Subject: [PATCH 08/12] Add LAUNCHER to the real VR activity when only an
 activity-alias has it

Lepton's apk-info-extractor ignores <activity-alias>, and Godot 4 exports put
LAUNCHER only on an alias (com.godot.game.GodotAppLauncher). Open Saber Plus
0.7.67 installed but Lepton exited with 'APP_ACTIVITY is empty'. Count only
real activities as launchable and patch the activity's VR intent filter.
Verified on the Frame: Open Saber Plus launches and renders.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/test_frame_apk_vr.py | 22 +++++++++++++++++++---
 ui/frame_apk_vr.py         |  8 +++++---
 2 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/tests/test_frame_apk_vr.py b/tests/test_frame_apk_vr.py
index 8b801bc..aa0d984 100644
--- a/tests/test_frame_apk_vr.py
+++ b/tests/test_frame_apk_vr.py
@@ -18,11 +18,11 @@ import frame_android
 from test_frame_apk import pool
 
 
-def manifest(utf8=False, launcher=False, category=None, samsung=False, split=False):
+def manifest(utf8=False, launcher=False, category=None, samsung=False, split=False, alias=False):
     strings = ['manifest', 'package', 'org.test.vr', 'application', 'activity', 'intent-filter',
                'action', 'category', 'name', vr.MAIN, category or next(iter(sorted(vr.VR))),
                vr.LAUNCHER, 'http://schemas.android.com/apk/res/android', 'meta-data', 'value',
-               'com.samsung.android.vr.application.mode', 'vr_only']
+               'com.samsung.android.vr.application.mode', 'vr_only', 'activity-alias']
     def start(tag, attrs=()):
         body = struct.pack('<IIHHHHHH', 0xffffffff, strings.index(tag), 20, 20, len(attrs), 0, 0, 0)
         for name, value in attrs:
@@ -42,7 +42,12 @@ def manifest(utf8=False, launcher=False, category=None, samsung=False, split=Fal
         b += end('intent-filter') + start('intent-filter')
     if launcher:
         b += leaf('category', [('name', vr.LAUNCHER)])
-    b += end('intent-filter') + end('activity') + end('application') + end('manifest')
+    b += end('intent-filter') + end('activity')
+    if alias:  # Godot 4: LAUNCHER only on an alias of the VR activity
+        b += start('activity-alias') + start('intent-filter') + leaf('action', [('name', vr.MAIN)])
+        b += leaf('category', [('name', strings[10])]) + leaf('category', [('name', vr.LAUNCHER)])
+        b += end('intent-filter') + end('activity-alias')
+    b += end('application') + end('manifest')
     return struct.pack('<HHI', 3, 8, len(b) + 8) + b
 
 
@@ -74,6 +79,17 @@ class VRTests(unittest.TestCase):
         self.assertFalse(vr.inspect(manifest(launcher=True, split=True))[0]['launchable'])
         self.assertTrue(vr.inspect(vr.add_launcher_category(manifest(launcher=True, split=True)))[0]['launchable'])
 
+    def test_alias_launcher_is_not_enough(self):
+        original = manifest(alias=True)
+        info, filters = vr.inspect(original)
+        self.assertFalse(info['launchable'])
+        self.assertTrue(info['vr_activity'])
+        self.assertEqual(len(filters), 1)
+        result = vr.add_launcher_category(original)
+        info, filters = vr.inspect(result)
+        self.assertTrue(info['launchable'])
+        self.assertIn(vr.LAUNCHER, filters[0]['categories'])
+
     def test_styled_pool(self):
         for utf8 in (False, True):
             p = bytearray(pool(['styled'], utf8))
diff --git a/ui/frame_apk_vr.py b/ui/frame_apk_vr.py
index 6d835f7..08e93d1 100644
--- a/ui/frame_apk_vr.py
+++ b/ui/frame_apk_vr.py
@@ -16,7 +16,7 @@ def inspect(data):
             tag, attrs = next(elements)
             value = attrs.get('name', (None, None, None))[2]
             if tag == 'intent-filter' and stack and stack[-1] in ('activity', 'activity-alias'):
-                current = {'actions': set(), 'categories': set(), 'templates': []}
+                current = {'actions': set(), 'categories': set(), 'templates': [], 'alias': stack[-1] == 'activity-alias'}
             if current is not None and stack and stack[-1] == 'intent-filter':
                 if tag == 'action':
                     current['actions'].add(value)
@@ -34,8 +34,10 @@ def inspect(data):
                 current = None
     mains = [f for f in filters if MAIN in f['actions']]
     vr_filters = [f for f in mains if VR & f['categories']]
-    return {'launchable': any(LAUNCHER in f['categories'] for f in mains),
-            'vr_activity': bool(vr_filters), 'vr': bool(vr_filters) or samsung}, vr_filters
+    # Lepton's apk-info-extractor ignores <activity-alias>; Godot 4 puts LAUNCHER only there.
+    return {'launchable': any(LAUNCHER in f['categories'] for f in mains if not f['alias']),
+            'vr_activity': bool(vr_filters), 'vr': bool(vr_filters) or samsung}, \
+        [f for f in vr_filters if not f['alias']]
 
 
 def _append_string(chunk, text):

From e1c0ac983c52acd2eb82ed04f65b9b15d0bb19be Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 20:40:16 +1000
Subject: [PATCH 09/12] Repair alias-only launchers for flat apps too; never
 fail on a VR alias

Review follow-up. inspect() now returns 'repairable' and the filters it can
patch: the real activity's VR MAIN filter, or, when LAUNCHER/VR sits only on an
<activity-alias>, any real MAIN filter with a category to copy. install() and
patch() repair on 'repairable' instead of 'vr_activity', so a flat Godot 4
export is fixed and a VR category only on the alias no longer aborts install.
Tests cover both shapes, an already-launchable activity with an alias, and an
end-to-end patch.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 tests/test_frame_apk_vr.py | 55 +++++++++++++++++++++++++++++---------
 ui/frame_android.py        | 11 ++++----
 ui/frame_apk_vr.py         | 14 ++++++----
 3 files changed, 57 insertions(+), 23 deletions(-)

diff --git a/tests/test_frame_apk_vr.py b/tests/test_frame_apk_vr.py
index aa0d984..da87d15 100644
--- a/tests/test_frame_apk_vr.py
+++ b/tests/test_frame_apk_vr.py
@@ -18,11 +18,14 @@ import frame_android
 from test_frame_apk import pool
 
 
+DEFAULT = 'android.intent.category.DEFAULT'
+
+
 def manifest(utf8=False, launcher=False, category=None, samsung=False, split=False, alias=False):
     strings = ['manifest', 'package', 'org.test.vr', 'application', 'activity', 'intent-filter',
                'action', 'category', 'name', vr.MAIN, category or next(iter(sorted(vr.VR))),
                vr.LAUNCHER, 'http://schemas.android.com/apk/res/android', 'meta-data', 'value',
-               'com.samsung.android.vr.application.mode', 'vr_only', 'activity-alias']
+               'com.samsung.android.vr.application.mode', 'vr_only', 'activity-alias', DEFAULT, next(iter(sorted(vr.VR)))]
     def start(tag, attrs=()):
         body = struct.pack('<IIHHHHHH', 0xffffffff, strings.index(tag), 20, 20, len(attrs), 0, 0, 0)
         for name, value in attrs:
@@ -43,9 +46,11 @@ def manifest(utf8=False, launcher=False, category=None, samsung=False, split=Fal
     if launcher:
         b += leaf('category', [('name', vr.LAUNCHER)])
     b += end('intent-filter') + end('activity')
-    if alias:  # Godot 4: LAUNCHER only on an alias of the VR activity
+    if alias:  # Godot 4: LAUNCHER only on an alias of the activity ('vr' or 'flat')
         b += start('activity-alias') + start('intent-filter') + leaf('action', [('name', vr.MAIN)])
-        b += leaf('category', [('name', strings[10])]) + leaf('category', [('name', vr.LAUNCHER)])
+        if alias == 'vr':
+            b += leaf('category', [('name', next(iter(sorted(vr.VR))))])
+        b += leaf('category', [('name', vr.LAUNCHER)])
         b += end('intent-filter') + end('activity-alias')
     b += end('application') + end('manifest')
     return struct.pack('<HHI', 3, 8, len(b) + 8) + b
@@ -80,15 +85,39 @@ class VRTests(unittest.TestCase):
         self.assertTrue(vr.inspect(vr.add_launcher_category(manifest(launcher=True, split=True)))[0]['launchable'])
 
     def test_alias_launcher_is_not_enough(self):
-        original = manifest(alias=True)
-        info, filters = vr.inspect(original)
-        self.assertFalse(info['launchable'])
-        self.assertTrue(info['vr_activity'])
-        self.assertEqual(len(filters), 1)
-        result = vr.add_launcher_category(original)
-        info, filters = vr.inspect(result)
+        # (manifest, still VR after patching)
+        cases = [(manifest(alias='vr'), True),                    # Godot 4 VR export
+                 (manifest(alias='vr', category=DEFAULT), True),  # VR category only on the alias
+                 (manifest(alias='flat', category=DEFAULT), False)]  # Godot 4 flat export
+        for original, is_vr in cases:
+            info, filters = vr.inspect(original)
+            self.assertFalse(info['launchable'])
+            self.assertTrue(info['repairable'])
+            self.assertEqual(len(filters), 1)
+            self.assertFalse(filters[0]['alias'])
+            result = vr.add_launcher_category(original)
+            info, _ = vr.inspect(result)
+            self.assertTrue(info['launchable'])
+            self.assertFalse(info['repairable'])
+            self.assertEqual(info['vr'], is_vr)
+
+    def test_alias_with_launchable_activity_is_left_alone(self):
+        original = manifest(launcher=True, alias='vr')
+        info, _ = vr.inspect(original)
         self.assertTrue(info['launchable'])
-        self.assertIn(vr.LAUNCHER, filters[0]['categories'])
+        self.assertFalse(info['repairable'])
+        self.assertEqual(vr.add_launcher_category(original), original)
+
+    def test_patch_alias_apk(self):
+        with tempfile.TemporaryDirectory() as d:
+            src, dst = Path(d) / 'in.apk', Path(d) / 'out.apk'
+            with zipfile.ZipFile(src, 'w') as z:
+                z.writestr('AndroidManifest.xml', manifest(alias='flat', category=DEFAULT))
+            with patch.object(signing, 'signing_key', return_value=self.key):
+                result = frame_android.patch(src, dst)
+            self.assertEqual(result['patched'], ['launcher'])
+            self.assertTrue(frame_apk.apk_info(dst)['launchable'])
+            self.assertTrue(signing.verify(dst))
 
     def test_styled_pool(self):
         for utf8 in (False, True):
@@ -189,7 +218,7 @@ class VRTests(unittest.TestCase):
 
     def test_install_auto_and_override(self):
         base = {'package': 'org.test.vr', 'label': 'VR', 'abis': [], 'min_sdk': None,
-                'vr': True, 'vr_activity': True, 'launchable': False}
+                'vr': True, 'vr_activity': True, 'launchable': False, 'repairable': True}
         with patch.object(frame_android, 'apk_info', return_value=base), \
                 patch.object(frame_android, 'xr_compat_files', return_value={}), \
                 patch.object(frame_android, 'patch', return_value={'patched': ['launcher']}) as repair, \
@@ -234,7 +263,7 @@ class VRTests(unittest.TestCase):
 
     def test_install_adds_layer_to_vr_apps(self):
         base = {'package': 'org.test.vr', 'label': 'VR', 'abis': [], 'min_sdk': None,
-                'vr': True, 'vr_activity': True, 'launchable': True}
+                'vr': True, 'vr_activity': True, 'launchable': True, 'repairable': False}
         layer = {'x': b''}
         with patch.object(frame_android, 'apk_info', return_value=dict(base)), \
                 patch.object(frame_android, 'xr_compat_files', return_value=layer), \
diff --git a/ui/frame_android.py b/ui/frame_android.py
index 306860a..499e99e 100644
--- a/ui/frame_android.py
+++ b/ui/frame_android.py
@@ -149,7 +149,7 @@ def install(apk_path, flatscreen=None, name=None, source=None, icon_png=None, xr
     # changes calls SteamVR would otherwise reject.
     add = xr_compat_files(apk_path) if (info['vr'] if xr_compat is None else xr_compat) else {}
     with _install_lock:
-        if add or (not info['launchable'] and info['vr_activity']):
+        if add or info['repairable']:
             with tempfile.TemporaryDirectory(prefix='frame-vr-') as tmp:
                 patched = os.path.join(tmp, 'app.apk')
                 info['patched'] = patch(apk_path, patched, add)['patched']
@@ -320,8 +320,8 @@ def patch(src, dst, add=None):
         info = apk_info(src)
         with zipfile.ZipFile(src) as z:
             original = frame_apk._read(z, 'AndroidManifest.xml', frame_apk.MAX_MANIFEST)
-        manifest = add_launcher_category(original) if info['vr_activity'] else original
-        if not info['launchable'] and not info['vr_activity']:
+        manifest = add_launcher_category(original) if info['repairable'] else original
+        if not info['launchable'] and not info['repairable']:
             raise FrameError('APK has no MAIN/LAUNCHER or patchable VR activity')
         repack(src, dst, replace={'AndroidManifest.xml': manifest}, add=add)
         result = apk_info(dst)
@@ -341,8 +341,9 @@ def main():
             if cmd == 'info':
                 info = apk_info(args[0])
                 print(frame_apk_versions.describe(info))
-                if info.get('vr'):
-                    print('VR app' + ('' if info.get('launchable') else '; Frame Control adds the LAUNCHER entry Lepton needs'))
+                fix = '; Frame Control adds the LAUNCHER entry Lepton needs' if info.get('repairable') else ''
+                if info.get('vr') or fix:
+                    print(('VR app' if info.get('vr') else 'Android app') + fix)
                 for note in info.get('vr_issues', []):
                     print(note)
                 return
diff --git a/ui/frame_apk_vr.py b/ui/frame_apk_vr.py
index 08e93d1..a9895cd 100644
--- a/ui/frame_apk_vr.py
+++ b/ui/frame_apk_vr.py
@@ -35,9 +35,13 @@ def inspect(data):
     mains = [f for f in filters if MAIN in f['actions']]
     vr_filters = [f for f in mains if VR & f['categories']]
     # Lepton's apk-info-extractor ignores <activity-alias>; Godot 4 puts LAUNCHER only there.
-    return {'launchable': any(LAUNCHER in f['categories'] for f in mains if not f['alias']),
-            'vr_activity': bool(vr_filters), 'vr': bool(vr_filters) or samsung}, \
-        [f for f in vr_filters if not f['alias']]
+    real = [f for f in mains if not f['alias']]
+    targets = [f for f in real if VR & f['categories']]
+    if not targets and any(LAUNCHER in f['categories'] or VR & f['categories'] for f in mains if f['alias']):
+        targets = [f for f in real if f['templates']]  # the patch copies an existing <category>
+    launchable = any(LAUNCHER in f['categories'] for f in real)
+    return {'launchable': launchable, 'repairable': not launchable and bool(targets),
+            'vr_activity': bool(vr_filters), 'vr': bool(vr_filters) or samsung}, targets
 
 
 def _append_string(chunk, text):
@@ -64,7 +68,7 @@ def add_launcher_category(axml_bytes):
     if info['launchable']:
         return axml_bytes
     if not filters:
-        raise frame_apk.ApkError('no VR activity with a MAIN intent filter to patch')
+        raise frame_apk.ApkError('no activity with a MAIN intent filter that Frame Control can patch')
     target = filters[0]
     chunks = list(frame_apk._chunks(axml_bytes, 8, len(axml_bytes)))
     pool = next(c for c in chunks if c[0] == 1)
@@ -87,7 +91,7 @@ def add_launcher_category(axml_bytes):
             struct.pack_into('<HBBI', start, a + 12, 8, 0, 3, index)
             break
     else:
-        raise frame_apk.ApkError('VR category has no name attribute')
+        raise frame_apk.ApkError('category has no name attribute')
     end = struct.pack('<HHI', 0x0103, hs, hs + 8) + start[8:hs] + start[hs:hs + 8]
     result = bytearray(axml_bytes[:8])
     for _, _, off, size in chunks:

From 268afccf055f7f297962a739e8cde2b836ffcb05 Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 20:52:30 +1000
Subject: [PATCH 10/12] APK sources: shared interface for source modules

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 ui/apk_sources/__init__.py | 45 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 ui/apk_sources/__init__.py

diff --git a/ui/apk_sources/__init__.py b/ui/apk_sources/__init__.py
new file mode 100644
index 0000000..88df1f4
--- /dev/null
+++ b/ui/apk_sources/__init__.py
@@ -0,0 +1,45 @@
+"""APK sources: every place Frame Control can find and download APKs.
+
+One module per source kind in this package. Each module exposes the same small
+interface so ``search.py`` can query them all and show where every result came
+from. Python stdlib only; must run on Python 3.9.
+
+Module interface
+----------------
+KIND = 'sidequest'            # stable id of the source kind
+def sources() -> list[dict]   # configured sources of this kind (a kind can have
+                              # several, e.g. one per F-Droid-format repo)
+def search(source, query, limit=50) -> list[dict]   # Entry dicts, best first
+def details(source, entry_id) -> dict               # Entry with 'versions'
+def download(source, entry_id, version_code=None) -> dict
+    # {'apk': local path, 'obb': [paths], 'sha256': hex or None, 'verified': bool}
+    # Raise SourceError with a user-readable message on failure.
+
+Source dict
+-----------
+{'id': 'sidequest', 'kind': KIND, 'name': 'SideQuest', 'url': 'https://...',
+ 'builtin': True, 'enabled': True, 'trust': 'official' | 'community' | 'user'}
+
+Entry dict (missing facts are None, never guessed)
+----------
+{'source': source id, 'id': source-local id, 'package': 'org.example.app' or None,
+ 'name': str, 'summary': str, 'icon': url or None, 'page': url or None,
+ 'version': '1.2', 'version_code': 12, 'min_sdk': 24, 'abis': ['arm64-v8a'],
+ 'vr': True/False/None, 'size': bytes, 'free': True, 'license': 'GPL-3.0' or None,
+ 'updated': 'YYYY-MM-DD', 'downloadable': bool,   # False = open page only
+ 'versions': [ {version, version_code, min_sdk, size, updated}, ... ]}  # details() only
+
+Rules
+-----
+- Only sources that distribute APKs with the developer's consent: free listings,
+  never paid apps re-hosted, no licence or entitlement workarounds.
+- Honour each site's terms and robots rules; if automated download isn't allowed,
+  return entries with 'downloadable': False and a 'page' link instead.
+- Cache indexes under frame_host.cache_dir('apk-sources'); send a clear
+  User-Agent ('FrameControl/<version>'); keep requests modest.
+- Tests use recorded fixtures, never the network.
+"""
+
+
+class SourceError(Exception):
+    """User-readable failure from a source (network, format, verification)."""

From 9e9e5950d0635c5e3bec178bbf7047492c208a9e Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 20:55:56 +1000
Subject: [PATCH 11/12] Patch the activity the launcher alias targets, not the
 first MAIN filter

Second review follow-up: with several activities (e.g. a splash activity ahead
of the game), the alias fallback now prefers the real activity named by the
alias's android:targetActivity. Reads targetActivity by resource id, updates
the error text and docs/vr-apks.md.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 docs/vr-apks.md            |  7 +++++--
 tests/test_frame_apk_vr.py | 24 ++++++++++++++++++++----
 ui/frame_android.py        |  2 +-
 ui/frame_apk.py            |  3 ++-
 ui/frame_apk_vr.py         | 11 +++++++++--
 5 files changed, 37 insertions(+), 10 deletions(-)

diff --git a/docs/vr-apks.md b/docs/vr-apks.md
index 8d31cc3..e57325c 100644
--- a/docs/vr-apks.md
+++ b/docs/vr-apks.md
@@ -100,8 +100,11 @@ VR apps default to immersive mode without the flatscreen marker. The upload
 selector or CLI `--flat` / `--vr` overrides that choice. Compatibility notes
 identify legacy VrApi, Meta platform SDK and OpenXR libraries.
 
-If a VR MAIN intent filter lacks LAUNCHER, Frame Control inserts it, repacks
-and v2-signs the APK locally before copying it; `meta.json` records
+Lepton only starts an `<activity>` whose MAIN intent filter has LAUNCHER; it
+ignores `<activity-alias>`, which is where Godot 4 exports put LAUNCHER. When no
+real activity qualifies, Frame Control adds LAUNCHER to the VR activity's MAIN
+filter, or to the activity the launcher alias targets, then repacks and v2-signs
+the APK locally before copying it; `meta.json` records
 `"patched": ["launcher"]`. Unchanged ZIP members retain their compressed
 bytes; stored libraries are aligned to 16 KiB. The RSA signing identity lives
 in Frame Control's per-user app-data directory as `apk-signing-key.json`
diff --git a/tests/test_frame_apk_vr.py b/tests/test_frame_apk_vr.py
index da87d15..49a56ca 100644
--- a/tests/test_frame_apk_vr.py
+++ b/tests/test_frame_apk_vr.py
@@ -21,11 +21,11 @@ from test_frame_apk import pool
 DEFAULT = 'android.intent.category.DEFAULT'
 
 
-def manifest(utf8=False, launcher=False, category=None, samsung=False, split=False, alias=False):
+def manifest(utf8=False, launcher=False, category=None, samsung=False, split=False, alias=False, splash=False):
     strings = ['manifest', 'package', 'org.test.vr', 'application', 'activity', 'intent-filter',
                'action', 'category', 'name', vr.MAIN, category or next(iter(sorted(vr.VR))),
                vr.LAUNCHER, 'http://schemas.android.com/apk/res/android', 'meta-data', 'value',
-               'com.samsung.android.vr.application.mode', 'vr_only', 'activity-alias', DEFAULT, next(iter(sorted(vr.VR)))]
+               'com.samsung.android.vr.application.mode', 'vr_only', 'activity-alias', DEFAULT, next(iter(sorted(vr.VR))), 'targetActivity', '.Splash', '.Game']
     def start(tag, attrs=()):
         body = struct.pack('<IIHHHHHH', 0xffffffff, strings.index(tag), 20, 20, len(attrs), 0, 0, 0)
         for name, value in attrs:
@@ -39,7 +39,10 @@ def manifest(utf8=False, launcher=False, category=None, samsung=False, split=Fal
     b = pool(strings, utf8) + start('manifest', [('package', 'org.test.vr')]) + start('application')
     if samsung:
         b += leaf('meta-data', [('name', strings[15]), ('value', 'vr_only')])
-    b += start('activity') + start('intent-filter') + leaf('action', [('name', vr.MAIN)])
+    if splash:  # a helper activity with its own MAIN filter, ahead of the game's
+        b += start('activity', [('name', '.Splash')]) + start('intent-filter') + leaf('action', [('name', vr.MAIN)])
+        b += leaf('category', [('name', DEFAULT)]) + end('intent-filter') + end('activity')
+    b += start('activity', [('name', '.Game')] if splash else []) + start('intent-filter') + leaf('action', [('name', vr.MAIN)])
     b += leaf('category', [('name', strings[10])])
     if split:
         b += end('intent-filter') + start('intent-filter')
@@ -47,7 +50,7 @@ def manifest(utf8=False, launcher=False, category=None, samsung=False, split=Fal
         b += leaf('category', [('name', vr.LAUNCHER)])
     b += end('intent-filter') + end('activity')
     if alias:  # Godot 4: LAUNCHER only on an alias of the activity ('vr' or 'flat')
-        b += start('activity-alias') + start('intent-filter') + leaf('action', [('name', vr.MAIN)])
+        b += start('activity-alias', [('targetActivity', '.Game')] if splash else []) + start('intent-filter') + leaf('action', [('name', vr.MAIN)])
         if alias == 'vr':
             b += leaf('category', [('name', next(iter(sorted(vr.VR))))])
         b += leaf('category', [('name', vr.LAUNCHER)])
@@ -101,6 +104,19 @@ class VRTests(unittest.TestCase):
             self.assertFalse(info['repairable'])
             self.assertEqual(info['vr'], is_vr)
 
+    def test_alias_target_activity_is_patched(self):
+        original = manifest(alias='flat', category=DEFAULT, splash=True)
+        info, filters = vr.inspect(original)
+        self.assertTrue(info['repairable'])
+        self.assertEqual(filters[0]['activity'], 'org.test.vr.Game')
+        owner, launchers = None, []
+        for tag, attrs in frame_apk.manifest_elements(vr.add_launcher_category(original)):
+            if tag in ('activity', 'activity-alias'):
+                owner = (tag, attrs.get('name', (0, 0, None))[2])
+            if tag == 'category' and attrs['name'][2] == vr.LAUNCHER:
+                launchers.append(owner)
+        self.assertEqual(launchers, [('activity', '.Game'), ('activity-alias', None)])
+
     def test_alias_with_launchable_activity_is_left_alone(self):
         original = manifest(launcher=True, alias='vr')
         info, _ = vr.inspect(original)
diff --git a/ui/frame_android.py b/ui/frame_android.py
index 499e99e..5e1deba 100644
--- a/ui/frame_android.py
+++ b/ui/frame_android.py
@@ -322,7 +322,7 @@ def patch(src, dst, add=None):
             original = frame_apk._read(z, 'AndroidManifest.xml', frame_apk.MAX_MANIFEST)
         manifest = add_launcher_category(original) if info['repairable'] else original
         if not info['launchable'] and not info['repairable']:
-            raise FrameError('APK has no MAIN/LAUNCHER or patchable VR activity')
+            raise FrameError('APK has no MAIN/LAUNCHER activity that Frame Control can patch')
         repack(src, dst, replace={'AndroidManifest.xml': manifest}, add=add)
         result = apk_info(dst)
         result.pop('icon_png', None)
diff --git a/ui/frame_apk.py b/ui/frame_apk.py
index 0be260a..7b7a9ff 100644
--- a/ui/frame_apk.py
+++ b/ui/frame_apk.py
@@ -10,7 +10,8 @@ import zipfile
 
 # android: attribute resource ids; names can be stripped by shrinkers, ids can't.
 ATTR = {0x01010001: 'label', 0x01010002: 'icon', 0x01010003: 'name',
-        0x01010024: 'value', 0x0101021b: 'versionCode', 0x0101021c: 'versionName', 0x0101020c: 'minSdkVersion'}
+        0x01010024: 'value', 0x0101021b: 'versionCode', 0x0101021c: 'versionName', 0x0101020c: 'minSdkVersion',
+        0x01010202: 'targetActivity'}
 T_REF, T_STRING, T_INT_DEC, T_INT_HEX = 0x01, 0x03, 0x10, 0x11
 # APKs can come from websites (install links), so nothing read from one may be
 # unbounded. zipfile stops at a member's declared size, so checking it is enough.
diff --git a/ui/frame_apk_vr.py b/ui/frame_apk_vr.py
index a9895cd..e87b46f 100644
--- a/ui/frame_apk_vr.py
+++ b/ui/frame_apk_vr.py
@@ -10,13 +10,18 @@ VR = {'com.oculus.intent.category.VR', 'org.khronos.openxr.intent.category.IMMER
 def inspect(data):
     elements = iter(frame_apk.manifest_elements(data))
     stack, filters, samsung = [], [], False
-    current = None
+    current, owner, package = None, None, ''
     for kind, hs, off, size in frame_apk._chunks(data, 8, len(data)):
         if kind == 0x0102:
             tag, attrs = next(elements)
             value = attrs.get('name', (None, None, None))[2]
+            if tag == 'manifest':
+                package = attrs.get('package', (None, None, None))[2] or ''
+            if tag in ('activity', 'activity-alias'):
+                owner = attrs.get('targetActivity', (None, None, None))[2] if tag == 'activity-alias' else value
+                owner = package + owner if owner and owner.startswith('.') else owner
             if tag == 'intent-filter' and stack and stack[-1] in ('activity', 'activity-alias'):
-                current = {'actions': set(), 'categories': set(), 'templates': [], 'alias': stack[-1] == 'activity-alias'}
+                current = {'actions': set(), 'categories': set(), 'templates': [], 'alias': stack[-1] == 'activity-alias', 'activity': owner}
             if current is not None and stack and stack[-1] == 'intent-filter':
                 if tag == 'action':
                     current['actions'].add(value)
@@ -38,7 +43,9 @@ def inspect(data):
     real = [f for f in mains if not f['alias']]
     targets = [f for f in real if VR & f['categories']]
     if not targets and any(LAUNCHER in f['categories'] or VR & f['categories'] for f in mains if f['alias']):
+        aimed = {f['activity'] for f in mains if f['alias'] and (LAUNCHER in f['categories'] or VR & f['categories'])}
         targets = [f for f in real if f['templates']]  # the patch copies an existing <category>
+        targets = [f for f in targets if f['activity'] in aimed] or targets
     launchable = any(LAUNCHER in f['categories'] for f in real)
     return {'launchable': launchable, 'repairable': not launchable and bool(targets),
             'vr_activity': bool(vr_filters), 'vr': bool(vr_filters) or samsung}, targets

From 038dcd48cd75336f6a86c63c7878bfc9c52deec9 Mon Sep 17 00:00:00 2001
From: saphid <4596216+saphid@users.noreply.github.com>
Date: Mon, 28 Sep 2026 21:04:55 +1000
Subject: [PATCH 12/12] Treat bare activity names as package-relative when
 matching the alias target

Third review follow-up (PackageParser.buildClassName). Confirmed the
targetActivity resource id 0x01010202 in Open Saber Plus's manifest.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 ui/frame_apk_vr.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/ui/frame_apk_vr.py b/ui/frame_apk_vr.py
index e87b46f..013fd55 100644
--- a/ui/frame_apk_vr.py
+++ b/ui/frame_apk_vr.py
@@ -19,6 +19,8 @@ def inspect(data):
                 package = attrs.get('package', (None, None, None))[2] or ''
             if tag in ('activity', 'activity-alias'):
                 owner = attrs.get('targetActivity', (None, None, None))[2] if tag == 'activity-alias' else value
+                if owner and '.' not in owner:  # PackageParser.buildClassName: bare names are relative too
+                    owner = '.' + owner
                 owner = package + owner if owner and owner.startswith('.') else owner
             if tag == 'intent-filter' and stack and stack[-1] in ('activity', 'activity-alias'):
                 current = {'actions': set(), 'categories': set(), 'templates': [], 'alias': stack[-1] == 'activity-alias', 'activity': owner}