@openelement/ui 0.41.0-alpha.1

package/src/open-layout.js

@@ -0,0 +1,1377 @@
+/** @jsxImportSource @openelement/core */ /**
+ * @openelement/ui - open-layout
+ *
+ * App layout component with header, sidebar, and footer.
+ * Web Standards Lab: light-first, restrained, documentation-focused.
+ *
+ * v0.20.0: Migrated from DsdLitElement to DsdElement (Ocean component).
+ *   - CSSStyleSheet replaces Lit css``
+ *   - render() returns string
+ *   - @click bindings for mobile menu toggle
+ *   - SPA navigation via Navigation API (navigate/fetch/swap) preserved
+ *   - Event delegation at shadow root level for nav clicks
+ * v0.24.1: Migrated from html`` template to JSX (ADR-0057).
+ *
+ * @csspart container - The app-layout root div
+ * @csspart header - The sticky header element
+ * @csspart sidebar - The docs-sidebar nav
+ * @csspart main - The layout-main element
+ * @csspart footer - The app-footer element
+ * @csspart nav - The header-nav element
+ * @csspart nav-toggle - The mobile menu toggle button
+ *
+ * Usage:
+ * ```html
+ * <open-layout current-path="/guide/getting-started"
+ *   nav-items='[{"section":"Guide","items":[{"path":"/guide/getting-started","label":"Getting Started"}]}]'>
+ * </open-layout>
+ * ```
+ */ import { OpenElement } from '@openelement/element';
+import { StyleSheet } from '@openelement/core/style-sheet';
+import { createContext, provideContext } from '@openelement/core';
+import { escapeAttr, escapeHtml } from '@openelement/core';
+import { createLogger } from '@openelement/core/logger';
+import '.\/open-theme-toggle.js';
+import './open-brand-mark.js';
+export const tagName = 'open-layout';
+const SAFE_URL_SCHEMES = new Set([
+  'http:',
+  'https:',
+  'mailto:',
+  'tel:',
+  'sms:'
+]);
+const log = createLogger('ui');
+function isSafeLayoutUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return false;
+  if (trimmed.startsWith('//')) return false;
+  if (trimmed.startsWith('/') || trimmed.startsWith('#') || trimmed.startsWith('./') || trimmed.startsWith('../')) {
+    return true;
+  }
+  try {
+    const parsed = new URL(trimmed, 'https://openelement.org/');
+    return SAFE_URL_SCHEMES.has(parsed.protocol);
+  } catch  {
+    return false;
+  }
+}
+/* --- Locale/path helpers (inlined from @openelement/router) --- */ const LOCALE_LABELS = {
+  en: '中文',
+  zh: 'English'
+};
+function parsePathWithoutLocale(pathname, locales) {
+  const segs = pathname.split('/').filter(Boolean);
+  if (segs.length > 0 && locales.includes(segs[0])) {
+    return '/' + segs.slice(1).join('/') || '/';
+  }
+  return pathname || '/';
+}
+function detectLocale(pathname, locales, defaultLocale) {
+  const segs = pathname.split('/').filter(Boolean);
+  if (segs.length > 0 && locales.includes(segs[0])) return segs[0];
+  return defaultLocale;
+}
+function localizePath(path1, locale) {
+  if (isSafeLayoutUrl(path1) && /^https?:/i.test(path1)) return path1;
+  return `/${locale}${path1}`;
+}
+function switchPath(currentPath, currentLocale, locales) {
+  const other = locales.find((l)=>l !== currentLocale) || currentLocale;
+  return `/${other}${currentPath}`;
+}
+function switchLabel(currentLocale) {
+  return LOCALE_LABELS[currentLocale] || currentLocale;
+}
+/** SignalContext key: theme state shared across all components */ export const THEME_CTX = createContext(Symbol('theme'), 'light');
+const sheet = new StyleSheet();
+sheet.replaceSync(`
+  :host {
+    display: block;
+  }
+
+  * { font-family: var(--font-sans); }
+
+  .app-layout {
+    display: flex;
+    flex-direction: column;
+    min-height: 100vh;
+    background: var(--bg-base);
+    color: var(--text-primary);
+    font-family: var(--font-sans);
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+
+  .layout-body {
+    display: flex;
+    flex: 1;
+    max-width: 1400px;
+    margin: 0 auto;
+    width: 100%;
+  }
+
+  .layout-main {
+    flex: 1;
+    min-width: 0;
+    width: 100%;
+  }
+
+  .app-layout[home] .layout-body,
+  .app-layout[full-width] .layout-body {
+    display: flex;
+    flex-direction: column;
+    max-width: none;
+  }
+
+  .app-layout[home] .layout-main,
+  .app-layout[full-width] .layout-main {
+    flex: 1;
+  }
+
+  /* Header */
+  .app-header {
+    position: sticky;
+    top: 0;
+    z-index: 100;
+    background: var(--nav-bg);
+    border-bottom: var(--border-size-1) solid var(--border);
+    backdrop-filter: blur(18px) saturate(150%);
+    -webkit-backdrop-filter: blur(18px) saturate(150%);
+    transition: background 0.2s ease, border-color 0.2s ease, box-shadow 0.2s ease;
+  }
+  .app-header.scrolled {
+    background: color-mix(in srgb, var(--bg-base) 88%, transparent);
+    border-bottom-color: var(--border-hover);
+    box-shadow: 0 var(--size-2) var(--size-10) color-mix(in srgb, var(--brand) 5%, transparent);
+  }
+
+  .header-inner {
+    max-width: none;
+    margin: 0 auto;
+    padding: 0 clamp(var(--size-5), 3.5vw, var(--size-9));
+    display: flex;
+    align-items: center;
+    min-height: var(--nav-height);
+    gap: var(--size-6);
+  }
+
+  .mobile-tab-bar { display: none; }
+
+  .mobile-menu-btn {
+    display: none;
+    align-items: center;
+    justify-content: center;
+    width: var(--size-10);
+    height: var(--size-10);
+    border: var(--border-size-1) solid var(--border);
+    border-radius: var(--radius-round);
+    background: color-mix(in srgb, var(--bg-elevated) 74%, transparent);
+    color: var(--text-secondary);
+    cursor: pointer;
+    padding: 0;
+    transition: all 0.15s ease;
+  }
+  .mobile-menu-btn:hover {
+    color: var(--text-primary);
+    border-color: var(--border-hover);
+    background: var(--bg-hover);
+  }
+
+  .logo {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--size-3);
+    font-size: var(--font-size-3);
+    font-weight: var(--font-weight-8);
+    color: var(--text-primary);
+    text-decoration: none;
+    letter-spacing: 0;
+    white-space: nowrap;
+  }
+
+  .logo:hover open-brand-mark {
+    transform: translateY(calc(var(--border-size-1) * -1));
+  }
+
+  open-brand-mark {
+    transition: transform var(--duration-2) var(--ease-2);
+  }
+
+  .logo-word {
+    display: inline-block;
+    transform: translateY(calc(var(--border-size-1) * -1));
+  }
+
+  .logo-sub {
+    font-size: var(--font-size-00);
+    color: var(--text-muted);
+    margin-left: var(--size-2);
+    font-family: var(--font-mono);
+    font-weight: var(--font-weight-8);
+    text-transform: uppercase;
+  }
+
+  .header-nav {
+    display: flex;
+    gap: clamp(var(--size-5), 3vw, var(--size-8));
+    flex: 1;
+    justify-content: center;
+  }
+  .header-nav a {
+    color: var(--nav-link-color);
+    text-decoration: none;
+    font-size: var(--font-size-1);
+    font-weight: var(--font-weight-5);
+    padding: var(--size-2) 0;
+    transition: color 0.15s ease, background 0.15s ease;
+  }
+  .header-nav a:hover {
+    color: var(--nav-link-hover);
+  }
+  .header-nav a[aria-current="page"] {
+    color: var(--brand-deep);
+    font-weight: var(--font-weight-8);
+  }
+
+  .header-right {
+    display: flex;
+    align-items: center;
+    gap: var(--size-1);
+    margin-left: auto;
+  }
+
+  /* CTA buttons */
+  .btn-secondary {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--size-2);
+    color: var(--text-primary);
+    text-decoration: none;
+    font-size: var(--font-size-button);
+    font-weight: var(--font-weight-semibold);
+    padding: var(--size-2) var(--size-4);
+    border: var(--border-size-1) solid color-mix(in srgb, var(--border) 72%, var(--brand));
+    border-radius: var(--radius-round);
+    background: color-mix(in srgb, var(--bg-elevated) 76%, transparent);
+    box-shadow: inset 0 1px 0 color-mix(in srgb, var(--gray-0) 70%, transparent);
+    transition: all 0.15s ease;
+  }
+  .btn-secondary:hover {
+    color: var(--brand-deep);
+    border-color: var(--brand-light);
+    background: color-mix(in srgb, var(--brand-pale) 42%, var(--bg-elevated));
+  }
+  .btn-secondary svg { flex-shrink: 0; }
+
+  .btn-primary {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    color: var(--on-brand);
+    text-decoration: none;
+    font-size: var(--font-size-button);
+    font-weight: var(--font-weight-semibold);
+    padding: var(--size-2) var(--size-4);
+    border: var(--border-size-1) solid transparent;
+    border-radius: var(--radius-round);
+    background: linear-gradient(135deg, var(--brand), var(--brand-light));
+    box-shadow: 0 var(--size-2) var(--size-5) var(--brand-glow);
+    white-space: nowrap;
+    transition: all 0.15s ease;
+  }
+  .btn-primary:hover {
+    background: linear-gradient(135deg, var(--brand-hover), var(--brand-light));
+    transform: translateY(calc(var(--border-size-1) * -1));
+  }
+
+  .header-right .btn-secondary,
+  .header-right .btn-primary {
+    display: none;
+  }
+
+  .lang-switch {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-width: var(--size-9);
+    width: var(--size-9);
+    height: var(--size-9);
+    padding: 0;
+    font-size: var(--font-size-button);
+    font-weight: var(--font-weight-semibold);
+    color: var(--text-secondary);
+    border: 0;
+    border-radius: var(--radius-round);
+    background: transparent;
+    cursor: pointer;
+    text-decoration: none;
+    transition: all 0.15s ease;
+  }
+  .lang-switch:hover {
+    color: var(--brand-deep);
+    border-color: transparent;
+    background: color-mix(in srgb, var(--brand-pale) 34%, transparent);
+  }
+
+  /* Sidebar */
+  .docs-sidebar {
+    width: clamp(200px, 20vw, 260px);
+    flex-shrink: 0;
+    border-right: var(--border-size-1) solid var(--border);
+    padding: 2rem 0;
+    overflow-y: auto;
+    height: calc(100vh - var(--nav-height));
+    position: sticky;
+    top: var(--nav-height);
+    scrollbar-width: thin;
+    background: color-mix(in srgb, var(--bg-elevated) 42%, transparent);
+  }
+  :host([home]) .docs-sidebar,
+  :host([full-width]) .docs-sidebar {
+    width: 0; min-width: 0; padding: 0;
+    overflow: hidden; border-right: none;
+  }
+
+  .nav-section { margin-bottom: 1.5rem; }
+  .nav-section summary {
+    font-size: 0.625rem;
+    font-weight: 800;
+    text-transform: uppercase;
+    letter-spacing: 0.22em;
+    color: var(--text-muted);
+    padding: 0 1.5rem;
+    margin-bottom: 0.5rem;
+    cursor: pointer;
+    list-style: none;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    user-select: none;
+  }
+  .nav-section summary::-webkit-details-marker { display: none; }
+  .nav-section summary::marker { content: ""; }
+  .nav-section summary:hover { color: var(--text-secondary); }
+
+  .docs-sidebar a {
+    display: block;
+    color: var(--text-muted);
+    text-decoration: none;
+    font-size: 0.85rem;
+    padding: 0.35rem 1.5rem;
+    border-left: 2px solid transparent;
+    transition: color 0.15s ease, border-color 0.15s ease, background 0.15s ease;
+  }
+  .docs-sidebar a:hover {
+    color: var(--text-secondary);
+    background: var(--bg-hover);
+  }
+  .docs-sidebar a.active,
+  .docs-sidebar a[aria-current="page"] {
+    color: var(--brand);
+    border-left-color: var(--brand);
+    background: var(--brand-subtle);
+    font-weight: 600;
+  }
+
+  /* Footer */
+  .app-footer {
+    border-top: var(--border-size-1) solid var(--border);
+    background: color-mix(in srgb, var(--bg-elevated) 58%, transparent);
+  }
+  .footer-inner {
+    max-width: 1240px;
+    margin: 0 auto;
+    padding: var(--size-16) var(--size-8);
+    display: grid;
+    grid-template-columns: repeat(4, 1fr);
+    gap: var(--size-8);
+  }
+  .footer-column h4 {
+    font-size: var(--font-size-button);
+    font-weight: var(--font-weight-semibold);
+    color: var(--text-primary);
+    margin: 0 0 var(--size-4);
+  }
+  .footer-column a {
+    display: block;
+    color: var(--text-secondary);
+    text-decoration: none;
+    font-size: var(--font-size-body-sm);
+    padding: 4px 0;
+    transition: color 0.15s ease;
+  }
+  .footer-column a:hover {
+    color: var(--text-primary);
+  }
+  .footer-bottom {
+    border-top: var(--border-size-1) solid var(--border);
+    padding: var(--size-4) var(--size-8);
+    max-width: 1240px;
+    margin: 0 auto;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    color: var(--text-muted);
+    font-size: var(--font-size-body-sm);
+  }
+  .footer-bottom a {
+    color: var(--text-secondary);
+    text-decoration: none;
+    transition: color 0.15s ease;
+  }
+  .footer-bottom a:hover {
+    color: var(--text-primary);
+  }
+
+  /* Mobile backdrop */
+  .mobile-backdrop {
+    position: fixed; inset: 0; top: var(--nav-height);
+    background: var(--overlay);
+    z-index: 80; opacity: 0; pointer-events: none;
+    transition: opacity 0.3s ease;
+  }
+
+  /* Responsive */
+  @media (max-width: 1120px) {
+    .header-inner {
+      gap: var(--size-3);
+      padding-inline: var(--size-4);
+    }
+
+    .header-nav {
+      gap: var(--size-3);
+    }
+
+    .btn-secondary .btn-text { display: none; }
+  }
+
+  @media (max-width: 900px) {
+    .mobile-menu-btn { display: flex; }
+    .header-inner { padding: 0 var(--size-4); gap: var(--size-2); }
+    .header-nav { display: none; }
+    .btn-secondary .btn-text { display: none; }
+    .header-right { gap: 4px; }
+
+    .docs-sidebar {
+      position: fixed; top: var(--nav-height); left: 0;
+      width: min(280px, 80vw);
+      height: calc(100vh - var(--nav-height)); z-index: 90;
+      background: var(--bg-elevated);
+      border-right: var(--border-size-1) solid var(--border);
+      padding: 1rem 0; overflow-y: auto;
+      transform: translateX(-101%);
+      transition: transform 0.25s cubic-bezier(0.4,0,0.2,1);
+      will-change: transform;
+    }
+    :host([menu-open]) .docs-sidebar {
+      transform: translateX(0);
+      box-shadow: var(--shadow-1);
+    }
+    :host([menu-open]) .mobile-backdrop { opacity: 1; pointer-events: auto; }
+    .nav-section { margin-bottom: 0.5rem; }
+    .nav-section summary { padding: var(--size-2) var(--size-4); }
+    .docs-sidebar a { padding: 0.5rem 1rem 0.5rem 2rem; }
+    .layout-main { width: 100%; }
+    .app-footer { padding: 0; }
+    .footer-inner {
+      grid-template-columns: repeat(2, 1fr);
+      padding: var(--size-12) var(--size-4);
+      padding-bottom: calc(var(--size-12) + var(--size-16));
+    }
+    .footer-bottom {
+      flex-direction: column;
+      gap: var(--size-2);
+      padding: var(--size-4);
+      padding-bottom: calc(var(--size-4) + var(--size-16));
+      text-align: center;
+    }
+
+    .mobile-tab-bar {
+      display: flex; position: fixed; bottom: 0; left: 0; right: 0;
+      height: 56px; z-index: 100;
+      background: var(--nav-bg);
+      backdrop-filter: blur(12px) saturate(180%);
+      -webkit-backdrop-filter: blur(12px) saturate(180%);
+      border-top: var(--border-size-1) solid var(--border);
+      padding: 0 env(safe-area-inset-right) 0 env(safe-area-inset-left);
+      padding-bottom: env(safe-area-inset-bottom);
+    }
+    .tab-item {
+      flex: 1; display: flex; flex-direction: column;
+      align-items: center; justify-content: center; gap: 2px;
+      color: var(--text-muted);
+      text-decoration: none; font-size: 10px; font-weight: 600;
+      transition: color 0.15s ease;
+      -webkit-tap-highlight-color: transparent; padding: 4px 0;
+    }
+    .tab-item svg { width: 20px; height: 20px; flex-shrink: 0; }
+    .tab-item:hover { color: var(--text-secondary); }
+    .tab-item.active { color: var(--brand); }
+  }
+
+  @media (max-width: 768px) {
+    .header-right { gap: 4px; }
+    .lang-switch { display: none; }
+  }
+  @media (max-width: 480px) {
+    .btn-primary { display: none; }
+    .btn-secondary { padding: 8px; border: none; }
+    .btn-secondary .btn-text { display: none; }
+    .header-inner { padding: 0 var(--size-3); gap: var(--size-1); }
+  }
+`);
+export class OpenLayout extends OpenElement {
+  _cleanupNav;
+  _scrollCleanup;
+  _navOptions;
+  get _locales() {
+    try {
+      const raw = this.locales || this.getAttribute('locales');
+      if (raw) {
+        if (Array.isArray(raw)) return raw;
+        if (typeof raw === 'string') {
+          try {
+            return JSON.parse(raw);
+          } catch  {}
+        }
+      }
+      return [
+        'en'
+      ];
+    } catch  {
+      return [
+        'en'
+      ];
+    }
+  }
+  get _defaultLocale() {
+    return this.getAttribute('locale') || this._locales[0] || 'en';
+  }
+  get _currentLocale() {
+    try {
+      if (typeof globalThis.location !== 'undefined') {
+        return detectLocale(location.pathname, this._locales, this._defaultLocale);
+      }
+      return this._defaultLocale;
+    } catch  {
+      return this._defaultLocale;
+    }
+  }
+  get _currentPathWithoutLocale() {
+    try {
+      if (typeof globalThis.location !== 'undefined') {
+        return parsePathWithoutLocale(location.pathname, this._locales);
+      }
+      return this.getAttribute('current-path') || '/';
+    } catch  {
+      return '/';
+    }
+  }
+  static styles = [
+    sheet
+  ];
+  static observedAttributes = [
+    'current-path',
+    'nav-items',
+    'header-nav',
+    'logo-text',
+    'logo-sub',
+    'github-url',
+    'edit-url',
+    'locale',
+    'locales'
+  ];
+  _themeHandler;
+  _docClickCleanup;
+  render() {
+    return this._renderLayout();
+  }
+  _getStr(attr, def) {
+    const camel = attr.replace(/-([a-z])/g, (_, c)=>c.toUpperCase());
+    const prop = this[camel];
+    if (prop !== undefined && prop !== null) return String(prop);
+    return this.getAttribute(attr) || def;
+  }
+  _getBool(attr) {
+    const camel = attr.replace(/-([a-z])/g, (_, c)=>c.toUpperCase());
+    const prop = this[camel];
+    if (typeof prop === 'boolean') return prop;
+    return this.hasAttribute(attr);
+  }
+  // _currentPathWithoutLocale, _currentLocale, _locales, _switchPath(),
+  // _switchLabel(), _updateSwitch(), _localizePath()
+  // ?? all inlined (replaces former @openelement/router dependency)
+  _currentPath() {
+    // SSR-safe: prefer attribute/prop set by renderDsd over URL detection
+    // location.pathname is undefined during build.
+    const prop = this.currentPath;
+    if (typeof prop === 'string' && prop.length > 0) return prop;
+    const attr = this.getAttribute('current-path');
+    if (attr && attr.length > 0) return attr;
+    try {
+      if (typeof globalThis.location !== 'undefined') {
+        return parsePathWithoutLocale(location.pathname, this._locales);
+      }
+      return this.getAttribute('current-path') || '/';
+    } catch  {
+      return '/';
+    }
+  }
+  /** Compute GitHub edit URL from current path. */ _computeEditUrl() {
+    const path1 = this._currentPath();
+    if (!path1 || path1 === '/') return '';
+    const EDIT_BASE = 'https://github.com/open-element/openelement/edit/main/www/app/routes';
+    const clean = path1.replace(/\/$/, '').split('/').filter(Boolean);
+    // Remove locale prefix if present (en/, zh/)
+    if ([
+      'en',
+      'zh'
+    ].includes(clean[0])) clean.shift();
+    const filePath = clean.length === 0 ? 'index/index' : clean.join('/');
+    return `${EDIT_BASE}/${filePath}.tsx`;
+  }
+  _navItems() {
+    const items = this._rawNavItems();
+    return this._filterByPath(items);
+  }
+  /** Auto-filter sidebar sections by current path prefix. */ _filterByPath(items) {
+    const path1 = this._currentPath();
+    const SECTION_MAP = {
+      '/guide': [
+        'Quick Start',
+        'Core',
+        'Production'
+      ],
+      '/architecture': [
+        'Principles',
+        'Compatibility',
+        'Reference'
+      ],
+      '/registry': [
+        'Registry'
+      ],
+      '/hub': [
+        'Registry'
+      ],
+      '/blog': [
+        'History'
+      ]
+    };
+    for (const [prefix, sections] of Object.entries(SECTION_MAP)){
+      if (path1.startsWith(prefix)) {
+        return items.filter((s)=>sections.includes(s.section));
+      }
+    }
+    return items;
+  }
+  _rawNavItems() {
+    try {
+      const prop = this.navItems;
+      if (prop && Array.isArray(prop)) return prop;
+      const raw = this.getAttribute('nav-items');
+      if (raw) return JSON.parse(raw);
+      return [];
+    } catch (e) {
+      log.warn('Failed to parse nav-items JSON:', e);
+      return [];
+    }
+  }
+  _headerNav() {
+    try {
+      const prop = this.headerNav;
+      if (prop && Array.isArray(prop)) return prop;
+      const raw = this.getAttribute('header-nav');
+      if (raw) return JSON.parse(raw);
+      return [];
+    } catch (e) {
+      log.warn('Failed to parse header-nav JSON:', e);
+      return [];
+    }
+  }
+  // --- Icons ---
+  /** v0.24.1: SVG icon attributes shared across all mobile tab bar icons. */ static _ICON_ATTRS = {
+    viewBox: '0 0 20 20',
+    fill: 'none',
+    stroke: 'currentColor',
+    'stroke-width': '1.5',
+    'stroke-linecap': 'round',
+    'stroke-linejoin': 'round'
+  };
+  /** v0.24.1: Render mobile tab icon as JSX SVG. Falls back to a generic shape. */ _renderIcon(label) {
+    const a1 = OpenLayout._ICON_ATTRS;
+    switch(label){
+      case 'Home':
+        return <svg {...a1}>
+            <path d='M3 10l7-7 7 7'/>
+            <path d='M5 8v9h3v-5h4v5h3V8'/>
+          </svg>;
+      case 'Docs':
+      case 'Blog':
+        return <svg {...a1}>
+            <rect x='3' y='2' width='14' height='16' rx='2'/>
+            <path d='M7 6h6M7 10h6M7 14h3'/>
+          </svg>;
+      case 'Examples':
+        return <svg {...a1}>
+            <rect x='3' y='3' width='14' height='14' rx='2'/>
+            <path d='M7 7l6 3-6 3z'/>
+          </svg>;
+      case 'Components':
+        return <svg {...a1}>
+            <rect x='2' y='2' width='7' height='7' rx='1'/>
+            <rect x='11' y='2' width='7' height='7' rx='1'/>
+            <rect x='2' y='11' width='7' height='7' rx='1'/>
+            <rect x='11' y='11' width='7' height='7' rx='1'/>
+          </svg>;
+      case 'Architecture':
+      case 'Engine':
+        return <svg {...a1}>
+            <circle cx='10' cy='10' r='3'/>
+            <path d='M10 1v2M10 17v2M3.5 3.5l1.4 1.4M15.1 15.1l1.4 1.4M1 10h2M17 10h2M3.5 16.5l1.4-1.4M15.1 4.9l1.4-1.4'/>
+          </svg>;
+      case 'Hub':
+      case 'RegistryHub':
+        return <svg {...a1}>
+            <path d='M10 2l7 4v8l-7 4-7-4V6z'/>
+            <path d='M10 10l7-4M10 10v8M10 10L3 6'/>
+          </svg>;
+      case 'Roadmap':
+        return <svg {...a1}>
+            <circle cx='4' cy='6' r='1.5'/>
+            <circle cx='10' cy='10' r='1.5'/>
+            <circle cx='16' cy='14' r='1.5'/>
+            <path d='M5.5 6h10M11.5 10h5'/>
+          </svg>;
+      case 'Framework':
+        return <svg {...a1}>
+            <path d='M5 3h10M5 3v6h7M12 9v3M5 17h7'/>
+          </svg>;
+      default:
+        return <svg {...a1}>
+            <circle cx='10' cy='10' r='8'/>
+            <path d='M6 6l3 5 5 3-3-5z'/>
+          </svg>;
+    }
+  }
+  _safeHref(href, fallback = '#') {
+    if (!href) return fallback;
+    const trimmed = href.trim();
+    return isSafeLayoutUrl(trimmed) ? trimmed : fallback;
+  }
+  _isExternalHref(href) {
+    try {
+      const parsed = new URL(href, 'https://openelement.org/');
+      return parsed.origin !== 'https://openelement.org' && SAFE_URL_SCHEMES.has(parsed.protocol);
+    } catch  {
+      return false;
+    }
+  }
+  _localizedSafeHref(href) {
+    const safeHref = this._safeHref(href);
+    const isExternal = this._isExternalHref(safeHref);
+    return {
+      href: isExternal ? safeHref : localizePath(safeHref, this._currentLocale),
+      isExternal
+    };
+  }
+  // --- Main render ---
+  _renderLayout() {
+    const home = this._getBool('full-width') || this._getBool('home');
+    const noSearch = this.hasAttribute('no-search');
+    const logoText = this._getStr('logo-text', '');
+    const logoSub = this._getStr('logo-sub', '');
+    const locales = this._locales;
+    const currentLocale = this._currentLocale;
+    const currentPath = this._currentPathWithoutLocale;
+    const langLabel = locales.length > 1 ? switchLabel(currentLocale) : '';
+    const langHref = locales.length > 1 ? switchPath(currentPath, currentLocale, locales) : '';
+    return <div className='app-layout' part='container' home={home || undefined}>
+        <header className='app-header' part='header'>
+          <nav className='header-inner' aria-label='Primary navigation'>
+            {(logoText || logoSub) && <a className='logo' href='/'>
+                <open-brand-mark size='md'></open-brand-mark>
+                {logoText && <span className='logo-word'>{logoText}</span>}
+                {logoSub && <span className='logo-sub'>{logoSub}</span>}
+              </a>}
+            {this._renderHeaderNav()}
+            <div className='header-right'>
+              {!noSearch && <open-search></open-search>}
+              {!home && <button type='button' className='mobile-menu-btn' part='nav-toggle' aria-label='Toggle navigation' onClick={(event)=>this._toggleMenu(event)}>
+                  <svg width='18' height='18' viewBox='0 0 18 18' fill='none' stroke='currentColor' stroke-width='1.5' stroke-linecap='round'>
+                    <line x1='3' y1='4.5' x2='15' y2='4.5'/>
+                    <line x1='3' y1='9' x2='15' y2='9'/>
+                    <line x1='3' y1='13.5' x2='15' y2='13.5'/>
+                  </svg>
+                </button>}
+              <open-theme-toggle></open-theme-toggle>
+              {locales.length > 1 && <a className='lang-switch' href={langHref} data-nav={langHref}>
+                  {langLabel}
+                </a>}
+            </div>
+          </nav>
+        </header>
+        <div className='mobile-backdrop'></div>
+        <div className='layout-body'>
+          {!home && this._renderSidebarNav()}
+          <main className='layout-main' part='main'>
+            <slot></slot>
+          </main>
+        </div>
+        <footer className='app-footer' part='footer'>
+          <div className='footer-inner'>
+            <div className='footer-column'>
+              <h4>Product</h4>
+              <a href={localizePath('/guide/core-concepts', currentLocale)} data-nav={localizePath('/guide/core-concepts', currentLocale)}>
+                Elements
+              </a>
+              <a href={localizePath('/architecture/design-system', currentLocale)} data-nav={localizePath('/architecture/design-system', currentLocale)}>
+                UI
+              </a>
+              <a href={localizePath('/architecture/architecture', currentLocale)} data-nav={localizePath('/architecture/architecture', currentLocale)}>
+                Framework
+              </a>
+              <a href={localizePath('/architecture/standards-registry', currentLocale)} data-nav={localizePath('/architecture/standards-registry', currentLocale)}>
+                Protocols
+              </a>
+            </div>
+            <div className='footer-column'>
+              <h4>Resources</h4>
+              <a href={localizePath('/guide/getting-started', currentLocale)} data-nav={localizePath('/guide/getting-started', currentLocale)}>
+                Guide
+              </a>
+              <a href={localizePath('/guide/api', currentLocale)} data-nav={localizePath('/guide/api', currentLocale)}>
+                API
+              </a>
+              <a href={localizePath('/architecture/architecture', currentLocale)} data-nav={localizePath('/architecture/architecture', currentLocale)}>
+                Architecture
+              </a>
+              <a href={localizePath('/blog', currentLocale)} data-nav={localizePath('/blog', currentLocale)}>
+                Blog
+              </a>
+            </div>
+            <div className='footer-column'>
+              <h4>Company</h4>
+              <a href='https://github.com/open-element/openelement'>GitHub</a>
+              <a href={localizePath('/roadmap', currentLocale)} data-nav={localizePath('/roadmap', currentLocale)}>
+                Roadmap
+              </a>
+              <a href={localizePath('/changelog', currentLocale)} data-nav={localizePath('/changelog', currentLocale)}>
+                Changelog
+              </a>
+            </div>
+            <div className='footer-column'>
+              <h4>Legal</h4>
+              <a href='https://github.com/open-element/openelement/blob/main/LICENSE'>
+                MIT License
+              </a>
+              <a href={localizePath('/contributing', currentLocale)} data-nav={localizePath('/contributing', currentLocale)}>
+                Contributing
+              </a>
+            </div>
+          </div>
+          <div className='footer-bottom'>
+            <span>(c) 2026 openElement. MIT License.</span>
+          </div>
+        </footer>
+        {this._renderMobileTabBar()}
+      </div>;
+  }
+  _renderHeaderNav() {
+    const links = this._headerNav();
+    if (links.length === 0) return null;
+    const cp = this._currentPath();
+    return <nav className='header-nav' part='nav'>
+        {links.map((link)=>{
+      const { href: localized, isExternal } = this._localizedSafeHref(link.href);
+      const isCurrent = !isExternal && (cp === link.href || cp === localized || cp.startsWith(localized + '/'));
+      return <a href={localized} data-nav={isExternal ? '' : localized} aria-current={isCurrent ? 'page' : undefined}>
+              {link.label}
+            </a>;
+    })}
+      </nav>;
+  }
+  _renderSidebarNav() {
+    const nav1 = this._navItems();
+    if (nav1.length === 0) return null;
+    return <nav className='docs-sidebar' part='sidebar' aria-label='Documentation navigation'>
+        {nav1.map((section)=><details className='nav-section' open>
+            <summary className='nav-section-title'>
+              {section.section}
+            </summary>
+            {section.items.map((item)=>{
+        const href = item.href || item.path || '#';
+        const { href: localized, isExternal } = this._localizedSafeHref(href);
+        const cp = this._currentPath();
+        const isActive = !isExternal && cp === localized;
+        return <a href={localized} className={isActive ? 'active' : undefined} aria-current={isActive ? 'page' : undefined} data-nav={isExternal ? '' : localized}>
+                  {item.label}
+                </a>;
+      })}
+          </details>)}
+      </nav>;
+  }
+  _renderMobileTabBar() {
+    const links = this._headerNav();
+    if (links.length === 0) return null;
+    const MOBILE_TAB_LIMIT = 5;
+    const mobileLinks = links.slice(0, MOBILE_TAB_LIMIT);
+    const locs = this._locales;
+    const sectionRoot = (href)=>{
+      const segs = href.split('/').filter(Boolean);
+      const start = locs.length > 1 && locs.includes(segs[0]) ? 1 : 0;
+      return segs.length > start + 1 ? '/' + segs[start] : href;
+    };
+    const rawPath = this._currentPathWithoutLocale;
+    return <nav className='mobile-tab-bar' aria-label='Quick navigation'>
+        {mobileLinks.map((link)=>{
+      const { href: localized, isExternal } = this._localizedSafeHref(link.href);
+      const root = sectionRoot(link.href);
+      const isActive = !isExternal && (rawPath === root || rawPath.startsWith(root + '/'));
+      return <a className={`tab-item${isActive ? ' active' : ''}`} href={localized} data-nav={isExternal ? '' : localized} aria-current={isActive ? 'page' : undefined}>
+              {this._renderIcon(link.label)}
+              <span>{link.label}</span>
+            </a>;
+    })}
+      </nav>;
+  }
+  // --- Scroll detection ---
+  _setupScrollDetection() {
+    if (typeof globalThis.window === 'undefined') return;
+    let ticking;
+    const onScroll = ()=>{
+      if (ticking !== undefined) return;
+      ticking = globalThis.setTimeout(()=>{
+        const header1 = this.shadowRoot?.querySelector('.app-header');
+        if (header1) {
+          header1.classList.toggle('scrolled', globalThis.scrollY > 0);
+        }
+        ticking = undefined;
+      }, 100);
+    };
+    globalThis.addEventListener('scroll', onScroll, {
+      passive: true
+    });
+    this._scrollCleanup = ()=>{
+      globalThis.removeEventListener('scroll', onScroll);
+      if (ticking !== undefined) {
+        globalThis.clearTimeout(ticking);
+      }
+    };
+  }
+  _teardownScrollDetection() {
+    this._scrollCleanup?.();
+    this._scrollCleanup = undefined;
+  }
+  // --- Lifecycle ---
+  connectedCallback() {
+    super.connectedCallback();
+    const locales = this._locales;
+    if (locales.length > 1) {
+      const locale = this._currentLocale;
+      if (locales.includes(locale)) {
+        this.setAttribute('locale', locale);
+      }
+    }
+    // Sync data-theme from document.documentElement on connect
+    const docTheme = document.documentElement?.dataset?.theme;
+    if (docTheme) {
+      this.setAttribute('data-theme', docTheme);
+    }
+    // SignalContext: provide theme state to all child components
+    const initialTheme = docTheme || 'light';
+    provideContext(this, THEME_CTX, initialTheme);
+    // Listen for theme change events from open-theme-toggle
+    this._themeHandler = (e)=>{
+      const detail = e.detail;
+      if (detail?.theme) {
+        this.setAttribute('data-theme', detail.theme);
+        provideContext(this, THEME_CTX, detail.theme);
+        this._propagateTheme(detail.theme);
+      }
+    };
+    globalThis.addEventListener?.('open:theme-change', this._themeHandler);
+    this._propagateTheme(initialTheme);
+    if (this.shadowRoot && this.shadowRoot.childNodes.length > 0) {
+      this._setupDetailsToggle();
+    }
+    this._setupSpaNavigation({
+      contentLoader: async (path1, locale)=>{
+        await this._loadContent(path1, locale);
+      },
+      onAfterSwap: (_path)=>{
+        this._updateActiveNav();
+      }
+    });
+    // v0.23.0: Integrated from www/public/mobile-menu.js.
+    // Close mobile menu on backdrop click or sidebar nav link click.
+    this._docClickCleanup = this._setupBackdropClose();
+    // Scroll detection for header backdrop blur
+    this._setupScrollDetection();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._teardownSpaNavigation();
+    this._docClickCleanup?.();
+    if (this._themeHandler) {
+      globalThis.removeEventListener?.('open:theme-change', this._themeHandler);
+    }
+    this._teardownScrollDetection();
+  }
+  attributeChangedCallback(name, old, val) {
+    if (old === val) return;
+    if (name === 'current-path') {
+      this._updateActiveNav();
+    }
+  }
+  // --- Mobile menu ---
+  // v0.31 UI-shell debt: replace _replaceShadowRootFromLayout with signal-driven SPA nav.
+  // Currently SPA navigation destroys the entire shadow DOM and rebuilds it from
+  // fetched HTML, then manually re-attaches events in _setupDetailsToggle. This is
+  // incompatible with the signal architecture ?? we should make currentPath/navItems
+  // signals and let data-signal markers handle DOM updates reactively. Then the
+  // _setupDetailsToggle hack (and this entire method) can be deleted.
+  _menuBtnHandler = null;
+  _setupDetailsToggle() {
+    const btn = this.shadowRoot?.querySelector('.mobile-menu-btn');
+    if (!btn) return;
+    // Remove any stale listener from a previous shadow root.
+    if (this._menuBtnHandler) {
+      btn.removeEventListener('click', this._menuBtnHandler);
+    }
+    this._menuBtnHandler = this._toggleMenu.bind(this);
+    btn.addEventListener('click', this._menuBtnHandler);
+  }
+  _toggleMenu(_e) {
+    const isOpen = this.hasAttribute('menu-open');
+    this.toggleAttribute('menu-open', !isOpen);
+    this._syncInert(!isOpen);
+  }
+  _syncInert(menuOpen) {
+    const main1 = this.shadowRoot?.querySelector('.layout-main');
+    if (main1) {
+      if (menuOpen) main1.setAttribute('inert', '');
+      else main1.removeAttribute('inert');
+    }
+  }
+  /**
+   * v0.23.0: Integrated from www/public/mobile-menu.js.
+   * Closes mobile menu when backdrop or sidebar nav link is clicked.
+   * Uses composedPath() to detect clicks across shadow DOM boundaries.
+   */ _setupBackdropClose() {
+    const handler = (e)=>{
+      const target = e.target;
+      if (!target || !(target instanceof Element)) return;
+      const path1 = e.composedPath();
+      let isBackdrop = false;
+      let isNavLink = false;
+      for(let i = 0; i < path1.length; i++){
+        const el = path1[i];
+        if (!el?.classList) continue;
+        if (el.classList.contains('mobile-backdrop')) {
+          isBackdrop = true;
+          break;
+        }
+        if (el.tagName === 'A') {
+          isNavLink = true;
+          break;
+        }
+      }
+      if (!isBackdrop && !isNavLink) return;
+      this._closeMenu();
+    };
+    document.addEventListener('click', handler);
+    return ()=>document.removeEventListener('click', handler);
+  }
+  _closeMenu() {
+    this.removeAttribute('menu-open');
+    const details1 = this.shadowRoot?.querySelector('details.mobile-menu');
+    if (details1) details1.removeAttribute('open');
+    this._syncInert(false);
+  }
+  // --- Theme ---
+  _propagateTheme(theme) {
+    const walk = (root)=>{
+      root.querySelectorAll('*').forEach((el)=>{
+        if (el.tagName.includes('-')) {
+          el.setAttribute('data-theme', theme);
+        }
+        if (el.shadowRoot) {
+          walk(el.shadowRoot);
+        }
+      });
+    };
+    // Walk light DOM children (slotted page components like docs-home, ui-showcase)
+    walk(this);
+    // Walk shadow DOM content (internal layout elements)
+    if (this.shadowRoot) {
+      walk(this.shadowRoot);
+    }
+  }
+  /**
+   * Recursively search for open-layout in parsed DOM, including
+   * inside <template shadowrootmode="open"> (DSD content).
+   *
+   * querySelector does not traverse template content, but SSG pages
+   * wrap page output in a page component whose shadow root contains
+   * the <open-layout>.
+   */ _findOpenLayout(root) {
+    for (const child of Array.from(root.children)){
+      if (child.tagName.toLowerCase() === 'open-layout') return child;
+      if (child.tagName === 'TEMPLATE') {
+        const found = this._findOpenLayout(child.content);
+        if (found) return found;
+      }
+      const found = this._findOpenLayout(child);
+      if (found) return found;
+    }
+    return null;
+  }
+  _activateDeclarativeShadowRoots(root) {
+    const templates = Array.from(root.querySelectorAll('template[shadowrootmode]'));
+    if (root instanceof HTMLElement && root.firstElementChild instanceof HTMLTemplateElement && root.firstElementChild.hasAttribute('shadowrootmode')) {
+      templates.unshift(root.firstElementChild);
+    }
+    for (const template of templates){
+      const host = template.parentElement;
+      if (!host || host.shadowRoot) {
+        template.remove();
+        continue;
+      }
+      const mode = template.getAttribute('shadowrootmode') === 'closed' ? 'closed' : 'open';
+      const shadow = host.attachShadow({
+        mode
+      });
+      shadow.appendChild(template.content);
+      template.remove();
+    }
+  }
+  _isShadowTemplate(el) {
+    return el instanceof HTMLTemplateElement && el.hasAttribute('shadowrootmode');
+  }
+  _syncLayoutAttributes(newLayout, locale) {
+    const incoming = new Set(Array.from(newLayout.attributes).map((attr)=>attr.name));
+    const preserve = new Set([
+      'data-theme',
+      'theme'
+    ]);
+    for (const attr of Array.from(this.attributes)){
+      if (!incoming.has(attr.name) && !preserve.has(attr.name)) {
+        this.removeAttribute(attr.name);
+      }
+    }
+    for (const attr of Array.from(newLayout.attributes)){
+      this.setAttribute(attr.name, attr.value);
+    }
+    this.setAttribute('locale', locale);
+    this.setAttribute('current-path', newLayout.getAttribute('current-path') || this._currentPathWithoutLocale);
+  }
+  _replaceShadowRootFromLayout(newLayout) {
+    const shadowTemplate = Array.from(newLayout.children).find((child)=>this._isShadowTemplate(child));
+    if (!shadowTemplate || !this.shadowRoot) return;
+    while(this.shadowRoot.firstChild){
+      this.shadowRoot.removeChild(this.shadowRoot.firstChild);
+    }
+    this.shadowRoot.appendChild(document.adoptNode(shadowTemplate.content));
+    this._activateDeclarativeShadowRoots(this.shadowRoot);
+    this._setupDetailsToggle();
+    this._updateSwitch(this.shadowRoot);
+  }
+  /* --- SPA navigation (inlined from @openelement/router) --- */ _setupSpaNavigation(opts) {
+    this._navOptions = opts;
+    if (this.shadowRoot) {
+      this._setupClickDelegation(this.shadowRoot);
+    }
+    this._setupNavigationApi();
+    this._setupPopState();
+  }
+  _teardownSpaNavigation() {
+    this._cleanupNav?.();
+    this._cleanupNav = undefined;
+    this._navOptions = undefined;
+  }
+  _setupClickDelegation(root) {
+    const handler = (e)=>{
+      const link = e.target.closest('a');
+      if (!link) return;
+      const href = link.getAttribute('href');
+      if (!href) return;
+      if (!isSafeLayoutUrl(href) || /^https?:/i.test(href) || href.startsWith('#')) {
+        return;
+      }
+      e.preventDefault();
+      e.stopImmediatePropagation();
+      const isLangSwitch = link.classList.contains('lang-switch');
+      if (isLangSwitch) {
+        this._replaceTo(href);
+      } else {
+        this._navigateTo(href);
+      }
+    };
+    root.addEventListener('click', handler);
+    const prev = this._cleanupNav;
+    this._cleanupNav = ()=>{
+      root.removeEventListener('click', handler);
+      prev?.();
+    };
+  }
+  _setupNavigationApi() {
+    const nav1 = globalThis.navigation;
+    if (!nav1) return;
+    const onNav = (event)=>{
+      const e = event;
+      if (!e.canIntercept || e.hashChange || e.downloadRequest) return;
+      const url = new URL(e.destination.url);
+      if (url.origin !== location.origin) return;
+      e.intercept({
+        handler: ()=>this._navigateNow(url.pathname)
+      });
+    };
+    try {
+      nav1.addEventListener('navigate', onNav);
+      const prev = this._cleanupNav;
+      this._cleanupNav = ()=>{
+        try {
+          nav1.removeEventListener('navigate', onNav);
+        } catch  {}
+        prev?.();
+      };
+    } catch  {
+    // Navigation API interception is optional; fall back to popstate routing.
+    }
+  }
+  _setupPopState() {
+    const handler = ()=>{
+      this._navigateNow(location.pathname);
+    };
+    globalThis.addEventListener('popstate', handler);
+    const prev = this._cleanupNav;
+    this._cleanupNav = ()=>{
+      globalThis.removeEventListener('popstate', handler);
+      prev?.();
+    };
+  }
+  _navigateTo(href) {
+    const url = new URL(href, location.origin);
+    if (url.origin !== location.origin) {
+      location.href = href;
+      return;
+    }
+    history.pushState(null, '', url.pathname + url.search + url.hash);
+    this._navigateNow(url.pathname);
+  }
+  _replaceTo(href) {
+    const url = new URL(href, location.origin);
+    if (url.origin !== location.origin) return;
+    history.replaceState(null, '', url.pathname + url.search + url.hash);
+    this._navigateNow(url.pathname);
+  }
+  _navigateNow(pathname) {
+    const locale = detectLocale(pathname, this._locales, this._defaultLocale);
+    this.setAttribute('current-path', pathname);
+    this.setAttribute('locale', locale);
+    const opts = this._navOptions;
+    if (!opts) return;
+    // Update lang-switch immediately (before async fetch)
+    if (this.shadowRoot) {
+      this._updateSwitch(this.shadowRoot);
+    }
+    opts.contentLoader(pathname, locale).then(()=>{
+      if (this.shadowRoot) {
+        this._updateSwitch(this.shadowRoot);
+      }
+      opts.onAfterSwap?.(pathname, locale);
+    }).catch((err)=>{
+      log.warn('content load failed:', err);
+      location.reload();
+    });
+  }
+  _updateSwitch(shadowRoot) {
+    const link = shadowRoot.querySelector('.lang-switch');
+    if (!link) return;
+    const pathWithoutLocale = this._currentPathWithoutLocale;
+    const currentLocale = this._currentLocale;
+    link.textContent = switchLabel(currentLocale);
+    link.setAttribute('href', switchPath(pathWithoutLocale, currentLocale, this._locales));
+  }
+  async _loadContent(path1, locale) {
+    try {
+      const resp = await fetch(path1);
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      const html = await resp.text();
+      const parsed = new DOMParser().parseFromString(html, 'text/html');
+      const tmp = parsed.body;
+      const newLayout = this._findOpenLayout(tmp);
+      if (!newLayout) throw new Error('No open-layout found');
+      document.documentElement.lang = parsed.documentElement.lang || locale;
+      if (parsed.title) document.title = parsed.title;
+      this._syncHeadElement(parsed, 'meta[name="description"]');
+      this._syncHeadElement(parsed, 'link[rel="canonical"]');
+      this._syncHeadElements(parsed, 'link[rel="alternate"][hreflang]');
+      this._syncLayoutAttributes(newLayout, locale);
+      this._replaceShadowRootFromLayout(newLayout);
+      // DOMParser nodes belong to a different document. adoptNode()
+      // transfers ownership so appendChild works without errors.
+      while(this.firstChild)this.removeChild(this.firstChild);
+      const children = Array.from(newLayout.children).filter((child)=>!this._isShadowTemplate(child));
+      for (const child of children){
+        const adopted = document.adoptNode(child);
+        if (adopted instanceof Element) {
+          this._activateDeclarativeShadowRoots(adopted);
+        }
+        this.appendChild(adopted);
+      }
+      // Propagate theme to newly inserted components.
+      const currentTheme = this.getAttribute('data-theme') || document.documentElement?.dataset?.theme;
+      if (currentTheme) {
+        this._propagateTheme(currentTheme);
+        requestAnimationFrame(()=>this._propagateTheme(currentTheme));
+      }
+      globalThis.scrollTo({
+        top: 0,
+        behavior: 'smooth'
+      });
+    } catch (e) {
+      log.warn('SPA navigation failed, reloading:', e);
+      globalThis.location.reload();
+    }
+  }
+  _syncHeadElement(parsed, selector) {
+    const incoming = parsed.head.querySelector(selector);
+    const current = document.head.querySelector(selector);
+    if (!incoming) {
+      current?.remove();
+      return;
+    }
+    const cloned = document.adoptNode(incoming.cloneNode(true));
+    if (current) current.replaceWith(cloned);
+    else document.head.appendChild(cloned);
+  }
+  _syncHeadElements(parsed, selector) {
+    document.head.querySelectorAll(selector).forEach((el)=>el.remove());
+    parsed.head.querySelectorAll(selector).forEach((el)=>{
+      document.head.appendChild(document.adoptNode(el.cloneNode(true)));
+    });
+  }
+  _updateActiveNav() {
+    if (!this.shadowRoot) return;
+    const cp = this._currentPath();
+    const links = this.shadowRoot.querySelectorAll('.docs-sidebar a[data-nav], .header-nav a[data-nav]');
+    links.forEach((a1)=>{
+      const nav1 = a1.getAttribute('data-nav');
+      const isActive = nav1 === cp;
+      a1.classList.toggle('active', isActive);
+      if (isActive) a1.setAttribute('aria-current', 'page');
+      else a1.removeAttribute('aria-current');
+    });
+  }
+  // --- Utilities ---
+  _esc = escapeHtml;
+  _escAttr = escapeAttr;
+}
+export default OpenLayout;
+// Guard: idempotent across SSR paths
+if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+  customElements.define(tagName, OpenLayout);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ui/src/open-layout.tsx"],"sourcesContent":["/** @jsxImportSource @openelement/core */\n/**\n * @openelement/ui - open-layout\n *\n * App layout component with header, sidebar, and footer.\n * Web Standards Lab: light-first, restrained, documentation-focused.\n *\n * v0.20.0: Migrated from DsdLitElement to DsdElement (Ocean component).\n *   - CSSStyleSheet replaces Lit css``\n *   - render() returns string\n *   - @click bindings for mobile menu toggle\n *   - SPA navigation via Navigation API (navigate/fetch/swap) preserved\n *   - Event delegation at shadow root level for nav clicks\n * v0.24.1: Migrated from html`` template to JSX (ADR-0057).\n *\n * @csspart container - The app-layout root div\n * @csspart header - The sticky header element\n * @csspart sidebar - The docs-sidebar nav\n * @csspart main - The layout-main element\n * @csspart footer - The app-footer element\n * @csspart nav - The header-nav element\n * @csspart nav-toggle - The mobile menu toggle button\n *\n * Usage:\n * ```html\n * <open-layout current-path=\"/guide/getting-started\"\n *   nav-items='[{\"section\":\"Guide\",\"items\":[{\"path\":\"/guide/getting-started\",\"label\":\"Getting Started\"}]}]'>\n * </open-layout>\n * ```\n */\n\nimport { OpenElement } from '@openelement/element';\nimport { StyleSheet, type StyleSheetLike } from '@openelement/core/style-sheet';\nimport { type Context, createContext, provideContext } from '@openelement/core';\nimport { escapeAttr, escapeHtml } from '@openelement/core';\nimport { createLogger } from '@openelement/core/logger';\nimport '.\\/open-theme-toggle.js';\nimport './open-brand-mark.js';\n\nexport const tagName = 'open-layout';\nconst SAFE_URL_SCHEMES = new Set(['http:', 'https:', 'mailto:', 'tel:', 'sms:']);\nconst log = createLogger('ui');\n\nfunction isSafeLayoutUrl(url: string): boolean {\n  const trimmed = url.trim();\n  if (!trimmed) return false;\n  if (trimmed.startsWith('//')) return false;\n  if (\n    trimmed.startsWith('/') ||\n    trimmed.startsWith('#') ||\n    trimmed.startsWith('./') ||\n    trimmed.startsWith('../')\n  ) {\n    return true;\n  }\n  try {\n    const parsed = new URL(trimmed, 'https://openelement.org/');\n    return SAFE_URL_SCHEMES.has(parsed.protocol);\n  } catch {\n    return false;\n  }\n}\n\n/* --- Navigation API types (for SPA routing) --- */\ninterface NavigationLike extends EventTarget {\n  addEventListener(type: 'navigate', listener: EventListener): void;\n  removeEventListener(type: 'navigate', listener: EventListener): void;\n}\n\ninterface NavigationNavigateEvent extends Event {\n  canIntercept: boolean;\n  hashChange: boolean;\n  downloadRequest: boolean;\n  destination: { url: string };\n  intercept(opts: { handler: () => void }): void;\n}\n\n/* --- Locale/path helpers (inlined from @openelement/router) --- */\n\nconst LOCALE_LABELS: Record<string, string> = { en: '中文', zh: 'English' };\n\nfunction parsePathWithoutLocale(pathname: string, locales: string[]): string {\n  const segs = pathname.split('/').filter(Boolean);\n  if (segs.length > 0 && locales.includes(segs[0])) {\n    return '/' + segs.slice(1).join('/') || '/';\n  }\n  return pathname || '/';\n}\n\nfunction detectLocale(pathname: string, locales: string[], defaultLocale: string): string {\n  const segs = pathname.split('/').filter(Boolean);\n  if (segs.length > 0 && locales.includes(segs[0])) return segs[0];\n  return defaultLocale;\n}\n\nfunction localizePath(path: string, locale: string): string {\n  if (isSafeLayoutUrl(path) && /^https?:/i.test(path)) return path;\n  return `/${locale}${path}`;\n}\n\nfunction switchPath(currentPath: string, currentLocale: string, locales: string[]): string {\n  const other = locales.find((l) => l !== currentLocale) || currentLocale;\n  return `/${other}${currentPath}`;\n}\n\nfunction switchLabel(currentLocale: string): string {\n  return LOCALE_LABELS[currentLocale] || currentLocale;\n}\n\n/** SignalContext key: theme state shared across all components */\nexport const THEME_CTX: Context<'dark' | 'light'> = createContext<'dark' | 'light'>(\n  Symbol('theme'),\n  'light',\n);\n\nexport interface NavItem {\n  path?: string;\n  href?: string;\n  label: string;\n}\n\nexport interface NavSection {\n  section: string;\n  items: NavItem[];\n}\n\nexport interface HeaderNavLink {\n  href: string;\n  label: string;\n}\n\nconst sheet: StyleSheetLike = new StyleSheet();\nsheet.replaceSync(`\n  :host {\n    display: block;\n  }\n\n  * { font-family: var(--font-sans); }\n\n  .app-layout {\n    display: flex;\n    flex-direction: column;\n    min-height: 100vh;\n    background: var(--bg-base);\n    color: var(--text-primary);\n    font-family: var(--font-sans);\n    -webkit-font-smoothing: antialiased;\n    -moz-osx-font-smoothing: grayscale;\n  }\n\n  .layout-body {\n    display: flex;\n    flex: 1;\n    max-width: 1400px;\n    margin: 0 auto;\n    width: 100%;\n  }\n\n  .layout-main {\n    flex: 1;\n    min-width: 0;\n    width: 100%;\n  }\n\n  .app-layout[home] .layout-body,\n  .app-layout[full-width] .layout-body {\n    display: flex;\n    flex-direction: column;\n    max-width: none;\n  }\n\n  .app-layout[home] .layout-main,\n  .app-layout[full-width] .layout-main {\n    flex: 1;\n  }\n\n  /* Header */\n  .app-header {\n    position: sticky;\n    top: 0;\n    z-index: 100;\n    background: var(--nav-bg);\n    border-bottom: var(--border-size-1) solid var(--border);\n    backdrop-filter: blur(18px) saturate(150%);\n    -webkit-backdrop-filter: blur(18px) saturate(150%);\n    transition: background 0.2s ease, border-color 0.2s ease, box-shadow 0.2s ease;\n  }\n  .app-header.scrolled {\n    background: color-mix(in srgb, var(--bg-base) 88%, transparent);\n    border-bottom-color: var(--border-hover);\n    box-shadow: 0 var(--size-2) var(--size-10) color-mix(in srgb, var(--brand) 5%, transparent);\n  }\n\n  .header-inner {\n    max-width: none;\n    margin: 0 auto;\n    padding: 0 clamp(var(--size-5), 3.5vw, var(--size-9));\n    display: flex;\n    align-items: center;\n    min-height: var(--nav-height);\n    gap: var(--size-6);\n  }\n\n  .mobile-tab-bar { display: none; }\n\n  .mobile-menu-btn {\n    display: none;\n    align-items: center;\n    justify-content: center;\n    width: var(--size-10);\n    height: var(--size-10);\n    border: var(--border-size-1) solid var(--border);\n    border-radius: var(--radius-round);\n    background: color-mix(in srgb, var(--bg-elevated) 74%, transparent);\n    color: var(--text-secondary);\n    cursor: pointer;\n    padding: 0;\n    transition: all 0.15s ease;\n  }\n  .mobile-menu-btn:hover {\n    color: var(--text-primary);\n    border-color: var(--border-hover);\n    background: var(--bg-hover);\n  }\n\n  .logo {\n    display: inline-flex;\n    align-items: center;\n    gap: var(--size-3);\n    font-size: var(--font-size-3);\n    font-weight: var(--font-weight-8);\n    color: var(--text-primary);\n    text-decoration: none;\n    letter-spacing: 0;\n    white-space: nowrap;\n  }\n\n  .logo:hover open-brand-mark {\n    transform: translateY(calc(var(--border-size-1) * -1));\n  }\n\n  open-brand-mark {\n    transition: transform var(--duration-2) var(--ease-2);\n  }\n\n  .logo-word {\n    display: inline-block;\n    transform: translateY(calc(var(--border-size-1) * -1));\n  }\n\n  .logo-sub {\n    font-size: var(--font-size-00);\n    color: var(--text-muted);\n    margin-left: var(--size-2);\n    font-family: var(--font-mono);\n    font-weight: var(--font-weight-8);\n    text-transform: uppercase;\n  }\n\n  .header-nav {\n    display: flex;\n    gap: clamp(var(--size-5), 3vw, var(--size-8));\n    flex: 1;\n    justify-content: center;\n  }\n  .header-nav a {\n    color: var(--nav-link-color);\n    text-decoration: none;\n    font-size: var(--font-size-1);\n    font-weight: var(--font-weight-5);\n    padding: var(--size-2) 0;\n    transition: color 0.15s ease, background 0.15s ease;\n  }\n  .header-nav a:hover {\n    color: var(--nav-link-hover);\n  }\n  .header-nav a[aria-current=\"page\"] {\n    color: var(--brand-deep);\n    font-weight: var(--font-weight-8);\n  }\n\n  .header-right {\n    display: flex;\n    align-items: center;\n    gap: var(--size-1);\n    margin-left: auto;\n  }\n\n  /* CTA buttons */\n  .btn-secondary {\n    display: inline-flex;\n    align-items: center;\n    gap: var(--size-2);\n    color: var(--text-primary);\n    text-decoration: none;\n    font-size: var(--font-size-button);\n    font-weight: var(--font-weight-semibold);\n    padding: var(--size-2) var(--size-4);\n    border: var(--border-size-1) solid color-mix(in srgb, var(--border) 72%, var(--brand));\n    border-radius: var(--radius-round);\n    background: color-mix(in srgb, var(--bg-elevated) 76%, transparent);\n    box-shadow: inset 0 1px 0 color-mix(in srgb, var(--gray-0) 70%, transparent);\n    transition: all 0.15s ease;\n  }\n  .btn-secondary:hover {\n    color: var(--brand-deep);\n    border-color: var(--brand-light);\n    background: color-mix(in srgb, var(--brand-pale) 42%, var(--bg-elevated));\n  }\n  .btn-secondary svg { flex-shrink: 0; }\n\n  .btn-primary {\n    display: inline-flex;\n    align-items: center;\n    gap: 4px;\n    color: var(--on-brand);\n    text-decoration: none;\n    font-size: var(--font-size-button);\n    font-weight: var(--font-weight-semibold);\n    padding: var(--size-2) var(--size-4);\n    border: var(--border-size-1) solid transparent;\n    border-radius: var(--radius-round);\n    background: linear-gradient(135deg, var(--brand), var(--brand-light));\n    box-shadow: 0 var(--size-2) var(--size-5) var(--brand-glow);\n    white-space: nowrap;\n    transition: all 0.15s ease;\n  }\n  .btn-primary:hover {\n    background: linear-gradient(135deg, var(--brand-hover), var(--brand-light));\n    transform: translateY(calc(var(--border-size-1) * -1));\n  }\n\n  .header-right .btn-secondary,\n  .header-right .btn-primary {\n    display: none;\n  }\n\n  .lang-switch {\n    display: inline-flex;\n    align-items: center;\n    justify-content: center;\n    min-width: var(--size-9);\n    width: var(--size-9);\n    height: var(--size-9);\n    padding: 0;\n    font-size: var(--font-size-button);\n    font-weight: var(--font-weight-semibold);\n    color: var(--text-secondary);\n    border: 0;\n    border-radius: var(--radius-round);\n    background: transparent;\n    cursor: pointer;\n    text-decoration: none;\n    transition: all 0.15s ease;\n  }\n  .lang-switch:hover {\n    color: var(--brand-deep);\n    border-color: transparent;\n    background: color-mix(in srgb, var(--brand-pale) 34%, transparent);\n  }\n\n  /* Sidebar */\n  .docs-sidebar {\n    width: clamp(200px, 20vw, 260px);\n    flex-shrink: 0;\n    border-right: var(--border-size-1) solid var(--border);\n    padding: 2rem 0;\n    overflow-y: auto;\n    height: calc(100vh - var(--nav-height));\n    position: sticky;\n    top: var(--nav-height);\n    scrollbar-width: thin;\n    background: color-mix(in srgb, var(--bg-elevated) 42%, transparent);\n  }\n  :host([home]) .docs-sidebar,\n  :host([full-width]) .docs-sidebar {\n    width: 0; min-width: 0; padding: 0;\n    overflow: hidden; border-right: none;\n  }\n\n  .nav-section { margin-bottom: 1.5rem; }\n  .nav-section summary {\n    font-size: 0.625rem;\n    font-weight: 800;\n    text-transform: uppercase;\n    letter-spacing: 0.22em;\n    color: var(--text-muted);\n    padding: 0 1.5rem;\n    margin-bottom: 0.5rem;\n    cursor: pointer;\n    list-style: none;\n    display: flex;\n    align-items: center;\n    gap: 0.5rem;\n    user-select: none;\n  }\n  .nav-section summary::-webkit-details-marker { display: none; }\n  .nav-section summary::marker { content: \"\"; }\n  .nav-section summary:hover { color: var(--text-secondary); }\n\n  .docs-sidebar a {\n    display: block;\n    color: var(--text-muted);\n    text-decoration: none;\n    font-size: 0.85rem;\n    padding: 0.35rem 1.5rem;\n    border-left: 2px solid transparent;\n    transition: color 0.15s ease, border-color 0.15s ease, background 0.15s ease;\n  }\n  .docs-sidebar a:hover {\n    color: var(--text-secondary);\n    background: var(--bg-hover);\n  }\n  .docs-sidebar a.active,\n  .docs-sidebar a[aria-current=\"page\"] {\n    color: var(--brand);\n    border-left-color: var(--brand);\n    background: var(--brand-subtle);\n    font-weight: 600;\n  }\n\n  /* Footer */\n  .app-footer {\n    border-top: var(--border-size-1) solid var(--border);\n    background: color-mix(in srgb, var(--bg-elevated) 58%, transparent);\n  }\n  .footer-inner {\n    max-width: 1240px;\n    margin: 0 auto;\n    padding: var(--size-16) var(--size-8);\n    display: grid;\n    grid-template-columns: repeat(4, 1fr);\n    gap: var(--size-8);\n  }\n  .footer-column h4 {\n    font-size: var(--font-size-button);\n    font-weight: var(--font-weight-semibold);\n    color: var(--text-primary);\n    margin: 0 0 var(--size-4);\n  }\n  .footer-column a {\n    display: block;\n    color: var(--text-secondary);\n    text-decoration: none;\n    font-size: var(--font-size-body-sm);\n    padding: 4px 0;\n    transition: color 0.15s ease;\n  }\n  .footer-column a:hover {\n    color: var(--text-primary);\n  }\n  .footer-bottom {\n    border-top: var(--border-size-1) solid var(--border);\n    padding: var(--size-4) var(--size-8);\n    max-width: 1240px;\n    margin: 0 auto;\n    display: flex;\n    justify-content: space-between;\n    align-items: center;\n    color: var(--text-muted);\n    font-size: var(--font-size-body-sm);\n  }\n  .footer-bottom a {\n    color: var(--text-secondary);\n    text-decoration: none;\n    transition: color 0.15s ease;\n  }\n  .footer-bottom a:hover {\n    color: var(--text-primary);\n  }\n\n  /* Mobile backdrop */\n  .mobile-backdrop {\n    position: fixed; inset: 0; top: var(--nav-height);\n    background: var(--overlay);\n    z-index: 80; opacity: 0; pointer-events: none;\n    transition: opacity 0.3s ease;\n  }\n\n  /* Responsive */\n  @media (max-width: 1120px) {\n    .header-inner {\n      gap: var(--size-3);\n      padding-inline: var(--size-4);\n    }\n\n    .header-nav {\n      gap: var(--size-3);\n    }\n\n    .btn-secondary .btn-text { display: none; }\n  }\n\n  @media (max-width: 900px) {\n    .mobile-menu-btn { display: flex; }\n    .header-inner { padding: 0 var(--size-4); gap: var(--size-2); }\n    .header-nav { display: none; }\n    .btn-secondary .btn-text { display: none; }\n    .header-right { gap: 4px; }\n\n    .docs-sidebar {\n      position: fixed; top: var(--nav-height); left: 0;\n      width: min(280px, 80vw);\n      height: calc(100vh - var(--nav-height)); z-index: 90;\n      background: var(--bg-elevated);\n      border-right: var(--border-size-1) solid var(--border);\n      padding: 1rem 0; overflow-y: auto;\n      transform: translateX(-101%);\n      transition: transform 0.25s cubic-bezier(0.4,0,0.2,1);\n      will-change: transform;\n    }\n    :host([menu-open]) .docs-sidebar {\n      transform: translateX(0);\n      box-shadow: var(--shadow-1);\n    }\n    :host([menu-open]) .mobile-backdrop { opacity: 1; pointer-events: auto; }\n    .nav-section { margin-bottom: 0.5rem; }\n    .nav-section summary { padding: var(--size-2) var(--size-4); }\n    .docs-sidebar a { padding: 0.5rem 1rem 0.5rem 2rem; }\n    .layout-main { width: 100%; }\n    .app-footer { padding: 0; }\n    .footer-inner {\n      grid-template-columns: repeat(2, 1fr);\n      padding: var(--size-12) var(--size-4);\n      padding-bottom: calc(var(--size-12) + var(--size-16));\n    }\n    .footer-bottom {\n      flex-direction: column;\n      gap: var(--size-2);\n      padding: var(--size-4);\n      padding-bottom: calc(var(--size-4) + var(--size-16));\n      text-align: center;\n    }\n\n    .mobile-tab-bar {\n      display: flex; position: fixed; bottom: 0; left: 0; right: 0;\n      height: 56px; z-index: 100;\n      background: var(--nav-bg);\n      backdrop-filter: blur(12px) saturate(180%);\n      -webkit-backdrop-filter: blur(12px) saturate(180%);\n      border-top: var(--border-size-1) solid var(--border);\n      padding: 0 env(safe-area-inset-right) 0 env(safe-area-inset-left);\n      padding-bottom: env(safe-area-inset-bottom);\n    }\n    .tab-item {\n      flex: 1; display: flex; flex-direction: column;\n      align-items: center; justify-content: center; gap: 2px;\n      color: var(--text-muted);\n      text-decoration: none; font-size: 10px; font-weight: 600;\n      transition: color 0.15s ease;\n      -webkit-tap-highlight-color: transparent; padding: 4px 0;\n    }\n    .tab-item svg { width: 20px; height: 20px; flex-shrink: 0; }\n    .tab-item:hover { color: var(--text-secondary); }\n    .tab-item.active { color: var(--brand); }\n  }\n\n  @media (max-width: 768px) {\n    .header-right { gap: 4px; }\n    .lang-switch { display: none; }\n  }\n  @media (max-width: 480px) {\n    .btn-primary { display: none; }\n    .btn-secondary { padding: 8px; border: none; }\n    .btn-secondary .btn-text { display: none; }\n    .header-inner { padding: 0 var(--size-3); gap: var(--size-1); }\n  }\n`);\n\nexport class OpenLayout extends OpenElement {\n  private _cleanupNav?: () => void;\n  private _scrollCleanup?: () => void;\n  private _navOptions?: {\n    contentLoader: (path: string, locale: string) => Promise<void>;\n    onAfterSwap?: (path: string, locale: string) => void;\n  };\n\n  private get _locales(): string[] {\n    try {\n      const raw = (this as Record<string, unknown>).locales || this.getAttribute('locales');\n      if (raw) {\n        if (Array.isArray(raw)) return raw as string[];\n        if (typeof raw === 'string') {\n          try {\n            return JSON.parse(raw);\n          } catch { /* ignore */ }\n        }\n      }\n      return ['en'];\n    } catch {\n      return ['en'];\n    }\n  }\n\n  private get _defaultLocale(): string {\n    return this.getAttribute('locale') || this._locales[0] || 'en';\n  }\n\n  private get _currentLocale(): string {\n    try {\n      if (typeof globalThis.location !== 'undefined') {\n        return detectLocale(location.pathname, this._locales, this._defaultLocale);\n      }\n      return this._defaultLocale;\n    } catch {\n      return this._defaultLocale;\n    }\n  }\n\n  private get _currentPathWithoutLocale(): string {\n    try {\n      if (typeof globalThis.location !== 'undefined') {\n        return parsePathWithoutLocale(location.pathname, this._locales);\n      }\n      return this.getAttribute('current-path') || '/';\n    } catch {\n      return '/';\n    }\n  }\n\n  static override styles = [sheet];\n  static override observedAttributes = [\n    'current-path',\n    'nav-items',\n    'header-nav',\n    'logo-text',\n    'logo-sub',\n    'github-url',\n    'edit-url',\n    'locale',\n    'locales',\n  ];\n\n  private _themeHandler?: (e: Event) => void;\n  private _docClickCleanup?: () => void;\n\n  override render(): ReturnType<typeof OpenElement.prototype.render> {\n    return this._renderLayout();\n  }\n\n  private _getStr(attr: string, def: string): string {\n    const camel = attr.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());\n    const prop = (this as Record<string, unknown>)[camel];\n    if (prop !== undefined && prop !== null) return String(prop);\n    return this.getAttribute(attr) || def;\n  }\n\n  private _getBool(attr: string): boolean {\n    const camel = attr.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());\n    const prop = (this as Record<string, unknown>)[camel];\n    if (typeof prop === 'boolean') return prop;\n    return this.hasAttribute(attr);\n  }\n\n  // _currentPathWithoutLocale, _currentLocale, _locales, _switchPath(),\n  // _switchLabel(), _updateSwitch(), _localizePath()\n  // ?? all inlined (replaces former @openelement/router dependency)\n\n  private _currentPath(): string {\n    // SSR-safe: prefer attribute/prop set by renderDsd over URL detection\n    // location.pathname is undefined during build.\n    const prop = (this as Record<string, unknown>).currentPath;\n    if (typeof prop === 'string' && prop.length > 0) return prop;\n    const attr = this.getAttribute('current-path');\n    if (attr && attr.length > 0) return attr;\n    try {\n      if (typeof globalThis.location !== 'undefined') {\n        return parsePathWithoutLocale(location.pathname, this._locales);\n      }\n      return this.getAttribute('current-path') || '/';\n    } catch {\n      return '/';\n    }\n  }\n\n  /** Compute GitHub edit URL from current path. */\n  private _computeEditUrl(): string {\n    const path = this._currentPath();\n    if (!path || path === '/') return '';\n    const EDIT_BASE = 'https://github.com/open-element/openelement/edit/main/www/app/routes';\n    const clean = path.replace(/\\/$/, '').split('/').filter(Boolean);\n    // Remove locale prefix if present (en/, zh/)\n    if (['en', 'zh'].includes(clean[0])) clean.shift();\n    const filePath = clean.length === 0 ? 'index/index' : clean.join('/');\n    return `${EDIT_BASE}/${filePath}.tsx`;\n  }\n\n  private _navItems(): NavSection[] {\n    const items = this._rawNavItems();\n    return this._filterByPath(items);\n  }\n\n  /** Auto-filter sidebar sections by current path prefix. */\n  private _filterByPath(items: NavSection[]): NavSection[] {\n    const path = this._currentPath();\n    const SECTION_MAP: Record<string, string[]> = {\n      '/guide': ['Quick Start', 'Core', 'Production'],\n      '/architecture': ['Principles', 'Compatibility', 'Reference'],\n      '/registry': ['Registry'],\n      '/hub': ['Registry'],\n      '/blog': ['History'],\n    };\n    for (const [prefix, sections] of Object.entries(SECTION_MAP)) {\n      if (path.startsWith(prefix)) {\n        return items.filter((s) => sections.includes(s.section));\n      }\n    }\n    return items;\n  }\n\n  private _rawNavItems(): NavSection[] {\n    try {\n      const prop = (this as Record<string, unknown>).navItems;\n      if (prop && Array.isArray(prop)) return prop as NavSection[];\n      const raw = this.getAttribute('nav-items');\n      if (raw) return JSON.parse(raw);\n      return [];\n    } catch (e) {\n      log.warn('Failed to parse nav-items JSON:', e);\n      return [];\n    }\n  }\n\n  private _headerNav(): HeaderNavLink[] {\n    try {\n      const prop = (this as Record<string, unknown>).headerNav;\n      if (prop && Array.isArray(prop)) return prop as HeaderNavLink[];\n      const raw = this.getAttribute('header-nav');\n      if (raw) return JSON.parse(raw);\n      return [];\n    } catch (e) {\n      log.warn('Failed to parse header-nav JSON:', e);\n      return [];\n    }\n  }\n\n  // --- Icons ---\n\n  /** v0.24.1: SVG icon attributes shared across all mobile tab bar icons. */\n  private static _ICON_ATTRS = {\n    viewBox: '0 0 20 20',\n    fill: 'none',\n    stroke: 'currentColor',\n    'stroke-width': '1.5',\n    'stroke-linecap': 'round' as const,\n    'stroke-linejoin': 'round' as const,\n  };\n\n  /** v0.24.1: Render mobile tab icon as JSX SVG. Falls back to a generic shape. */\n  private _renderIcon(label: string) {\n    const a = OpenLayout._ICON_ATTRS;\n    switch (label) {\n      case 'Home':\n        return (\n          <svg {...a}>\n            <path d='M3 10l7-7 7 7' />\n            <path d='M5 8v9h3v-5h4v5h3V8' />\n          </svg>\n        );\n      case 'Docs':\n      case 'Blog':\n        return (\n          <svg {...a}>\n            <rect x='3' y='2' width='14' height='16' rx='2' />\n            <path d='M7 6h6M7 10h6M7 14h3' />\n          </svg>\n        );\n      case 'Examples':\n        return (\n          <svg {...a}>\n            <rect x='3' y='3' width='14' height='14' rx='2' />\n            <path d='M7 7l6 3-6 3z' />\n          </svg>\n        );\n      case 'Components':\n        return (\n          <svg {...a}>\n            <rect x='2' y='2' width='7' height='7' rx='1' />\n            <rect x='11' y='2' width='7' height='7' rx='1' />\n            <rect x='2' y='11' width='7' height='7' rx='1' />\n            <rect x='11' y='11' width='7' height='7' rx='1' />\n          </svg>\n        );\n      case 'Architecture':\n      case 'Engine':\n        return (\n          <svg {...a}>\n            <circle cx='10' cy='10' r='3' />\n            <path d='M10 1v2M10 17v2M3.5 3.5l1.4 1.4M15.1 15.1l1.4 1.4M1 10h2M17 10h2M3.5 16.5l1.4-1.4M15.1 4.9l1.4-1.4' />\n          </svg>\n        );\n      case 'Hub':\n      case 'RegistryHub':\n        return (\n          <svg {...a}>\n            <path d='M10 2l7 4v8l-7 4-7-4V6z' />\n            <path d='M10 10l7-4M10 10v8M10 10L3 6' />\n          </svg>\n        );\n      case 'Roadmap':\n        return (\n          <svg {...a}>\n            <circle cx='4' cy='6' r='1.5' />\n            <circle cx='10' cy='10' r='1.5' />\n            <circle cx='16' cy='14' r='1.5' />\n            <path d='M5.5 6h10M11.5 10h5' />\n          </svg>\n        );\n      case 'Framework':\n        return (\n          <svg {...a}>\n            <path d='M5 3h10M5 3v6h7M12 9v3M5 17h7' />\n          </svg>\n        );\n      default:\n        return (\n          <svg {...a}>\n            <circle cx='10' cy='10' r='8' />\n            <path d='M6 6l3 5 5 3-3-5z' />\n          </svg>\n        );\n    }\n  }\n\n  private _safeHref(href: string | undefined, fallback = '#'): string {\n    if (!href) return fallback;\n    const trimmed = href.trim();\n    return isSafeLayoutUrl(trimmed) ? trimmed : fallback;\n  }\n\n  private _isExternalHref(href: string): boolean {\n    try {\n      const parsed = new URL(href, 'https://openelement.org/');\n      return parsed.origin !== 'https://openelement.org' && SAFE_URL_SCHEMES.has(parsed.protocol);\n    } catch {\n      return false;\n    }\n  }\n\n  private _localizedSafeHref(href: string | undefined): { href: string; isExternal: boolean } {\n    const safeHref = this._safeHref(href);\n    const isExternal = this._isExternalHref(safeHref);\n    return {\n      href: isExternal ? safeHref : localizePath(safeHref, this._currentLocale),\n      isExternal,\n    };\n  }\n\n  // --- Main render ---\n\n  private _renderLayout() {\n    const home = this._getBool('full-width') || this._getBool('home');\n    const noSearch = this.hasAttribute('no-search');\n    const logoText = this._getStr('logo-text', '');\n    const logoSub = this._getStr('logo-sub', '');\n    const locales = this._locales;\n    const currentLocale = this._currentLocale;\n    const currentPath = this._currentPathWithoutLocale;\n    const langLabel = locales.length > 1 ? switchLabel(currentLocale) : '';\n    const langHref = locales.length > 1 ? switchPath(currentPath, currentLocale, locales) : '';\n\n    return (\n      <div className='app-layout' part='container' home={home || undefined}>\n        <header className='app-header' part='header'>\n          <nav className='header-inner' aria-label='Primary navigation'>\n            {(logoText || logoSub) && (\n              <a className='logo' href='/'>\n                <open-brand-mark size='md'></open-brand-mark>\n                {logoText && <span className='logo-word'>{logoText}</span>}\n                {logoSub && <span className='logo-sub'>{logoSub}</span>}\n              </a>\n            )}\n            {this._renderHeaderNav()}\n            <div className='header-right'>\n              {!noSearch && <open-search></open-search>}\n              {!home && (\n                <button\n                  type='button'\n                  className='mobile-menu-btn'\n                  part='nav-toggle'\n                  aria-label='Toggle navigation'\n                  onClick={(event: Event) => this._toggleMenu(event)}\n                >\n                  <svg\n                    width='18'\n                    height='18'\n                    viewBox='0 0 18 18'\n                    fill='none'\n                    stroke='currentColor'\n                    stroke-width='1.5'\n                    stroke-linecap='round'\n                  >\n                    <line x1='3' y1='4.5' x2='15' y2='4.5' />\n                    <line x1='3' y1='9' x2='15' y2='9' />\n                    <line x1='3' y1='13.5' x2='15' y2='13.5' />\n                  </svg>\n                </button>\n              )}\n              <open-theme-toggle></open-theme-toggle>\n              {locales.length > 1 && (\n                <a\n                  className='lang-switch'\n                  href={langHref}\n                  data-nav={langHref}\n                >\n                  {langLabel}\n                </a>\n              )}\n            </div>\n          </nav>\n        </header>\n        <div className='mobile-backdrop'></div>\n        <div className='layout-body'>\n          {!home && this._renderSidebarNav()}\n          <main className='layout-main' part='main'>\n            <slot></slot>\n          </main>\n        </div>\n        <footer className='app-footer' part='footer'>\n          <div className='footer-inner'>\n            <div className='footer-column'>\n              <h4>Product</h4>\n              <a\n                href={localizePath('/guide/core-concepts', currentLocale)}\n                data-nav={localizePath('/guide/core-concepts', currentLocale)}\n              >\n                Elements\n              </a>\n              <a\n                href={localizePath('/architecture/design-system', currentLocale)}\n                data-nav={localizePath('/architecture/design-system', currentLocale)}\n              >\n                UI\n              </a>\n              <a\n                href={localizePath('/architecture/architecture', currentLocale)}\n                data-nav={localizePath('/architecture/architecture', currentLocale)}\n              >\n                Framework\n              </a>\n              <a\n                href={localizePath('/architecture/standards-registry', currentLocale)}\n                data-nav={localizePath('/architecture/standards-registry', currentLocale)}\n              >\n                Protocols\n              </a>\n            </div>\n            <div className='footer-column'>\n              <h4>Resources</h4>\n              <a\n                href={localizePath('/guide/getting-started', currentLocale)}\n                data-nav={localizePath('/guide/getting-started', currentLocale)}\n              >\n                Guide\n              </a>\n              <a\n                href={localizePath('/guide/api', currentLocale)}\n                data-nav={localizePath('/guide/api', currentLocale)}\n              >\n                API\n              </a>\n              <a\n                href={localizePath('/architecture/architecture', currentLocale)}\n                data-nav={localizePath('/architecture/architecture', currentLocale)}\n              >\n                Architecture\n              </a>\n              <a\n                href={localizePath('/blog', currentLocale)}\n                data-nav={localizePath('/blog', currentLocale)}\n              >\n                Blog\n              </a>\n            </div>\n            <div className='footer-column'>\n              <h4>Company</h4>\n              <a href='https://github.com/open-element/openelement'>GitHub</a>\n              <a\n                href={localizePath('/roadmap', currentLocale)}\n                data-nav={localizePath('/roadmap', currentLocale)}\n              >\n                Roadmap\n              </a>\n              <a\n                href={localizePath('/changelog', currentLocale)}\n                data-nav={localizePath('/changelog', currentLocale)}\n              >\n                Changelog\n              </a>\n            </div>\n            <div className='footer-column'>\n              <h4>Legal</h4>\n              <a href='https://github.com/open-element/openelement/blob/main/LICENSE'>\n                MIT License\n              </a>\n              <a\n                href={localizePath('/contributing', currentLocale)}\n                data-nav={localizePath('/contributing', currentLocale)}\n              >\n                Contributing\n              </a>\n            </div>\n          </div>\n          <div className='footer-bottom'>\n            <span>(c) 2026 openElement. MIT License.</span>\n          </div>\n        </footer>\n        {this._renderMobileTabBar()}\n      </div>\n    );\n  }\n\n  private _renderHeaderNav() {\n    const links = this._headerNav();\n    if (links.length === 0) return null;\n    const cp = this._currentPath();\n    return (\n      <nav className='header-nav' part='nav'>\n        {links.map((link) => {\n          const { href: localized, isExternal } = this._localizedSafeHref(link.href);\n          const isCurrent = !isExternal &&\n            (cp === link.href || cp === localized || cp.startsWith(localized + '/'));\n          return (\n            <a\n              href={localized}\n              data-nav={isExternal ? '' : localized}\n              aria-current={isCurrent ? 'page' : undefined}\n            >\n              {link.label}\n            </a>\n          );\n        })}\n      </nav>\n    );\n  }\n\n  private _renderSidebarNav() {\n    const nav = this._navItems();\n    if (nav.length === 0) return null;\n    return (\n      <nav\n        className='docs-sidebar'\n        part='sidebar'\n        aria-label='Documentation navigation'\n      >\n        {nav.map((section) => (\n          <details className='nav-section' open>\n            <summary className='nav-section-title'>\n              {section.section}\n            </summary>\n            {section.items.map((item) => {\n              const href = item.href || item.path || '#';\n              const { href: localized, isExternal } = this._localizedSafeHref(href);\n              const cp = this._currentPath();\n              const isActive = !isExternal && cp === localized;\n              return (\n                <a\n                  href={localized}\n                  className={isActive ? 'active' : undefined}\n                  aria-current={isActive ? 'page' : undefined}\n                  data-nav={isExternal ? '' : localized}\n                >\n                  {item.label}\n                </a>\n              );\n            })}\n          </details>\n        ))}\n      </nav>\n    );\n  }\n\n  private _renderMobileTabBar() {\n    const links = this._headerNav();\n    if (links.length === 0) return null;\n\n    const MOBILE_TAB_LIMIT = 5;\n    const mobileLinks = links.slice(0, MOBILE_TAB_LIMIT);\n\n    const locs = this._locales;\n    const sectionRoot = (href: string): string => {\n      const segs = href.split('/').filter(Boolean);\n      const start = locs.length > 1 && locs.includes(segs[0]) ? 1 : 0;\n      return segs.length > start + 1 ? '/' + segs[start] : href;\n    };\n\n    const rawPath = this._currentPathWithoutLocale;\n\n    return (\n      <nav className='mobile-tab-bar' aria-label='Quick navigation'>\n        {mobileLinks.map((link) => {\n          const { href: localized, isExternal } = this._localizedSafeHref(link.href);\n          const root = sectionRoot(link.href);\n          const isActive = !isExternal &&\n            (rawPath === root || rawPath.startsWith(root + '/'));\n          return (\n            <a\n              className={`tab-item${isActive ? ' active' : ''}`}\n              href={localized}\n              data-nav={isExternal ? '' : localized}\n              aria-current={isActive ? 'page' : undefined}\n            >\n              {this._renderIcon(link.label)}\n              <span>{link.label}</span>\n            </a>\n          );\n        })}\n      </nav>\n    );\n  }\n\n  // --- Scroll detection ---\n\n  private _setupScrollDetection(): void {\n    if (typeof globalThis.window === 'undefined') return;\n    let ticking: ReturnType<typeof setTimeout> | undefined;\n    const onScroll = () => {\n      if (ticking !== undefined) return;\n      ticking = globalThis.setTimeout(() => {\n        const header = this.shadowRoot?.querySelector('.app-header');\n        if (header) {\n          header.classList.toggle('scrolled', globalThis.scrollY > 0);\n        }\n        ticking = undefined;\n      }, 100);\n    };\n    globalThis.addEventListener('scroll', onScroll, { passive: true });\n    this._scrollCleanup = () => {\n      globalThis.removeEventListener('scroll', onScroll);\n      if (ticking !== undefined) {\n        globalThis.clearTimeout(ticking);\n      }\n    };\n  }\n\n  private _teardownScrollDetection(): void {\n    this._scrollCleanup?.();\n    this._scrollCleanup = undefined;\n  }\n\n  // --- Lifecycle ---\n\n  override connectedCallback(): void {\n    super.connectedCallback();\n\n    const locales = this._locales;\n    if (locales.length > 1) {\n      const locale = this._currentLocale;\n      if (locales.includes(locale)) {\n        this.setAttribute('locale', locale);\n      }\n    }\n\n    // Sync data-theme from document.documentElement on connect\n    const docTheme = document.documentElement?.dataset?.theme;\n    if (docTheme) {\n      this.setAttribute('data-theme', docTheme);\n    }\n    // SignalContext: provide theme state to all child components\n    const initialTheme = (docTheme as 'dark' | 'light') || 'light';\n    provideContext(this, THEME_CTX, initialTheme);\n\n    // Listen for theme change events from open-theme-toggle\n    this._themeHandler = (e: Event) => {\n      const detail = (e as CustomEvent).detail;\n      if (detail?.theme) {\n        this.setAttribute('data-theme', detail.theme);\n        provideContext(this, THEME_CTX, detail.theme);\n        this._propagateTheme(detail.theme);\n      }\n    };\n    globalThis.addEventListener?.('open:theme-change', this._themeHandler);\n\n    this._propagateTheme(initialTheme);\n\n    if (this.shadowRoot && this.shadowRoot.childNodes.length > 0) {\n      this._setupDetailsToggle();\n    }\n\n    this._setupSpaNavigation({\n      contentLoader: async (path: string, locale: string) => {\n        await this._loadContent(path, locale);\n      },\n      onAfterSwap: (_path: string) => {\n        this._updateActiveNav();\n      },\n    });\n\n    // v0.23.0: Integrated from www/public/mobile-menu.js.\n    // Close mobile menu on backdrop click or sidebar nav link click.\n    this._docClickCleanup = this._setupBackdropClose();\n\n    // Scroll detection for header backdrop blur\n    this._setupScrollDetection();\n  }\n\n  override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._teardownSpaNavigation();\n    this._docClickCleanup?.();\n    if (this._themeHandler) {\n      globalThis.removeEventListener?.('open:theme-change', this._themeHandler);\n    }\n    this._teardownScrollDetection();\n  }\n\n  override attributeChangedCallback(name: string, old: string | null, val: string | null): void {\n    if (old === val) return;\n    if (name === 'current-path') {\n      this._updateActiveNav();\n    }\n  }\n\n  // --- Mobile menu ---\n\n  // v0.31 UI-shell debt: replace _replaceShadowRootFromLayout with signal-driven SPA nav.\n  // Currently SPA navigation destroys the entire shadow DOM and rebuilds it from\n  // fetched HTML, then manually re-attaches events in _setupDetailsToggle. This is\n  // incompatible with the signal architecture ?? we should make currentPath/navItems\n  // signals and let data-signal markers handle DOM updates reactively. Then the\n  // _setupDetailsToggle hack (and this entire method) can be deleted.\n  private _menuBtnHandler: ((e: Event) => void) | null = null;\n\n  private _setupDetailsToggle(): void {\n    const btn = this.shadowRoot?.querySelector('.mobile-menu-btn');\n    if (!btn) return;\n    // Remove any stale listener from a previous shadow root.\n    if (this._menuBtnHandler) {\n      btn.removeEventListener('click', this._menuBtnHandler);\n    }\n    this._menuBtnHandler = this._toggleMenu.bind(this);\n    btn.addEventListener('click', this._menuBtnHandler);\n  }\n\n  private _toggleMenu(_e: Event): void {\n    const isOpen = this.hasAttribute('menu-open');\n    this.toggleAttribute('menu-open', !isOpen);\n    this._syncInert(!isOpen);\n  }\n\n  private _syncInert(menuOpen: boolean): void {\n    const main = this.shadowRoot?.querySelector('.layout-main');\n    if (main) {\n      if (menuOpen) main.setAttribute('inert', '');\n      else main.removeAttribute('inert');\n    }\n  }\n\n  /**\n   * v0.23.0: Integrated from www/public/mobile-menu.js.\n   * Closes mobile menu when backdrop or sidebar nav link is clicked.\n   * Uses composedPath() to detect clicks across shadow DOM boundaries.\n   */\n  private _setupBackdropClose(): () => void {\n    const handler = (e: Event) => {\n      const target = e.target;\n      if (!target || !(target instanceof Element)) return;\n\n      const path = e.composedPath();\n      let isBackdrop = false;\n      let isNavLink = false;\n\n      for (let i = 0; i < path.length; i++) {\n        const el = path[i] as Element;\n        if (!el?.classList) continue;\n        if (el.classList.contains('mobile-backdrop')) {\n          isBackdrop = true;\n          break;\n        }\n        if (el.tagName === 'A') {\n          isNavLink = true;\n          break;\n        }\n      }\n\n      if (!isBackdrop && !isNavLink) return;\n      this._closeMenu();\n    };\n\n    document.addEventListener('click', handler);\n    return () => document.removeEventListener('click', handler);\n  }\n\n  private _closeMenu(): void {\n    this.removeAttribute('menu-open');\n    const details = this.shadowRoot?.querySelector('details.mobile-menu');\n    if (details) details.removeAttribute('open');\n    this._syncInert(false);\n  }\n\n  // --- Theme ---\n  private _propagateTheme(theme: string): void {\n    const walk = (root: Element | ShadowRoot) => {\n      root.querySelectorAll('*').forEach((el) => {\n        if (el.tagName.includes('-')) {\n          el.setAttribute('data-theme', theme);\n        }\n        if (el.shadowRoot) {\n          walk(el.shadowRoot);\n        }\n      });\n    };\n    // Walk light DOM children (slotted page components like docs-home, ui-showcase)\n    walk(this);\n    // Walk shadow DOM content (internal layout elements)\n    if (this.shadowRoot) {\n      walk(this.shadowRoot);\n    }\n  }\n\n  /**\n   * Recursively search for open-layout in parsed DOM, including\n   * inside <template shadowrootmode=\"open\"> (DSD content).\n   *\n   * querySelector does not traverse template content, but SSG pages\n   * wrap page output in a page component whose shadow root contains\n   * the <open-layout>.\n   */\n  private _findOpenLayout(root: Element | DocumentFragment): HTMLElement | null {\n    for (const child of Array.from(root.children)) {\n      if (child.tagName.toLowerCase() === 'open-layout') return child as HTMLElement;\n      if (child.tagName === 'TEMPLATE') {\n        const found = this._findOpenLayout((child as HTMLTemplateElement).content);\n        if (found) return found;\n      }\n      const found = this._findOpenLayout(child);\n      if (found) return found;\n    }\n    return null;\n  }\n\n  private _activateDeclarativeShadowRoots(root: Element | ShadowRoot | DocumentFragment): void {\n    const templates = Array.from(\n      root.querySelectorAll<HTMLTemplateElement>('template[shadowrootmode]'),\n    );\n\n    if (\n      root instanceof HTMLElement &&\n      root.firstElementChild instanceof HTMLTemplateElement &&\n      root.firstElementChild.hasAttribute('shadowrootmode')\n    ) {\n      templates.unshift(root.firstElementChild);\n    }\n\n    for (const template of templates) {\n      const host = template.parentElement;\n      if (!host || host.shadowRoot) {\n        template.remove();\n        continue;\n      }\n\n      const mode = template.getAttribute('shadowrootmode') === 'closed' ? 'closed' : 'open';\n      const shadow = host.attachShadow({ mode });\n      shadow.appendChild(template.content);\n      template.remove();\n    }\n  }\n\n  private _isShadowTemplate(el: Element): el is HTMLTemplateElement {\n    return el instanceof HTMLTemplateElement && el.hasAttribute('shadowrootmode');\n  }\n\n  private _syncLayoutAttributes(newLayout: HTMLElement, locale: string): void {\n    const incoming = new Set(\n      Array.from(newLayout.attributes).map((attr) => attr.name),\n    );\n    const preserve = new Set(['data-theme', 'theme']);\n\n    for (const attr of Array.from(this.attributes)) {\n      if (!incoming.has(attr.name) && !preserve.has(attr.name)) {\n        this.removeAttribute(attr.name);\n      }\n    }\n    for (const attr of Array.from(newLayout.attributes)) {\n      this.setAttribute(attr.name, attr.value);\n    }\n    this.setAttribute('locale', locale);\n    this.setAttribute(\n      'current-path',\n      newLayout.getAttribute('current-path') || this._currentPathWithoutLocale,\n    );\n  }\n\n  private _replaceShadowRootFromLayout(newLayout: HTMLElement): void {\n    const shadowTemplate = Array.from(newLayout.children).find((child) =>\n      this._isShadowTemplate(child)\n    );\n    if (!shadowTemplate || !this.shadowRoot) return;\n\n    while (this.shadowRoot.firstChild) {\n      this.shadowRoot.removeChild(this.shadowRoot.firstChild);\n    }\n    this.shadowRoot.appendChild(document.adoptNode(shadowTemplate.content));\n    this._activateDeclarativeShadowRoots(this.shadowRoot);\n    this._setupDetailsToggle();\n    this._updateSwitch(this.shadowRoot);\n  }\n\n  /* --- SPA navigation (inlined from @openelement/router) --- */\n\n  private _setupSpaNavigation(opts: {\n    contentLoader: (path: string, locale: string) => Promise<void>;\n    onAfterSwap?: (path: string, locale: string) => void;\n  }): void {\n    this._navOptions = opts;\n\n    if (this.shadowRoot) {\n      this._setupClickDelegation(this.shadowRoot);\n    }\n    this._setupNavigationApi();\n    this._setupPopState();\n  }\n\n  private _teardownSpaNavigation(): void {\n    this._cleanupNav?.();\n    this._cleanupNav = undefined;\n    this._navOptions = undefined;\n  }\n\n  private _setupClickDelegation(root: ShadowRoot): void {\n    const handler = (e: Event) => {\n      const link = (e.target as HTMLElement).closest<HTMLAnchorElement>('a');\n      if (!link) return;\n      const href = link.getAttribute('href');\n      if (!href) return;\n\n      if (!isSafeLayoutUrl(href) || /^https?:/i.test(href) || href.startsWith('#')) {\n        return;\n      }\n\n      e.preventDefault();\n      e.stopImmediatePropagation();\n\n      const isLangSwitch = link.classList.contains('lang-switch');\n      if (isLangSwitch) {\n        this._replaceTo(href);\n      } else {\n        this._navigateTo(href);\n      }\n    };\n    root.addEventListener('click', handler);\n    const prev = this._cleanupNav;\n    this._cleanupNav = () => {\n      root.removeEventListener('click', handler);\n      prev?.();\n    };\n  }\n\n  private _setupNavigationApi(): void {\n    const nav = (globalThis as typeof globalThis & { navigation?: NavigationLike }).navigation;\n    if (!nav) return;\n\n    const onNav: EventListener = (event) => {\n      const e = event as NavigationNavigateEvent;\n      if (!e.canIntercept || e.hashChange || e.downloadRequest) return;\n\n      const url = new URL(e.destination.url);\n      if (url.origin !== location.origin) return;\n\n      e.intercept({\n        handler: () => this._navigateNow(url.pathname),\n      });\n    };\n\n    try {\n      nav.addEventListener('navigate', onNav);\n      const prev = this._cleanupNav;\n      this._cleanupNav = () => {\n        try {\n          nav.removeEventListener('navigate', onNav);\n        } catch { /* */ }\n        prev?.();\n      };\n    } catch {\n      // Navigation API interception is optional; fall back to popstate routing.\n    }\n  }\n\n  private _setupPopState(): void {\n    const handler = () => {\n      this._navigateNow(location.pathname);\n    };\n    globalThis.addEventListener('popstate', handler);\n    const prev = this._cleanupNav;\n    this._cleanupNav = () => {\n      globalThis.removeEventListener('popstate', handler);\n      prev?.();\n    };\n  }\n\n  private _navigateTo(href: string): void {\n    const url = new URL(href, location.origin);\n    if (url.origin !== location.origin) {\n      location.href = href;\n      return;\n    }\n\n    history.pushState(null, '', url.pathname + url.search + url.hash);\n    this._navigateNow(url.pathname);\n  }\n\n  private _replaceTo(href: string): void {\n    const url = new URL(href, location.origin);\n    if (url.origin !== location.origin) return;\n\n    history.replaceState(null, '', url.pathname + url.search + url.hash);\n    this._navigateNow(url.pathname);\n  }\n\n  private _navigateNow(pathname: string): void {\n    const locale = detectLocale(pathname, this._locales, this._defaultLocale);\n    this.setAttribute('current-path', pathname);\n    this.setAttribute('locale', locale);\n\n    const opts = this._navOptions;\n    if (!opts) return;\n\n    // Update lang-switch immediately (before async fetch)\n    if (this.shadowRoot) {\n      this._updateSwitch(this.shadowRoot);\n    }\n\n    opts.contentLoader(pathname, locale).then(() => {\n      if (this.shadowRoot) {\n        this._updateSwitch(this.shadowRoot);\n      }\n      opts.onAfterSwap?.(pathname, locale);\n    }).catch((err) => {\n      log.warn('content load failed:', err);\n      location.reload();\n    });\n  }\n\n  private _updateSwitch(shadowRoot: ShadowRoot): void {\n    const link = shadowRoot.querySelector('.lang-switch') as HTMLAnchorElement | null;\n    if (!link) return;\n    const pathWithoutLocale = this._currentPathWithoutLocale;\n    const currentLocale = this._currentLocale;\n    link.textContent = switchLabel(currentLocale);\n    link.setAttribute('href', switchPath(pathWithoutLocale, currentLocale, this._locales));\n  }\n\n  private async _loadContent(path: string, locale: string): Promise<void> {\n    try {\n      const resp = await fetch(path);\n      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);\n      const html = await resp.text();\n      const parsed = new DOMParser().parseFromString(html, 'text/html');\n      const tmp = parsed.body;\n      const newLayout = this._findOpenLayout(tmp);\n      if (!newLayout) throw new Error('No open-layout found');\n\n      document.documentElement.lang = parsed.documentElement.lang || locale;\n      if (parsed.title) document.title = parsed.title;\n      this._syncHeadElement(parsed, 'meta[name=\"description\"]');\n      this._syncHeadElement(parsed, 'link[rel=\"canonical\"]');\n      this._syncHeadElements(parsed, 'link[rel=\"alternate\"][hreflang]');\n\n      this._syncLayoutAttributes(newLayout, locale);\n      this._replaceShadowRootFromLayout(newLayout);\n\n      // DOMParser nodes belong to a different document. adoptNode()\n      // transfers ownership so appendChild works without errors.\n      while (this.firstChild) this.removeChild(this.firstChild);\n      const children = Array.from(newLayout.children).filter((child) =>\n        !this._isShadowTemplate(child)\n      );\n      for (const child of children) {\n        const adopted = document.adoptNode(child);\n        if (adopted instanceof Element) {\n          this._activateDeclarativeShadowRoots(adopted);\n        }\n        this.appendChild(adopted);\n      }\n\n      // Propagate theme to newly inserted components.\n      const currentTheme = this.getAttribute('data-theme') ||\n        document.documentElement?.dataset?.theme;\n      if (currentTheme) {\n        this._propagateTheme(currentTheme);\n        requestAnimationFrame(() => this._propagateTheme(currentTheme));\n      }\n\n      globalThis.scrollTo({ top: 0, behavior: 'smooth' });\n    } catch (e) {\n      log.warn('SPA navigation failed, reloading:', e);\n      globalThis.location.reload();\n    }\n  }\n\n  private _syncHeadElement(parsed: Document, selector: string): void {\n    const incoming = parsed.head.querySelector(selector);\n    const current = document.head.querySelector(selector);\n    if (!incoming) {\n      current?.remove();\n      return;\n    }\n    const cloned = document.adoptNode(incoming.cloneNode(true));\n    if (current) current.replaceWith(cloned);\n    else document.head.appendChild(cloned);\n  }\n\n  private _syncHeadElements(parsed: Document, selector: string): void {\n    document.head.querySelectorAll(selector).forEach((el) => el.remove());\n    parsed.head.querySelectorAll(selector).forEach((el) => {\n      document.head.appendChild(document.adoptNode(el.cloneNode(true)));\n    });\n  }\n\n  private _updateActiveNav(): void {\n    if (!this.shadowRoot) return;\n    const cp = this._currentPath();\n    const links = this.shadowRoot.querySelectorAll(\n      '.docs-sidebar a[data-nav], .header-nav a[data-nav]',\n    );\n    links.forEach((a) => {\n      const nav = a.getAttribute('data-nav');\n      const isActive = nav === cp;\n      a.classList.toggle('active', isActive);\n      if (isActive) a.setAttribute('aria-current', 'page');\n      else a.removeAttribute('aria-current');\n    });\n  }\n\n  // --- Utilities ---\n\n  private _esc = escapeHtml;\n  private _escAttr = escapeAttr;\n}\n\nexport default OpenLayout;\n\n// Guard: idempotent across SSR paths\nif (typeof customElements !== 'undefined' && !customElements.get(tagName)) {\n  customElements.define(tagName, OpenLayout);\n}\n"],"names":[],"mappings":"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"}