diff --git a/docs/Features/Advanced/Classes-and-Modules.md b/docs/Features/Advanced/Classes-and-Modules.md
index 54242c51..7870ad4f 100644
--- a/docs/Features/Advanced/Classes-and-Modules.md
+++ b/docs/Features/Advanced/Classes-and-Modules.md
@@ -54,7 +54,7 @@ Public Function MyExportedFunction(ByVal arg As Long) As Long
 Public Function MyCDeclExport CDecl(ByVal arg As Long)
 ```
 
-This is primarily used to create Standard DLLs (see [Project Types](../Project-Configuration/Project-Types.md)), but this functionality is also available in Standard EXE and other compiled project types.
+This is primarily used to create Standard DLLs (see [Project Types](../Project-Configuration/Project-Types)), but this functionality is also available in Standard EXE and other compiled project types.
 
 ## Create classes without `IDispatch`
 
diff --git a/docs/Features/GUI-Components/Forms.md b/docs/Features/GUI-Components/Forms.md
index 2356ac84..106e5120 100644
--- a/docs/Features/GUI-Components/Forms.md
+++ b/docs/Features/GUI-Components/Forms.md
@@ -41,7 +41,7 @@ In addition to the above, forms have:
 - Control anchoring: control x/y/cx/cy can made relative, so they're automatically moved/resized with the Form. For example if you put a TextBox in the bottom right, then check the Right and Bottom anchors (in addition to Top and Left), the bottom right will size with the form on resize. This saves a lot of boiler-plate sizing code.
 - Control docking: Controls can be fixed along one of the sides of the Form (or container), or made to fill the whole Form/container. Multiple controls can be combined and mixed/matched in docking positions.
 
-For more information on Control Anchoring and Control Docking, see the [Anchoring and Docking page](Anchoring-Docking.md).
+For more information on Control Anchoring and Control Docking, see the [Anchoring and Docking page](Anchoring-Docking).
 
 ## High Quality Scaling in Image Controls
 
diff --git a/docs/Gemfile b/docs/Gemfile
index f2a0d906..fbd01ea7 100644
--- a/docs/Gemfile
+++ b/docs/Gemfile
@@ -8,23 +8,17 @@ source "https://rubygems.org"
 gem "jekyll", "~> 4.2"
 gem "logger"
 gem "fiddle"
-gem "nokogiri"
 gem "bigdecimal"
-gem "rake"
-gem "html-proofer"
+gem "rake" # required at runtime by just-the-docs via jekyll-remote-theme
 
 group :jekyll_plugins do
   gem "jekyll-remote-theme", "= 0.4.3"
   gem "jekyll-sass-converter", "~> 2.2"
   gem "jekyll-seo-tag"
   gem "jekyll-include-cache"
-  gem "jekyll-titles-from-headings"
   gem "jekyll-sitemap"
   gem "jekyll-relative-links"
   gem "jekyll-redirect-from"
-  gem "jekyll-optional-front-matter"
-  gem "jekyll-github-metadata"
-  gem "jekyll-default-layout"
   gem "jekyll-gfm-admonitions"
 end
 
diff --git a/docs/Gemfile.lock b/docs/Gemfile.lock
index 9f138f94..41b4b3ad 100644
--- a/docs/Gemfile.lock
+++ b/docs/Gemfile.lock
@@ -1,63 +1,25 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    Ascii85 (2.0.1)
     addressable (2.8.8)
       public_suffix (>= 2.0.2, < 8.0)
-    afm (1.0.0)
-    async (2.35.0)
-      console (~> 1.29)
-      fiber-annotation
-      io-event (~> 1.11)
-      metrics (~> 0.12)
-      traces (~> 0.18)
     base64 (0.3.0)
-    benchmark (0.5.0)
     bigdecimal (4.0.1)
     colorator (1.1.0)
     concurrent-ruby (1.3.6)
-    console (1.34.2)
-      fiber-annotation
-      fiber-local (~> 1.1)
-      json
     cssminify (1.0.2)
     csv (3.3.5)
     em-websocket (0.5.3)
       eventmachine (>= 0.12.9)
       http_parser.rb (~> 0)
-    ethon (0.15.0)
-      ffi (>= 1.15.0)
     eventmachine (1.2.7)
-    faraday (2.14.0)
-      faraday-net_http (>= 2.0, < 3.5)
-      json
-      logger
-    faraday-net_http (3.4.2)
-      net-http (~> 0.5)
-    ffi (1.17.2)
     ffi (1.17.2-x64-mingw-ucrt)
     ffi (1.17.2-x86_64-linux-gnu)
-    fiber-annotation (0.2.0)
-    fiber-local (1.1.0)
-      fiber-storage
-    fiber-storage (1.0.1)
     fiddle (1.1.8)
     forwardable-extended (2.6.0)
-    hashery (2.1.2)
-    html-proofer (5.1.1)
-      addressable (~> 2.3)
-      async (~> 2.1)
-      benchmark (~> 0.5)
-      nokogiri (~> 1.13)
-      pdf-reader (~> 2.11)
-      rainbow (~> 3.0)
-      typhoeus (~> 1.3)
-      yell (~> 2.0)
-      zeitwerk (~> 2.5)
     http_parser.rb (0.8.1)
     i18n (1.14.8)
       concurrent-ruby (~> 1.0)
-    io-event (1.14.2)
     jekyll (4.4.1)
       addressable (~> 2.4)
       base64 (~> 0.2)
@@ -77,19 +39,12 @@ GEM
       safe_yaml (~> 1.0)
       terminal-table (>= 1.8, < 4.0)
       webrick (~> 1.7)
-    jekyll-default-layout (0.1.5)
-      jekyll (>= 3.0, < 5.0)
     jekyll-gfm-admonitions (1.2.0)
       cssminify (~> 1.0)
       jekyll (>= 3.0, < 5.0)
       octicons (~> 19.8)
-    jekyll-github-metadata (2.16.1)
-      jekyll (>= 3.4, < 5.0)
-      octokit (>= 4, < 7, != 4.4.0)
     jekyll-include-cache (0.2.1)
       jekyll (>= 3.7, < 5.0)
-    jekyll-optional-front-matter (0.3.2)
-      jekyll (>= 3.0, < 5.0)
     jekyll-redirect-from (0.16.0)
       jekyll (>= 3.3, < 5.0)
     jekyll-relative-links (0.7.0)
@@ -105,8 +60,6 @@ GEM
       jekyll (>= 3.8, < 5.0)
     jekyll-sitemap (1.4.0)
       jekyll (>= 3.7, < 5.0)
-    jekyll-titles-from-headings (0.5.3)
-      jekyll (>= 3.3, < 5.0)
     jekyll-watch (2.2.1)
       listen (~> 3.0)
     json (2.18.0)
@@ -120,62 +73,29 @@ GEM
       rb-inotify (~> 0.9, >= 0.9.10)
     logger (1.7.0)
     mercenary (0.4.0)
-    metrics (0.15.0)
-    mini_portile2 (2.8.9)
-    net-http (0.9.1)
-      uri (>= 0.11.1)
-    nokogiri (1.18.10)
-      mini_portile2 (~> 2.8.2)
-      racc (~> 1.4)
-    nokogiri (1.18.10-x64-mingw-ucrt)
-      racc (~> 1.4)
-    nokogiri (1.18.10-x86_64-linux-gnu)
-      racc (~> 1.4)
     octicons (19.21.1)
-    octokit (6.1.1)
-      faraday (>= 1, < 3)
-      sawyer (~> 0.9)
     pathutil (0.16.2)
       forwardable-extended (~> 2.6)
-    pdf-reader (2.15.0)
-      Ascii85 (>= 1.0, < 3.0, != 2.0.0)
-      afm (>= 0.2.1, < 2)
-      hashery (~> 2.0)
-      ruby-rc4
-      ttfunk
     public_suffix (7.0.0)
-    racc (1.8.1)
-    rainbow (3.1.1)
-    rake (13.3.1)
+    rake (13.4.2)
     rb-fsevent (0.11.2)
     rb-inotify (0.11.1)
       ffi (~> 1.0)
     rexml (3.4.4)
     rouge (4.6.1)
-    ruby-rc4 (0.1.5)
     rubyzip (2.4.1)
     safe_yaml (1.0.5)
     sassc (2.4.0)
       ffi (~> 1.9)
-    sawyer (0.9.3)
-      addressable (>= 2.3.5)
-      faraday (>= 0.17.3, < 3)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
-    traces (0.18.2)
-    ttfunk (1.7.0)
-    typhoeus (1.5.0)
-      ethon (>= 0.9.0, < 0.16.0)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     tzinfo-data (1.2025.3)
       tzinfo (>= 1.0.0)
     unicode-display_width (2.6.0)
-    uri (1.1.1)
     wdm (0.2.0)
     webrick (1.9.2)
-    yell (2.2.2)
-    zeitwerk (2.7.4)
 
 PLATFORMS
   x64-mingw-ucrt
@@ -184,71 +104,46 @@ PLATFORMS
 DEPENDENCIES
   bigdecimal
   fiddle
-  html-proofer
   jekyll (~> 4.2)
-  jekyll-default-layout
   jekyll-gfm-admonitions
-  jekyll-github-metadata
   jekyll-include-cache
-  jekyll-optional-front-matter
   jekyll-redirect-from
   jekyll-relative-links
   jekyll-remote-theme (= 0.4.3)
   jekyll-sass-converter (~> 2.2)
   jekyll-seo-tag
   jekyll-sitemap
-  jekyll-titles-from-headings
   logger
-  nokogiri
   rake
   tzinfo (>= 1, < 3)
   tzinfo-data
   wdm (~> 0.1)
 
 CHECKSUMS
-  Ascii85 (2.0.1) sha256=15cb5d941808543cbb9e7e6aea3c8ec3877f154c3461e8b3673e97f7ecedbe5a
   addressable (2.8.8) sha256=7c13b8f9536cf6364c03b9d417c19986019e28f7c00ac8132da4eb0fe393b057
-  afm (1.0.0) sha256=5bd4d6f6241e7014ef090985ec6f4c3e9745f6de0828ddd58bc1efdd138f4545
-  async (2.35.0) sha256=0f792ce968023677669fb8608d0b16585332247181ed5417b4ff45900201e834
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  benchmark (0.5.0) sha256=465df122341aedcb81a2a24b4d3bd19b6c67c1530713fd533f3ff034e419236c
   bigdecimal (4.0.1) sha256=8b07d3d065a9f921c80ceaea7c9d4ae596697295b584c296fe599dd0ad01c4a7
   colorator (1.1.0) sha256=e2f85daf57af47d740db2a32191d1bdfb0f6503a0dfbc8327d0c9154d5ddfc38
   concurrent-ruby (1.3.6) sha256=6b56837e1e7e5292f9864f34b69c5a2cbc75c0cf5338f1ce9903d10fa762d5ab
-  console (1.34.2) sha256=1c036abf606ccec83f9dc28f0c31710fe5936ffe7ba5d235ae2865590a482d58
   cssminify (1.0.2) sha256=f574503558cd442c6286831ffdbebdb4587f6deb827ef7575f73f377a376a898
   csv (3.3.5) sha256=6e5134ac3383ef728b7f02725d9872934f523cb40b961479f69cf3afa6c8e73f
   em-websocket (0.5.3) sha256=f56a92bde4e6cb879256d58ee31f124181f68f8887bd14d53d5d9a292758c6a8
-  ethon (0.15.0) sha256=0809805a035bc10f54162ca99f15ded49e428e0488bcfe1c08c821e18261a74d
   eventmachine (1.2.7) sha256=994016e42aa041477ba9cff45cbe50de2047f25dd418eba003e84f0d16560972
-  faraday (2.14.0) sha256=8699cfe5d97e55268f2596f9a9d5a43736808a943714e3d9a53e6110593941cd
-  faraday-net_http (3.4.2) sha256=f147758260d3526939bf57ecf911682f94926a3666502e24c69992765875906c
-  ffi (1.17.2) sha256=297235842e5947cc3036ebe64077584bff583cd7a4e94e9a02fdec399ef46da6
   ffi (1.17.2-x64-mingw-ucrt) sha256=15d2da54ee578657a333a6059ed16eaba1cbd794ceecd15944825b65c8381ac0
   ffi (1.17.2-x86_64-linux-gnu) sha256=05d2026fc9dbb7cfd21a5934559f16293815b7ce0314846fee2ac8efbdb823ea
-  fiber-annotation (0.2.0) sha256=7abfadf1d119f508867d4103bf231c0354d019cc39a5738945dec2edadaf6c03
-  fiber-local (1.1.0) sha256=c885f94f210fb9b05737de65d511136ea602e00c5105953748aa0f8793489f06
-  fiber-storage (1.0.1) sha256=f48e5b6d8b0be96dac486332b55cee82240057065dc761c1ea692b2e719240e1
   fiddle (1.1.8) sha256=7fa8ee3627271497f3add5503acdbc3f40b32f610fc1cf49634f083ef3f32eee
   forwardable-extended (2.6.0) sha256=1bec948c469bbddfadeb3bd90eb8c85f6e627a412a3e852acfd7eaedbac3ec97
-  hashery (2.1.2) sha256=d239cc2310401903f6b79d458c2bbef5bf74c46f3f974ae9c1061fb74a404862
-  html-proofer (5.1.1) sha256=f9baaae2268049918eb494b0a5b96e97f513a6b8490c185d11c371b60d9ecf86
   http_parser.rb (0.8.1) sha256=9ae8df145b39aa5398b2f90090d651c67bd8e2ebfe4507c966579f641e11097a
   i18n (1.14.8) sha256=285778639134865c5e0f6269e0b818256017e8cde89993fdfcbfb64d088824a5
-  io-event (1.14.2) sha256=b0a069190eafe86005c22f7464f744971b5bd82f153740d34e6ab49548d4f613
   jekyll (4.4.1) sha256=4c1144d857a5b2b80d45b8cf5138289579a9f8136aadfa6dd684b31fe2bc18c1
-  jekyll-default-layout (0.1.5) sha256=c626be4e4a5deafca123539da2cd22ff873be350cafd4da134039efdf24320af
   jekyll-gfm-admonitions (1.2.0) sha256=38b95c75449033465313a92c2da3ee311d3569f38e6053c635bc16d3c28e702d
-  jekyll-github-metadata (2.16.1) sha256=4cf29988bdaf24774a7bc07fae71e54424ddfaa2895f742d8fa3036d0db65b4c
   jekyll-include-cache (0.2.1) sha256=c7d4b9e551732a27442cb2ce853ba36a2f69c66603694b8c1184c99ab1a1a205
-  jekyll-optional-front-matter (0.3.2) sha256=ecdc061d711472469fcf04da617653b553e914c038a17df3b6a5f6f92aeb761b
   jekyll-redirect-from (0.16.0) sha256=6635cae569ef9b0f90ffb71ec014ba977177fafb44d32a2b0526288d4d9be6db
   jekyll-relative-links (0.7.0) sha256=831e54c348eeae751845c0d4ac4b244bd73b664341f0e8c9f1803b16f4570835
   jekyll-remote-theme (0.4.3) sha256=d3fde726484fb3df04de9e347baf75aaa3d5bfea771a330412e0c52608e54b40
   jekyll-sass-converter (2.2.0) sha256=71894f61b1f062f9d56e90b83b29386c85af349749c5d6277a5ba4b2e69cfd1c
   jekyll-seo-tag (2.8.0) sha256=3f2ed1916d56f14ebfa38e24acde9b7c946df70cb183af2cb5f0598f21ae6818
   jekyll-sitemap (1.4.0) sha256=0de08c5debc185ea5a8f980e1025c7cd3f8e0c35c8b6ef592f15c46235cf4218
-  jekyll-titles-from-headings (0.5.3) sha256=77366754e361ea7b5d87881f5b1380835f5ce910c240a4d9ac2d7afe86d28481
   jekyll-watch (2.2.1) sha256=bc44ed43f5e0a552836245a54dbff3ea7421ecc2856707e8a1ee203a8387a7e1
   json (2.18.0) sha256=b10506aee4183f5cf49e0efc48073d7b75843ce3782c68dbeb763351c08fd505
   kramdown (2.5.1) sha256=87bbb6abd9d3cebe4fc1f33e367c392b4500e6f8fa19dd61c0972cf4afe7368c
@@ -257,41 +152,23 @@ CHECKSUMS
   listen (3.9.0) sha256=db9e4424e0e5834480385197c139cb6b0ae0ef28cc13310cfd1ca78377d59c67
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
   mercenary (0.4.0) sha256=b25a1e4a59adca88665e08e24acf0af30da5b5d859f7d8f38fba52c28f405138
-  metrics (0.15.0) sha256=61ded5bac95118e995b1bc9ed4a5f19bc9814928a312a85b200abbdac9039072
-  mini_portile2 (2.8.9) sha256=0cd7c7f824e010c072e33f68bc02d85a00aeb6fce05bb4819c03dfd3c140c289
-  net-http (0.9.1) sha256=25ba0b67c63e89df626ed8fac771d0ad24ad151a858af2cc8e6a716ca4336996
-  nokogiri (1.18.10) sha256=d5cc0731008aa3b3a87b361203ea3d19b2069628cb55e46ac7d84a0445e69cc1
-  nokogiri (1.18.10-x64-mingw-ucrt) sha256=64f40d4a41af9f7f83a4e236ad0cf8cca621b97e31f727b1bebdae565a653104
-  nokogiri (1.18.10-x86_64-linux-gnu) sha256=ff5ba26ba2dbce5c04b9ea200777fd225061d7a3930548806f31db907e500f72
   octicons (19.21.1) sha256=52f7330d7896fd18521999d1f6e9191f8b85ab22268b77e9f6d983a988556485
-  octokit (6.1.1) sha256=920e4a9d820205f70738f58de6a7e6ef0e2f25b27db954b5806a63105207b0bf
   pathutil (0.16.2) sha256=e43b74365631cab4f6d5e4228f812927efc9cb2c71e62976edcb252ee948d589
-  pdf-reader (2.15.0) sha256=c5025750bec8de7b11cfd1d1ccc2b944d2782c3638cd15b5ee1531d1206c0886
   public_suffix (7.0.0) sha256=f7090b5beb0e56f9f10d79eed4d5fbe551b3b425da65877e075dad47a6a1b095
-  racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f
-  rainbow (3.1.1) sha256=039491aa3a89f42efa1d6dec2fc4e62ede96eb6acd95e52f1ad581182b79bc6a
-  rake (13.3.1) sha256=8c9e89d09f66a26a01264e7e3480ec0607f0c497a861ef16063604b1b08eb19c
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
   rb-fsevent (0.11.2) sha256=43900b972e7301d6570f64b850a5aa67833ee7d87b458ee92805d56b7318aefe
   rb-inotify (0.11.1) sha256=a0a700441239b0ff18eb65e3866236cd78613d6b9f78fea1f9ac47a85e47be6e
   rexml (3.4.4) sha256=19e0a2c3425dfbf2d4fc1189747bdb2f849b6c5e74180401b15734bc97b5d142
   rouge (4.6.1) sha256=5075346d5797d6864be93f7adc75a16047a7dbfa572c63c502419ffa582c77de
-  ruby-rc4 (0.1.5) sha256=00cc40a39d20b53f5459e7ea006a92cf584e9bc275e2a6f7aa1515510e896c03
   rubyzip (2.4.1) sha256=8577c88edc1fde8935eb91064c5cb1aef9ad5494b940cf19c775ee833e075615
   safe_yaml (1.0.5) sha256=a6ac2d64b7eb027bdeeca1851fe7e7af0d668e133e8a88066a0c6f7087d9f848
   sassc (2.4.0) sha256=4c60a2b0a3b36685c83b80d5789401c2f678c1652e3288315a1551d811d9f83e
-  sawyer (0.9.3) sha256=0d0f19298408047037638639fe62f4794483fb04320269169bd41af2bdcf5e41
   terminal-table (3.0.2) sha256=f951b6af5f3e00203fb290a669e0a85c5dd5b051b3b023392ccfd67ba5abae91
-  traces (0.18.2) sha256=80f1649cb4daace1d7174b81f3b3b7427af0b93047759ba349960cb8f315e214
-  ttfunk (1.7.0) sha256=2370ba484b1891c70bdcafd3448cfd82a32dd794802d81d720a64c15d3ef2a96
-  typhoeus (1.5.0) sha256=120b67ed1ef515e6c0e938176db880f15b0916f038e78ce2a66290f3f1de3e3b
   tzinfo (2.0.6) sha256=8daf828cc77bcf7d63b0e3bdb6caa47e2272dcfaf4fbfe46f8c3a9df087a829b
   tzinfo-data (1.2025.3) sha256=b546e2f1e5e5c40a0c619aafb24e30d3d6a128c2f689278f721b7286dd499562
   unicode-display_width (2.6.0) sha256=12279874bba6d5e4d2728cef814b19197dbb10d7a7837a869bab65da943b7f5a
-  uri (1.1.1) sha256=379fa58d27ffb1387eaada68c749d1426738bd0f654d812fcc07e7568f5c57c6
   wdm (0.2.0) sha256=c46d9dcb6d375199ca07465bc67669ee8f041aeaa55dd7dafe6de4dd97b27647
   webrick (1.9.2) sha256=beb4a15fc474defed24a3bda4ffd88a490d517c9e4e6118c3edce59e45864131
-  yell (2.2.2) sha256=1d166f3cc3b6dc49a59778ea7156ed6d8de794c15106d48ffd6cbb061b9b26bc
-  zeitwerk (2.7.4) sha256=2bef90f356bdafe9a6c2bd32bcd804f83a4f9b8bc27f3600fff051eb3edcec8b
 
 BUNDLED WITH
   4.0.2
diff --git a/docs/IDE/Menu/Project.md b/docs/IDE/Menu/Project.md
index 7c368466..f629bc67 100644
--- a/docs/IDE/Menu/Project.md
+++ b/docs/IDE/Menu/Project.md
@@ -20,16 +20,16 @@ permalink: /tB/IDE/Project/Menu/Project
 
 ## Add
 
-**Add** is the same as Right Click Add on the [Project Explorer](../Project%20Explorer.md)
+**Add** is the same as Right Click Add on the [Project Explorer](../Explorer)
 
 ![Right-Click Add](../Images/RightClick-Add.png "Right-Click Add")
 
 ## References
 
-See [Project Settings](../Project%20Settings.md) filtered by "project.references".
+See [Project Settings](../Settings) filtered by "project.references".
 
 ![Library References - Project Settings](../Images/ProjectSettings_LibraryReferences.png "Library References - Project Settings")
 
 ## Project Settings
 
-See [Project Settings](../Project%20Settings.md).
+See [Project Settings](../Settings).
diff --git a/docs/IDE/Package Publishing.md b/docs/IDE/Package Publishing.md
index 7228ba7c..d91d6e50 100644
--- a/docs/IDE/Package Publishing.md	
+++ b/docs/IDE/Package Publishing.md	
@@ -15,4 +15,4 @@ Once you open a project you will be able to edit the properties.
 
 ![Package Publishing](Images/PackagePublishing_1.png "Package Publishing")
 
-Click the "EDIT" and this will open the [Project Settings](Project%20Settings.md)
+Click the "EDIT" and this will open the [Project Settings](Settings)
diff --git a/docs/IDE/Project Settings.md b/docs/IDE/Project Settings.md
index b9c31cc7..d0091138 100644
--- a/docs/IDE/Project Settings.md	
+++ b/docs/IDE/Project Settings.md	
@@ -31,7 +31,7 @@ Listed below are the project settings, in the same order as they appear in the P
 
 ![Available COM References - Project Settings](Images/ProjectSettings_AvailableCOMReferences.png "Available COM References - Project Settings")
 
-See [Packages](../Features/Packages/index.md)
+See [Packages](../../../Features/Packages/)
 
 ![432410211-d9f1e4d9-1805-47e5-93aa-251151b4e914](../Features/Packages/Images/e749e10f-e361-4f15-a977-d756fcb3b5dd.png)
 
diff --git a/docs/Miscellaneous/Documentation Development.md b/docs/Miscellaneous/Documentation Development.md
index d4b01335..cf340f9d 100644
--- a/docs/Miscellaneous/Documentation Development.md	
+++ b/docs/Miscellaneous/Documentation Development.md	
@@ -130,12 +130,10 @@ Before checking link integrity, the documentation must be built. This can be don
 
 To check that none of the internal links in the most recent documentation build are broken:
 
-    bundle exec htmlproofer ./_site --disable-external --no-enforce-https
-
-or, on Windows only
-
     check.bat
 
+This runs [Lychee](https://github.com/lycheeverse/lychee) in offline mode against the built `_site/`.
+
 ### Building and Local Serving
 
 To build and serve the documentation from http://localhost:4000:
diff --git a/docs/_config.yml b/docs/_config.yml
index 0a4deb46..92bdd141 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -15,6 +15,10 @@ remote_theme: just-the-docs/just-the-docs@v0.10.1
 highlighter: rouge
 
 defaults:
+  - scope:
+      path: ""
+    values:
+      layout: default
   - scope:
       path: "*/Images"
     values:
@@ -22,7 +26,7 @@ defaults:
   - scope:
       path: "assets/css"
     values:
-      render_with_liquid: true      
+      render_with_liquid: true
 
 # GitHub-style admonitions are supported, but we may wish to add custom
 # callouts below.
@@ -31,11 +35,6 @@ callouts:
   #  title: 💡 Tip
   #  color: green
 
-#defaults:
-#  - scope:
-#      path: ""
-#    values:
-#      layout: default
 
 #collections:
 #  intro:
diff --git a/docs/_includes/components/breadcrumbs.html b/docs/_includes/components/breadcrumbs.html
new file mode 100644
index 00000000..0e54ea08
--- /dev/null
+++ b/docs/_includes/components/breadcrumbs.html
@@ -0,0 +1,35 @@
+{%- comment -%}
+  Shadow of just-the-docs's _includes/components/breadcrumbs.html.
+
+  Renders the breadcrumb trail above each page's body by iterating the
+  precomputed chain attached to each page by
+  `_plugins/breadcrumbs-precompute.rb`. The upstream version walks the
+  cached site_nav HTML per page (~7 s across the site); offloading the
+  walk to Ruby makes this include essentially free.
+
+  Expected data shape on `page.breadcrumb_chain`:
+    Array of { "title" => String, "url" => String }, ordered root-first
+    (the ancestor nearest the site root is at index 0). The current
+    page itself is not in the chain -- it is rendered separately as the
+    final `<li>` with a `<span>`.
+
+  If the plugin is absent or the page has no chain (e.g. root pages
+  without `parent`), `page.breadcrumb_chain` is nil and the for-loop
+  emits nothing; only the current-page `<span>` is rendered, but the
+  outer guard `page.parent` prevents the whole block in that case.
+
+  Output parity with the upstream version: anchors carry no class
+  attribute, items use `breadcrumb-nav-list-item`, and the current
+  page is wrapped in a `<span>` rather than an `<a>`.
+{%- endcomment -%}
+
+{%- if page.url != "/" and page.parent and page.title -%}
+<nav aria-label="Breadcrumb" class="breadcrumb-nav">
+  <ol class="breadcrumb-nav-list">
+    {%- for entry in page.breadcrumb_chain %}
+    <li class="breadcrumb-nav-list-item"><a href="{{ entry.url | relative_url }}">{{ entry.title }}</a></li>
+    {%- endfor %}
+    <li class="breadcrumb-nav-list-item"><span>{{ page.title }}</span></li>
+  </ol>
+</nav>
+{%- endif -%}
diff --git a/docs/_includes/components/children_nav.html b/docs/_includes/components/children_nav.html
new file mode 100644
index 00000000..d24b3e71
--- /dev/null
+++ b/docs/_includes/components/children_nav.html
@@ -0,0 +1,40 @@
+{%- comment -%}
+  Shadow of just-the-docs's _includes/components/children_nav.html.
+
+  Renders the auto-generated child-pages TOC at the bottom of any page
+  whose `has_toc != false`. The upstream implementation includes the
+  cached `site_nav` HTML with `all=true` to probe for the current
+  page's children, then re-derives the children via
+  `where:` / `group_by:` on `site.html_pages`. The probe is the only
+  thing that forces a second site_nav cache key (alongside
+  `sidebar.html`'s `all=nil` variant); eliminating the probe halves the
+  nav-rendering work.
+
+  The list of immediate children is now precomputed at site-generate
+  time by `_plugins/children-precompute.rb` and exposed as
+  `page.children_in_nav`. Each entry is a hash:
+
+      { "title" => String, "url" => String, "summary" => String | nil }
+
+  ordered with the same nav_order / title precedence and
+  child_nav_order reversal the upstream applies.
+
+  When the array is empty (a leaf page, or `has_toc != false` on a
+  page that genuinely has no children), the whole block collapses to
+  nothing -- byte-identical to the upstream's behaviour on the same
+  pages.
+{%- endcomment -%}
+
+{%- if page.children_in_nav and page.children_in_nav.size >= 1 -%}
+
+<hr>
+{% include toc_heading_custom.html %}
+<ul>
+  {% for nav_child in page.children_in_nav %}
+  <li>
+    <a href="{{ nav_child.url | relative_url }}">{{ nav_child.title }}</a>{% if nav_child.summary %} - {{ nav_child.summary }}{% endif %}
+  </li>
+  {% endfor %}
+</ul>
+
+{%- endif -%}
diff --git a/docs/_includes/css/activation.scss.liquid b/docs/_includes/css/activation.scss.liquid
new file mode 100644
index 00000000..14f21db8
--- /dev/null
+++ b/docs/_includes/css/activation.scss.liquid
@@ -0,0 +1,132 @@
+{%- comment -%}
+  Shadow of just-the-docs's _includes/css/activation.scss.liquid.
+
+  Emits the per-page CSS that highlights the current page's nav entry,
+  unfolds its ancestor collections, and rotates their expander icons --
+  the no-JS fallback that lives in the `<style id="jtd-nav-activation">`
+  block in head.html. When JavaScript is enabled the theme's
+  `disableHeadStyleSheets()` disables this block before applying
+  `.active` classes via `activateNav()`; visitors with JS off rely on
+  these rules.
+
+  The upstream computes the page's positional path through the nav
+  tree by scanning the cached site_nav HTML (~150 KB) per page, which
+  costs ~11 s across the ~830-page site. This shadow consumes
+  `page.nav_levels` precomputed in Ruby by
+  `_plugins/nav-levels-precompute.rb` -- the same `[i, j, k, ...]`
+  array the upstream Liquid algorithm would build. The output CSS is
+  byte-identical to the upstream version after HTML compression.
+
+  Data shape on `page.nav_levels`:
+    Array of integers, ordered from collection-index outward:
+      nav_levels[0]   = collection index (always 1 on this site;
+                        the activation prefix is
+                        `.site-nav > ul.nav-list:first-child`)
+      nav_levels[i]   = 1-based position of the i-th ancestor in its
+                        parent's sorted, nav-filtered children list,
+                        for i in 1..page_level
+      nav_levels.size = page_level + 1
+
+  When `page.nav_levels` is nil (page excluded from the nav, missing
+  parent reference, or otherwise unresolvable) the include falls
+  through to the upstream's `activation_no_nav_link` rules.
+
+  Selector shapes (matching the upstream output verbatim):
+
+    Background-image removal (one rule, comma-separated parts):
+      - one part per ancestor level above the page's own level
+        (`prefix > li > a`, `prefix > li > ul > li > a`, ...)
+      - one part at the page's own level excluding the active sibling
+        (`prefix > ... > li:not(:nth-child(N)) > a`)
+      - one part covering all of the page's descendants
+        (`prefix > ... > li > ul > li a`)
+      - plus `.site-nav > ul.nav-list:not(:first-child) a` and
+        `.site-nav li.external a`
+
+    Active link bolding:
+      `prefix > li:nth-child(N1) > ul > li:nth-child(N2) > ... > a`
+
+    Expander rotation (one part per level, comma-separated):
+      `prefix > li:nth-child(N1) > ... > li:nth-child(Ni) > button svg`
+
+    Collection unfolding (one part per level, comma-separated):
+      `prefix > li.nav-list-item:nth-child(N1) > ... > ul.nav-list`
+{%- endcomment -%}
+
+{%- if page.nav_levels -%}
+
+  {%- assign nav_page_level = page.nav_levels.size | minus: 1 -%}
+  {%- assign nav_page_parent_level = nav_page_level | minus: 1 -%}
+
+  {%- capture activation_collection_prefix -%}
+  .site-nav > ul.nav-list:first-child
+  {%- endcapture -%}
+
+    {% if nav_page_level >= 2 -%}
+    {%- for i in (1..nav_page_parent_level) -%}
+    {{ activation_collection_prefix }} >
+    {%- for j in (2..i) %} li > ul >
+    {%- endfor %} li > a,
+    {% endfor -%}
+    {%- endif %}
+    {{ activation_collection_prefix }} >
+    {%- for i in (1..nav_page_parent_level) %} li > ul >
+    {%- endfor %} li:not(:nth-child({{ page.nav_levels[nav_page_level] }})) > a,
+    {{ activation_collection_prefix }} >
+    {%- for i in (1..nav_page_level) %} li > ul >
+    {%- endfor %} li a {
+      background-image: none;
+    }
+
+    .site-nav > ul.nav-list:not(:first-child) a,
+    .site-nav li.external a {
+      background-image: none;
+    }
+
+    {{ activation_collection_prefix }} > li:nth-child({{ page.nav_levels[1] }})
+    {%- for i in (2..nav_page_level) %} > ul > li:nth-child({{ page.nav_levels[i] }})
+    {%- endfor %} > a {
+      font-weight: 600;
+      text-decoration: none;
+    }
+
+    {%- if site.just_the_docs.collections %}
+    .site-nav > ul.nav-category-list > li > button svg,
+    {% endif -%}
+    {{ activation_collection_prefix }} > li:nth-child({{ page.nav_levels[1] }}) > button svg
+    {%- for i in (2..nav_page_level) %},
+    {{ activation_collection_prefix }} > li:nth-child({{ page.nav_levels[1] }}) >
+    {%- for j in (2..i) %} ul > li:nth-child({{ page.nav_levels[j] }}) >
+    {%- endfor %} button svg
+    {%- endfor %} {
+      transform: rotate(-90deg);
+    }
+
+    {%- if site.just_the_docs.collections %}
+    .site-nav > ul.nav-category-list > li.nav-list-item > ul.nav-list,
+    {% endif -%}
+    {{ activation_collection_prefix }} > li.nav-list-item:nth-child({{ page.nav_levels[1] }}) > ul.nav-list
+    {%- for i in (2..nav_page_level) %},
+    {{ activation_collection_prefix }} > li.nav-list-item:nth-child({{ page.nav_levels[1] }}) >
+    {%- for j in (2..i) %} ul.nav-list > li.nav-list-item:nth-child({{ page.nav_levels[j] }}) >
+    {%- endfor %} ul.nav-list
+    {%- endfor %} {
+      display: block;
+    }
+
+{%- else -%}
+
+    .site-nav ul li a {
+      background-image: none;
+    }
+
+    {%- if site.just_the_docs.collections %}
+    .site-nav > ul.nav-category-list > li > button svg {
+      transform: rotate(-90deg);
+    }
+    .site-nav > ul.nav-category-list > li.nav-list-item > ul.nav-list {
+      display: block;
+    }
+    {%- endif %}
+
+{%- endif -%}
diff --git a/docs/_plugins/breadcrumbs-precompute.rb b/docs/_plugins/breadcrumbs-precompute.rb
new file mode 100644
index 00000000..d0d63263
--- /dev/null
+++ b/docs/_plugins/breadcrumbs-precompute.rb
@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# Precomputes per-page breadcrumb chains so that the breadcrumbs include
+# can iterate a ready-made array instead of resolving ancestors at render
+# time.
+#
+# === Problem ===
+#
+# just-the-docs's stock `_includes/components/breadcrumbs.html` walks the
+# cached `site_nav` HTML (~150 KB) by string-splitting it at the current
+# page's `<a>` tag and stepping backward through `</a>` boundaries to
+# recover the ancestor anchors. That is roughly O(nav size) per page, so
+# at ~830 pages it sits at ~7 s of the RENDER phase.
+#
+# An equivalent Liquid rewrite using `where:` filters on
+# `site.html_pages` does not help: each `where:` is itself O(N_pages),
+# and the total number of comparisons works out to the same order of
+# magnitude as the upstream's string scanning. Liquid lacks a real
+# hash-lookup primitive, so walking the `parent` / `grand_parent` chain
+# inside a template cannot beat the upstream's complexity.
+#
+# === Approach ===
+#
+# Move the chain resolution out of Liquid and into Ruby, where a hash
+# lookup actually is O(1). At generate time (after `site.read`, before
+# rendering) we:
+#
+#   1. Collect every page that has a `title`. Pages without a title are
+#      not nav-eligible -- they cannot appear in any breadcrumb chain.
+#   2. Build a `title -> [pages]` hash. Most titles are unique on this
+#      site, but a handful (e.g. "Enumerations", which appears under
+#      WebView2, CEF, CustomControls, WinServicesLib, and
+#      WinNativeCommonCtls) need disambiguation. We keep the full list
+#      of pages per title and disambiguate on lookup.
+#   3. For each page with a `parent`, walk the chain upward:
+#        - At each step, look up the next ancestor by title.
+#        - If the current page has `grand_parent`, narrow the candidate
+#          set to ancestors whose own `parent` matches `grand_parent`.
+#          When no candidate matches the narrowed criterion we fall back
+#          to the first title hit -- the convention on this site is to
+#          declare `grand_parent` only when needed, so the fall-through
+#          case is safe by construction.
+#        - Push the ancestor onto the chain and step up. The depth is
+#          bounded at MAX_DEPTH to defend against accidental cycles in
+#          frontmatter.
+#   4. Store the resulting chain on `page.data['breadcrumb_chain']` as
+#      an Array of `{ "title" => String, "url" => String }` hashes,
+#      ordered root-first. The shape is deliberately a plain Hash (not
+#      a Page reference) so Liquid can render it without dragging in a
+#      full Page Drop -- which would defeat the point of precomputing.
+#
+# `_includes/components/breadcrumbs.html` consumes
+# `page.breadcrumb_chain` directly. The rendered HTML is byte-identical
+# to the upstream's output.
+#
+# === Compatibility ===
+#
+# Reads only `page.data['title']`, `page.data['parent']`, and
+# `page.data['grand_parent']`, plus `page.url`. These are all stable
+# Jekyll/just-the-docs fields. The plugin neither registers Liquid
+# filters nor mutates anything other than `page.data` -- if it is
+# removed, the breadcrumbs include's `for entry in page.breadcrumb_chain`
+# simply iterates `nil` and emits no ancestor entries (just the
+# current-page span), which is a graceful failure mode.
+#
+# MAX_DEPTH is set to 8: the deepest chain on the site today is 5
+# levels (Reference Section -> Packages -> VBA Package -> Strings
+# Module -> Len). 8 leaves comfortable headroom for future growth and
+# guarantees termination on any frontmatter that contains a cycle.
+
+module BreadcrumbsPrecompute
+  MAX_DEPTH = 8
+
+  class Generator < Jekyll::Generator
+    safe true
+    priority :normal
+
+    def generate(site)
+      # `site.html_pages` is a Liquid-drop method; from Ruby we filter
+      # `site.pages` directly. We only care about pages with a `title`,
+      # since pages without one cannot appear in any breadcrumb chain.
+      titled = site.pages.select { |p| p.data["title"] }
+      by_title = titled.group_by { |p| p.data["title"] }
+
+      titled.each do |page|
+        page.data["breadcrumb_chain"] = chain_for(page, by_title)
+      end
+    end
+
+    private
+
+    def chain_for(page, by_title)
+      chain = []
+      current = page
+
+      MAX_DEPTH.times do
+        parent_title = current.data["parent"]
+        break if parent_title.nil? || parent_title.to_s.empty?
+
+        parent = resolve_parent(parent_title, current.data["grand_parent"], by_title)
+        break unless parent
+
+        chain.unshift(
+          "title" => parent.data["title"],
+          "url" => parent.url,
+        )
+        current = parent
+      end
+
+      chain
+    end
+
+    def resolve_parent(parent_title, grand_parent_title, by_title)
+      candidates = by_title[parent_title]
+      return nil unless candidates
+
+      if grand_parent_title
+        narrowed = candidates.find { |c| c.data["parent"] == grand_parent_title }
+        return narrowed if narrowed
+      end
+
+      candidates.first
+    end
+  end
+end
diff --git a/docs/_plugins/build-phase-timing.rb b/docs/_plugins/build-phase-timing.rb
new file mode 100644
index 00000000..ad02ed5a
--- /dev/null
+++ b/docs/_plugins/build-phase-timing.rb
@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# Logs the wall-clock duration of each top-level Jekyll build phase
+# (READ / GENERATE / RENDER / WRITE+CLEANUP) to the build output as the
+# phase boundaries are crossed.
+#
+# `jekyll build --profile` prints per-Liquid-template render times in a
+# summary table at the end of the build, but the build phase breakdown
+# is only visible there if --profile is passed. With this plugin you see
+# each phase's duration inline, alongside the existing log lines from
+# plugins (jekyll-remote-theme, jekyll-gfm-admonitions, etc.), so the
+# otherwise-silent stretch between a generator's last log line and a
+# :post_render hook's first log line becomes a visible number.
+#
+# Example output:
+#
+#       Phases: READ done in 540ms.
+#         GFMA: Converted admonitions in 232 file(s).
+#         GFMA: Generator ran in 410ms.
+#       Phases: GENERATE done in 3800ms.
+#         GFMA: Inserting admonition CSS in 0 page(s).
+#       Phases: RENDER done in 12030ms.
+#       Phases: WRITE+CLEANUP done in 580ms.
+#                    done in 16.960 seconds.
+#
+# Phase to hook mapping:
+#
+#   :site, :after_reset  -- end of RESET, start of READ.
+#   :site, :post_read    -- end of READ, start of GENERATE.
+#   :site, :pre_render   -- end of GENERATE, start of RENDER.
+#   :site, :post_render  -- end of RENDER, start of CLEANUP+WRITE.
+#   :site, :post_write   -- end of WRITE, build effectively done.
+#
+# RESET itself is not measured separately; in practice it is a few ms of
+# clearing the site model and is bundled into the brief gap between
+# `:after_init` and `:after_reset`. CLEANUP (removing orphaned files
+# from `_site`) and WRITE (writing rendered output to disk) share a hook
+# boundary -- Jekyll has no hook between them -- so they are reported as
+# one bucket.
+#
+# Numbers are wall-clock from a monotonic clock, not CPU time; they
+# include any GC pauses and I/O waits that landed in the phase.
+
+module BuildPhaseTiming
+  MARKS = {}
+
+  def self.mark(name)
+    MARKS[name] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def self.log_phase(label, from, to)
+    return unless MARKS[from] && MARKS[to]
+    elapsed_ms = ((MARKS[to] - MARKS[from]) * 1000).round(0)
+    Jekyll.logger.info "Phases:", "#{label} done in #{elapsed_ms}ms."
+  end
+end
+
+Jekyll::Hooks.register :site, :after_reset do
+  BuildPhaseTiming.mark(:read_start)
+end
+
+Jekyll::Hooks.register :site, :post_read do
+  BuildPhaseTiming.mark(:read_end)
+  BuildPhaseTiming.log_phase("READ",          :read_start,   :read_end)
+end
+
+Jekyll::Hooks.register :site, :pre_render do
+  BuildPhaseTiming.mark(:generate_end)
+  BuildPhaseTiming.log_phase("GENERATE",      :read_end,     :generate_end)
+end
+
+Jekyll::Hooks.register :site, :post_render do
+  BuildPhaseTiming.mark(:render_end)
+  BuildPhaseTiming.log_phase("RENDER",        :generate_end, :render_end)
+end
+
+Jekyll::Hooks.register :site, :post_write do
+  BuildPhaseTiming.mark(:write_end)
+  BuildPhaseTiming.log_phase("WRITE+CLEANUP", :render_end,   :write_end)
+end
diff --git a/docs/_plugins/children-precompute.rb b/docs/_plugins/children-precompute.rb
new file mode 100644
index 00000000..402087d0
--- /dev/null
+++ b/docs/_plugins/children-precompute.rb
@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+# Precomputes the per-page "children in nav" list so that
+# `_includes/components/children_nav.html` can render the auto-table-of-
+# contents at the bottom of each parent page by iterating a ready-made
+# array, without consulting the cached `site_nav` HTML.
+#
+# === Problem ===
+#
+# just-the-docs's stock `_includes/components/children_nav.html` does
+# the following on every page where `has_toc != false`:
+#
+#   1. Reads `{%- include_cached components/site_nav.html all=true -%}`
+#      to obtain a rendered nav tree that *includes* `nav_exclude: true`
+#      pages.
+#   2. Splits that HTML at the current page's `<a>` to probe whether
+#      the next character is `<ul`. If not, the page has no children
+#      and the include returns immediately.
+#   3. Otherwise, rebuilds `nav_parenthood = site.html_pages |
+#      group_by: "parent"` and walks it via `components/nav/children.html`
+#      to select, filter, and sort the children for rendering.
+#
+# Two side effects of step 1 dominate the cost. First, including
+# `site_nav.html` with `all=true` adds a second cache key on top of
+# the `all=nil` one used by `sidebar.html`, doubling the nav-tree
+# rendering (~67 recursive `nav/links.html` invocations per variant,
+# ~3 s total). Second, the probe is a string split on ~150 KB of
+# cached HTML, paid by every page that doesn't pre-empt with
+# `has_toc: false` -- and the fallback computation duplicates the
+# `where:` / `group_by` work that the cached render already did.
+#
+# === Approach ===
+#
+# Move the children resolution to Ruby and do it once per page at
+# generate time:
+#
+#   1. Build a `parent_title -> [pages]` map from frontmatter, the
+#      inverse of the breadcrumb plugin's title-to-pages map. Pages
+#      without a `title` are excluded -- they cannot appear in the nav.
+#   2. For each titled page, look up its candidate children by title
+#      and filter:
+#        - If the child declares `grand_parent`, it must match the
+#          parent page's own `parent` (the same disambiguation used by
+#          `components/nav/children.html` for non-unique parent titles
+#          like "Enumerations").
+#   3. Sort the surviving children with the same precedence
+#      just-the-docs uses, partitioned by value type so that numeric
+#      and string `nav_order` / `title` values don't compare against
+#      each other:
+#        a. pages with a numeric  `nav_order`, ascending
+#        b. pages with a string   `nav_order`, lexicographic
+#        c. pages with no `nav_order` and a numeric `title`, ascending
+#        d. pages with no `nav_order` and a string  `title`, lexicographic
+#      Case-insensitive ordering (`site.nav_sort == 'case_insensitive'`)
+#      is honoured for the string buckets.
+#   4. Reverse the resulting array when `page.child_nav_order` is
+#      `'desc'` or `'reversed'`, matching the same flip the upstream
+#      `children_nav.html` applies after computing the list.
+#   5. Store the result on `page.data['children_in_nav']` as an
+#      Array of `{ "title" => String, "url" => String,
+#      "summary" => String | nil }` hashes. Plain hashes (not Page
+#      references) are used so Liquid renders without dragging in a
+#      full Page Drop.
+#
+# `_includes/components/children_nav.html` then iterates the array
+# directly. The shadow no longer calls `include_cached
+# components/site_nav.html all=true`, and since the breadcrumbs shadow
+# also stopped using that variant, nothing on the site triggers the
+# `all=true` cache fill. The cached site nav renders exactly once
+# (from `sidebar.html` with `all=nil`).
+#
+# === Output parity ===
+#
+# Children lists are byte-identical to the upstream output when the
+# site does not use the `ancestor:` frontmatter (this project does
+# not; see WIP.md). The `summary` field, when present, is appended
+# in the same form `<a>Title</a> - Summary`.
+#
+# === Compatibility ===
+#
+# Reads `page.data['title']`, `page.data['parent']`,
+# `page.data['grand_parent']`, `page.data['nav_order']`,
+# `page.data['summary']`, `page.data['child_nav_order']`, plus
+# `page.url`. Honours `site.config['nav_sort']` for case sensitivity.
+# Skips pages without a `title`, matching the just-the-docs nav-
+# inclusion rule.
+#
+# If the plugin is removed, the shadow children_nav.html iterates a
+# nil array and emits nothing -- pages lose their auto-generated TOC
+# but the build is otherwise intact.
+
+module ChildrenPrecompute
+  class Generator < Jekyll::Generator
+    safe true
+    priority :normal
+
+    REVERSE_FLAGS = %w[desc reversed].freeze
+
+    def generate(site)
+      # `site.html_pages` is a Liquid-drop accessor; from Ruby we
+      # filter `site.pages` directly.
+      titled = site.pages.select { |p| p.data["title"] }
+      by_parent_title = titled.group_by { |p| (p.data["parent"] || "").to_s }
+      case_insensitive = site.config["nav_sort"] == "case_insensitive"
+
+      titled.each do |page|
+        children = children_for(page, by_parent_title)
+        children = sort_children(children, case_insensitive)
+        children = children.reverse if REVERSE_FLAGS.include?(page.data["child_nav_order"].to_s)
+        page.data["children_in_nav"] = children.map do |c|
+          {
+            "title" => c.data["title"],
+            "url" => c.url,
+            "summary" => c.data["summary"],
+          }
+        end
+      end
+    end
+
+    private
+
+    def children_for(page, by_parent_title)
+      (by_parent_title[page.data["title"]] || []).select do |child|
+        # When a child declares `grand_parent`, it must match the
+        # parent page's own `parent` -- the same disambiguation the
+        # upstream `components/nav/children.html` applies. When the
+        # child omits `grand_parent`, no constraint applies.
+        gp = child.data["grand_parent"]
+        gp.nil? || gp == page.data["parent"]
+      end
+    end
+
+    # Mirrors the just-the-docs `_includes/components/nav/sorted.html`
+    # precedence: number/string partitions for each of `nav_order` and
+    # `title`, concatenated in that order.
+    def sort_children(pages, case_insensitive)
+      nav_num, nav_str, title_num, title_str = [], [], [], []
+
+      pages.each do |p|
+        if p.data["nav_order"]
+          (numeric?(p.data["nav_order"]) ? nav_num : nav_str) << p
+        else
+          (numeric?(p.data["title"]) ? title_num : title_str) << p
+        end
+      end
+
+      nav_num.sort_by!   { |p| p.data["nav_order"] }
+      nav_str.sort_by!   { |p| sort_key(p.data["nav_order"], case_insensitive) }
+      title_num.sort_by! { |p| p.data["title"] }
+      title_str.sort_by! { |p| sort_key(p.data["title"], case_insensitive) }
+
+      nav_num + nav_str + title_num + title_str
+    end
+
+    def numeric?(value)
+      value.is_a?(Numeric)
+    end
+
+    def sort_key(value, case_insensitive)
+      s = value.to_s
+      case_insensitive ? s.downcase : s
+    end
+  end
+end
diff --git a/docs/_plugins/jekyll-gfm-admonitions-patch.rb b/docs/_plugins/jekyll-gfm-admonitions-patch.rb
new file mode 100644
index 00000000..d4a7a168
--- /dev/null
+++ b/docs/_plugins/jekyll-gfm-admonitions-patch.rb
@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# Patch for jekyll-gfm-admonitions (>=1.2.0): suppress the per-page <style>
+# injection performed by the gem's :site, :post_render hook, while
+# preserving the gem's own "Converted admonitions in N file(s)." log
+# message so the build output still reports an honest count.
+#
+# The gem's default behaviour minifies its bundled `assets/admonitions.css`
+# and inlines it into the <head> of every page that contains an admonition,
+# duplicating ~1.5 KB across hundreds of rendered files. We instead bundle
+# the rules once into the site stylesheet via `_sass/custom/admonitions.scss`,
+# which the browser caches like any other static asset.
+#
+# === How the gem works (relevant bits) ===
+#
+# `JekyllGFMAdmonitions::GFMAdmonitionConverter` is a `Jekyll::Generator` with
+# `priority :lowest`, so it runs after all earlier generators have populated
+# the site model. Its `#generate` walks every collection document and every
+# page through `#process_doc_content`, which:
+#
+#   1. Snapshots the original markdown source (`original_content`).
+#   2. Calls `#process_doc`, which rewrites `> [!NOTE]` (and the other four
+#      GFM admonition keywords) into `<div class='markdown-alert ...'>` HTML
+#      via a regex substitution on `doc.content`. Octicons SVGs are inlined
+#      for the title icons. Code blocks are temporarily stashed out so
+#      admonitions inside fenced code are left alone.
+#   3. If `doc.content` actually changed, appends `doc` to a class-level
+#      array `GFMAdmonitionConverter.admonition_pages`.
+#
+# At the end of `#generate`, the gem logs:
+#
+#   "GFMA: Converted admonitions in #{admonition_pages.length} file(s)."
+#
+# Separately, the gem registers a `Jekyll::Hooks.register :site, :post_render`
+# block at module load time. After Jekyll has rendered the layouts to HTML,
+# that hook reads `admonition_pages.length` for its own log line, then
+# iterates the array, reads `assets/admonitions.css` from the gem's
+# installation directory, minifies it with `CSSminify.compress`, and
+# substitutes each page's `<head>...</head>` block to inject a
+# `<style>...minified css...</style>` element just before `</head>`. The gem
+# author's stated reason (in a code comment) is that GitHub Pages's Jekyll
+# sanitiser strips theme CSS additions, so inlining is their workaround --
+# but we build locally and deploy the rendered `_site/` to a static host, so
+# the sanitiser never runs and the workaround is pure overhead.
+#
+# === What this patch does ===
+#
+# The `:post_render` hook is registered unconditionally at gem load and
+# there is no public API to deregister it. We instead let the gem populate
+# `admonition_pages` normally during the GENERATE phase -- so the count log
+# at the end of `#generate` reflects the real number of pages with
+# admonitions -- and clear the array between the generator and the renderer
+# so the post-render hook iterates an empty list and injects nothing.
+#
+# The clear is performed in a `Jekyll::Hooks.register :site, :pre_render`
+# block. In the Jekyll site lifecycle, `:site, :pre_render` fires after
+# every generator has finished but before any page is rendered (see
+# `Jekyll::Site#render` in `lib/jekyll/site.rb`), which is exactly the gap
+# we need: the gem's generator-end log message has already been written
+# with the correct count, the gem's post-render hook has not yet run, and
+# our clear empties the list so the post-render iteration becomes a no-op.
+#
+# Net effect:
+#
+#   * Markdown -> HTML rewriting is untouched: every `> [!NOTE]` etc.
+#     becomes the same `<div class='markdown-alert markdown-alert-<type>'>`
+#     element the unpatched gem would produce.
+#   * The end-of-generate log line reads
+#     `"GFMA: Converted admonitions in N file(s)."` with the real count.
+#   * `admonition_pages` is cleared before render starts, so the gem's
+#     :post_render hook iterates zero pages and no `<style>` element is
+#     spliced into any page's `<head>`.
+#   * The post-render log line reads
+#     `"GFMA: Inserting admonition CSS in 0 page(s)."`. This is honest --
+#     we are no longer in that business -- though it is admittedly an
+#     odd thing to see in the build output. The line could be suppressed
+#     only by deregistering or replacing the gem's `:post_render` block,
+#     and Jekyll exposes no hook-deregistration API; we accept the
+#     cosmetic line rather than reach into Jekyll's hook registry.
+#   * The admonition CSS rules still apply at render time, because they
+#     are compiled into `assets/css/just-the-docs-combined.css` via the
+#     `@import "admonitions";` line in `_sass/custom/custom.scss`. That
+#     stylesheet is already linked by every page through the theme's
+#     `head.html`, so visual output is unchanged.
+#
+# === Compatibility ===
+#
+# This patch targets the exact gem version pinned by `Gemfile.lock` (1.2.0).
+# If the gem is upgraded, re-verify that
+#
+#   - `GFMAdmonitionConverter.admonition_pages` is still the class-level
+#     accumulator the generator pushes into and the post-render hook
+#     iterates, and
+#   - the post-render hook's only side effect is the per-page CSS
+#     injection driven by that accumulator (otherwise clearing it may
+#     not be enough).
+#
+# If a future release exposes an opt-out for the inlining (e.g. via
+# `site.config`), prefer that to this monkey-patch and delete this file.
+
+require "jekyll-gfm-admonitions"
+
+Jekyll::Hooks.register :site, :pre_render do
+  # Empties the accumulator the gem's :post_render hook would otherwise
+  # iterate over. The gem's earlier `Jekyll.logger.info` call at the end
+  # of `#generate` has already reported the real count by the time this
+  # hook fires.
+  JekyllGFMAdmonitions::GFMAdmonitionConverter.admonition_pages.clear
+end
+
+# Wrap `#generate` to report how long the gem's GENERATE-phase work takes.
+# `--profile` only attributes time to Liquid templates and converters, so
+# generators (this one included) are invisible to it. The wall-clock delta
+# we log here is the gem's full contribution to the GENERATE phase:
+# walking every collection doc and page, running the admonition regex,
+# and re-invoking the markdown converter on each admonition body.
+module JekyllGFMAdmonitions
+  class GFMAdmonitionConverter
+    unless method_defined?(:_generate_without_timing)
+      alias_method :_generate_without_timing, :generate
+      def generate(site)
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        _generate_without_timing(site)
+        elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(0)
+        Jekyll.logger.info "GFMA:", "Generator ran in #{elapsed_ms}ms."
+      end
+    end
+  end
+end
diff --git a/docs/_plugins/jekyll-relative-links-patch.rb b/docs/_plugins/jekyll-relative-links-patch.rb
new file mode 100644
index 00000000..c2ec00f1
--- /dev/null
+++ b/docs/_plugins/jekyll-relative-links-patch.rb
@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# Patch for jekyll-relative-links (>=0.7.0): replace the O(N) linear
+# scan in `url_for_path` with an O(1) hash lookup.
+#
+# === The bug ===
+#
+# `JekyllRelativeLinks::Generator#url_for_path` is invoked once for
+# every markdown link match (both inline `[X](Y)` and reference-style
+# `[X]: Y`) in every markdown document the gem processes. The unpatched
+# implementation is:
+#
+#     def url_for_path(path)
+#       path = CGI.unescape(path)
+#       target = potential_targets.find { |p| p.relative_path.sub(%r!\A/!, "") == path }
+#       relative_url(target.url) if target&.url
+#     end
+#
+#     def potential_targets
+#       @potential_targets ||= site.pages + site.static_files + site.docs_to_write
+#     end
+#
+# `potential_targets` is memoised (good), but the lookup against it is
+# a linear scan with a `.find` that calls `.sub` on every entry's
+# `relative_path` on every call (bad). For M link matches across the
+# site and N potential targets, total link-resolution cost is O(M*N).
+# On this site M*N ~= 7M (~6800 markdown link matches, ~1050 targets),
+# and the unpatched gem spends ~3.4s of the GENERATE phase here -- the
+# bulk of GENERATE on a build that otherwise takes ~600ms in that
+# phase.
+#
+# === The fix ===
+#
+# Build a hash from `relative_path` (with the leading slash stripped,
+# to match the unpatched comparison) to the target object once, and
+# look up by key thereafter. Hash construction is O(N) once; each
+# subsequent lookup is O(1). Total cost drops from O(M*N) to O(M+N),
+# and the GENERATE phase shrinks accordingly.
+#
+# The hash is built with first-wins semantics (`unless h.key?(key)`)
+# to match the unpatched `.find`, which returns the first matching
+# target. In practice `relative_path` is unique across pages, static
+# files, and docs, so this only matters as defence against an
+# unexpected duplicate -- but matching the upstream behaviour exactly
+# keeps the patch a safe drop-in.
+#
+# === Compatibility ===
+#
+# Targets the upstream gem version pinned by Gemfile.lock (0.7.0). The
+# patch overrides only `url_for_path` and adds one new memoiser
+# (`potential_targets_by_path`); every other method is untouched. The
+# `unless method_defined?` guard makes the patch idempotent against
+# accidental double-load.
+#
+# If a future release rewrites `url_for_path`, re-verify that the
+# replacement still resolves a path to a target by scanning
+# `potential_targets` (or an equivalent) and that swapping in a hash
+# lookup remains a faithful drop-in. If the upstream project takes a
+# PR for this, delete this file.
+
+require "jekyll-relative-links"
+
+module JekyllRelativeLinks
+  class Generator
+    unless method_defined?(:potential_targets_by_path)
+      def potential_targets_by_path
+        @potential_targets_by_path ||= potential_targets.each_with_object({}) do |p, h|
+          key = p.relative_path.sub(%r!\A/!, "")
+          h[key] = p unless h.key?(key)
+        end
+      end
+
+      def url_for_path(path)
+        path = CGI.unescape(path)
+        target = potential_targets_by_path[path]
+        relative_url(target.url) if target&.url
+      end
+    end
+  end
+end
diff --git a/docs/_plugins/nav-levels-precompute.rb b/docs/_plugins/nav-levels-precompute.rb
new file mode 100644
index 00000000..8e9e36da
--- /dev/null
+++ b/docs/_plugins/nav-levels-precompute.rb
@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+# Precomputes per-page nav-level coordinates for the just-the-docs
+# activation stylesheet (the inline `<style id="jtd-nav-activation">`
+# block that `_includes/head.html` emits via
+# `_includes/css/activation.scss.liquid`).
+#
+# === Problem ===
+#
+# The upstream activation include determines the current page's
+# position within the nav tree by capturing the cached `site_nav` HTML
+# (~150 KB) and walking it character by character: splitting it at the
+# page's `<a>` tag, then splitting the prefix at every
+# `<li class="nav-list-item"` boundary and counting `<ul>` / `</ul>`
+# occurrences in each fragment to recover an `[i, j, k, ...]` positional
+# path. From that path it emits `:nth-child(i) > li:nth-child(j) > ...`
+# selectors so the page's nav entry can be bolded, its ancestors
+# unfolded, and their expander icons rotated when JavaScript is
+# disabled. Across the ~830-page site the per-page string scanning
+# costs ~11 s -- ~40% of the entire RENDER phase.
+#
+# The positional path is fully derivable from frontmatter: each page's
+# place in the nav is determined by its parent / grand_parent chain
+# plus the nav_order / title sort rules. Moving the computation to
+# Ruby brings per-page render cost essentially to zero, and the
+# activation include becomes pure templating against precomputed data.
+#
+# === Approach ===
+#
+# Produce the same `nav_levels` array the upstream Liquid algorithm
+# would, and stash it on `page.data['nav_levels']` for the shadow
+# `_includes/css/activation.scss.liquid` to consume. The output CSS is
+# byte-identical to the upstream version after HTML compression.
+#
+# The array has the same shape as in the upstream:
+#
+#   nav_levels[0]   = collection-prefix index (always 1 on this site,
+#                     which has no `just_the_docs.collections`; the
+#                     activation prefix is `.site-nav > ul.nav-list:
+#                     first-child`).
+#   nav_levels[i]   = 1-based position of the i-th ancestor in its
+#                     parent's sorted, nav-filtered children list, for
+#                     i in 1..page_level.
+#   nav_levels.size = page_level + 1.
+#
+# === Why a top-down tree walk ===
+#
+# Walking the parent chain bottom-up (page -> parent -> grand_parent
+# -> ...) is the obvious approach, and works for most pages. It
+# breaks down when a page's `parent` title is not unique on the site
+# AND the page does not declare a `grand_parent` to disambiguate.
+#
+# Example: this site has two pages titled "Constants Module" -- one
+# under `VBA Package`, one under `VBRUN Package`. The VBA constants
+# (e.g. `VbAppWinStyle`) declare only `parent: Constants Module`. The
+# VBRUN constants additionally declare `grand_parent: VBRUN Package`,
+# disambiguating themselves. So a bottom-up walk from `VbAppWinStyle`
+# arrives at "Constants Module" with no way to choose between the two
+# pages -- pick by enumeration order and the indices come out
+# attributed to the wrong parent.
+#
+# Crucially, the upstream nav rendering keeps the same ambiguity in
+# its output: because the children filter in
+# `_includes/components/nav/children.html` only rejects a child whose
+# `grand_parent` is set AND mismatches, a child without `grand_parent`
+# is attributed to every same-title parent it could be attached to.
+# `VbAppWinStyle` therefore appears twice in the rendered nav: once
+# under VBA's Constants Module and once under VBRUN's. The upstream
+# `activation.scss.liquid` uses the page's first `<a>` occurrence in
+# the rendered HTML to anchor its path, which is whichever copy comes
+# first in render order.
+#
+# Mirroring "first occurrence in render order" deterministically
+# without rendering the nav requires walking the tree top-down in
+# render order and recording each page's chain the first time we
+# reach it. Subsequent visits to the same page (under a different
+# parent) leave the recorded chain untouched, just as the upstream's
+# split-at-first-occurrence does.
+#
+# === Algorithm ===
+#
+#   1. Collect every page with a `title`. Group by `parent` to obtain
+#      a parent-title -> children map. (Pages without a `title` cannot
+#      appear in the nav and are ignored throughout.)
+#   2. Build the sorted top-level page list: filter the parent=="" /
+#      parent==nil bucket to those without `nav_exclude`, sort with
+#      the same precedence the upstream `_includes/components/nav/
+#      sorted.html` applies (numeric nav_order, string nav_order,
+#      numeric title, string title), honouring
+#      `site.config['nav_sort']` for case sensitivity.
+#   3. Memoise `ordered_children_for(parent)` for every titled page:
+#      the children with `parent == parent.title`, filtered to those
+#      that are not `nav_exclude`d and whose `grand_parent` either is
+#      unset or matches `parent.parent` (the same disambiguation the
+#      upstream's `components/nav/children.html` performs). Sort the
+#      survivors and reverse them when `parent.child_nav_order` is
+#      `desc` / `reversed` -- the same flip the upstream's
+#      `components/nav/links.html` applies before rendering, so our
+#      child indices match the rendered positions.
+#   4. Walk the tree top-down in sorted order, threading the chain of
+#      ancestors visited so far. The first time a page is reached, its
+#      chain is recorded. The walk is bounded by MAX_DEPTH and skips
+#      any child already present in the current chain (cycle defence).
+#   5. For every titled page with a recorded chain, derive `nav_levels`
+#      by reading positions back from each step's memoised
+#      `ordered_children_for(...)`. Cache child-url -> index maps to
+#      keep the per-page lookup O(1).
+#
+# === Special cases ===
+#
+# A page is "not in the nav" -- and so gets no `nav_levels` -- if any
+# of the following are true:
+#
+#   - It has no `title`.
+#   - It has `nav_exclude: true`.
+#   - Its `parent` chain never reaches a top-level page (e.g. a
+#     reference to a non-existent parent title, or a chain that runs
+#     past MAX_DEPTH without grounding out).
+#   - It is filtered out by `grand_parent` disambiguation everywhere
+#     it could attach.
+#
+# When `nav_levels` is nil, the activation shadow falls through to the
+# upstream's `activation_no_nav_link` rules: a single
+# `.site-nav ul li a { background-image: none; }` rule, plus the
+# collection unfold/rotate rules when `site.just_the_docs.collections`
+# is set (it is not on this site).
+#
+# === Compatibility ===
+#
+# Reads `page.data['title']`, `page.data['parent']`,
+# `page.data['grand_parent']`, `page.data['nav_order']`,
+# `page.data['child_nav_order']`, `page.data['nav_exclude']`, plus
+# `page.url`. Honours `site.config['nav_sort']` for case sensitivity.
+# Writes only `page.data['nav_levels']`. If the plugin is removed,
+# `_includes/css/activation.scss.liquid` should be reverted to either
+# the upstream version (which recomputes the path per page) or any
+# other implementation that does not depend on `page.nav_levels`.
+#
+# MAX_DEPTH is set to 16: the deepest chain on the site today is 5
+# levels (Reference Section -> Packages -> VBA Package -> Strings
+# Module -> Len). The generous bound guarantees termination even if a
+# future authoring mistake creates a cycle in the `parent` chain.
+
+module NavLevelsPrecompute
+  MAX_DEPTH = 16
+  REVERSE_FLAGS = %w[desc reversed].freeze
+
+  class Generator < Jekyll::Generator
+    safe true
+    priority :normal
+
+    def generate(site)
+      titled = site.pages.select { |p| p.data["title"] }
+      by_parent_title = titled.group_by { |p| (p.data["parent"] || "").to_s }
+      case_insensitive = site.config["nav_sort"] == "case_insensitive"
+
+      # Sorted, nav-filtered top-level pages.
+      top_level = (by_parent_title[""] || []).reject { |p| p.data["nav_exclude"] }
+      top_level = sort_pages(top_level, case_insensitive)
+      top_index = top_level.each_with_index.map { |p, i| [p.url, i + 1] }.to_h
+
+      # Memoised ordered children for every titled page.
+      ordered_children = {}
+      titled.each do |parent|
+        ordered_children[parent.url] = ordered_children_for(parent, by_parent_title, case_insensitive)
+      end
+
+      # Child-url -> 1-based index per parent, for O(1) position lookup.
+      child_index = ordered_children.transform_values do |list|
+        list.each_with_index.map { |c, i| [c.url, i + 1] }.to_h
+      end
+
+      # Top-down nav walk: record each page's first-encountered chain.
+      paths = {}
+      top_level.each do |top|
+        walk_subtree(top, [top], paths, ordered_children, 0)
+      end
+
+      # Read back nav_levels for every page that has a recorded chain.
+      titled.each do |page|
+        page.data["nav_levels"] = levels_from_path(paths[page.url], top_index, child_index)
+      end
+    end
+
+    private
+
+    # Walks the nav subtree rooted at `node`, threading `chain` (the
+    # list of ancestors visited so far, root-first) and recording each
+    # page's chain the first time it is reached.
+    def walk_subtree(node, chain, paths, ordered_children, depth)
+      return if depth > MAX_DEPTH
+
+      paths[node.url] ||= chain
+
+      (ordered_children[node.url] || []).each do |child|
+        # Cycle defence: don't descend into a page already in the
+        # current chain. The first-occurrence rule still applies to
+        # the wider tree -- another branch may have already recorded
+        # this page's chain.
+        next if chain.any? { |p| p.url == child.url }
+        walk_subtree(child, chain + [child], paths, ordered_children, depth + 1)
+      end
+    end
+
+    # Returns the sorted, nav-filtered children of `parent` per the
+    # upstream's `components/nav/children.html` logic, with the
+    # `child_nav_order` reversal `components/nav/links.html` applies
+    # before rendering.
+    def ordered_children_for(parent, by_parent_title, case_insensitive)
+      children = (by_parent_title[parent.data["title"]] || []).select do |c|
+        next false if c.data["nav_exclude"]
+        gp = c.data["grand_parent"]
+        gp.nil? || gp == parent.data["parent"]
+      end
+      children = sort_pages(children, case_insensitive)
+      children = children.reverse if REVERSE_FLAGS.include?(parent.data["child_nav_order"].to_s)
+      children
+    end
+
+    # Derives `nav_levels` from a recorded chain `[top, ..., page]`.
+    # Each entry's position is read from the precomputed maps so the
+    # per-page cost is O(chain length).
+    def levels_from_path(chain, top_index, child_index)
+      return nil unless chain
+
+      top_idx = top_index[chain.first.url]
+      return nil unless top_idx
+
+      levels = [1, top_idx]
+      (1...chain.length).each do |i|
+        idx = child_index.dig(chain[i - 1].url, chain[i].url)
+        return nil unless idx
+        levels << idx
+      end
+      levels
+    end
+
+    # Mirrors the just-the-docs `_includes/components/nav/sorted.html`
+    # precedence: four buckets ordered as nav_order(num), nav_order(str),
+    # title(num), title(str), each sorted independently.
+    def sort_pages(pages, case_insensitive)
+      nav_num, nav_str, title_num, title_str = [], [], [], []
+
+      pages.each do |p|
+        if p.data["nav_order"]
+          (numeric?(p.data["nav_order"]) ? nav_num : nav_str) << p
+        else
+          (numeric?(p.data["title"]) ? title_num : title_str) << p
+        end
+      end
+
+      nav_num.sort_by!   { |p| p.data["nav_order"] }
+      nav_str.sort_by!   { |p| sort_key(p.data["nav_order"], case_insensitive) }
+      title_num.sort_by! { |p| p.data["title"] }
+      title_str.sort_by! { |p| sort_key(p.data["title"], case_insensitive) }
+
+      nav_num + nav_str + title_num + title_str
+    end
+
+    def numeric?(value)
+      value.is_a?(Numeric)
+    end
+
+    def sort_key(value, case_insensitive)
+      s = value.to_s
+      case_insensitive ? s.downcase : s
+    end
+  end
+end
diff --git a/docs/_sass/custom/admonitions.scss b/docs/_sass/custom/admonitions.scss
new file mode 100644
index 00000000..3fbfaae0
--- /dev/null
+++ b/docs/_sass/custom/admonitions.scss
@@ -0,0 +1,75 @@
+// Styles for GitHub-flavored Markdown admonitions emitted by the
+// jekyll-gfm-admonitions gem. Ported from the gem's `assets/admonitions.css`
+// so that the rules are bundled once into the site stylesheet rather than
+// minified and inlined into every page's <head>. The per-page injection is
+// suppressed by `_plugins/jekyll-gfm-admonitions-patch.rb`.
+
+.markdown-alert {
+  padding: 0.5rem 1rem;
+  margin-bottom: 1rem;
+  color: inherit;
+  border-left: 0.25em solid #30363d;
+
+  > :first-child {
+    margin-top: 0;
+  }
+
+  > :last-child {
+    margin-bottom: 0;
+  }
+
+  .markdown-alert-title {
+    display: flex;
+    font-weight: 500;
+    align-items: center;
+    line-height: 1;
+  }
+
+  svg {
+    margin-right: 0.5rem !important;
+  }
+
+  svg path {
+    fill: currentColor;
+  }
+
+  &.markdown-alert-note {
+    border-left-color: #4493f8;
+
+    .markdown-alert-title {
+      color: #4493f8;
+    }
+  }
+
+  &.markdown-alert-important {
+    border-left-color: #ab7df8;
+
+    .markdown-alert-title {
+      color: #ab7df8;
+    }
+  }
+
+  &.markdown-alert-warning {
+    border-left-color: #9e6a03;
+
+    .markdown-alert-title {
+      color: #d29922;
+    }
+  }
+
+  &.markdown-alert-tip {
+    border-left-color: #238636;
+
+    .markdown-alert-title {
+      color: #3fb950;
+    }
+  }
+
+  &.markdown-alert-caution {
+    border-left-color: #da3633;
+
+    .markdown-alert-title {
+      color: #f85149;
+    }
+  }
+}
diff --git a/docs/_sass/custom/custom.scss b/docs/_sass/custom/custom.scss
index 0e77c97e..3a508f9e 100644
--- a/docs/_sass/custom/custom.scss
+++ b/docs/_sass/custom/custom.scss
@@ -1,3 +1,5 @@
+@import "admonitions";
+
 .site-logo {
   padding-right: 3rem;
 }