@veluai/velu 0.1.0

package/runtime/velu-ui/lib/prism-loader.js

@@ -0,0 +1,74 @@
+import { Prism } from 'prism-react-renderer';
+import { LANG_DEPS, LANG_ALIASES, PRISM_LOADERS } from './prism-langs.js';
+
+/**
+ * Lazy prism language loader — fetches grammars on demand based on the
+ * actual `language` props rendered, never bundles all 297 upfront.
+ *
+ *  - `Prism` is exposed on globalThis so prismjs/components/*.js files
+ *    (which look it up globally) find it when they register grammars.
+ *  - `ensureLang(id)` walks the LANG_DEPS map to load every prerequisite
+ *    in correct order before the target, then resolves once everything is
+ *    registered. Subsequent calls for the same id share the cached promise.
+ *  - Aliases (e.g. `rb` → `ruby`) are resolved up front via LANG_ALIASES.
+ *  - `hasLang(id)` is a sync check used by render to gate highlighting:
+ *    true once `Prism.languages[id]` exists OR the bundled fallback covers
+ *    it. The CodeBlock kicks off ensureLang in an effect, then re-renders
+ *    once `hasLang` flips true.
+ */
+
+if (typeof globalThis !== 'undefined' && !globalThis.Prism) {
+  globalThis.Prism = Prism;
+} else if (typeof window !== 'undefined' && !window.Prism) {
+  window.Prism = Prism;
+}
+
+const loadPromises = new Map();
+
+export function resolveLang(idOrAlias) {
+  if (!idOrAlias) return null;
+  if (LANG_ALIASES[idOrAlias]) return LANG_ALIASES[idOrAlias];
+  return idOrAlias;
+}
+
+export function hasLang(id) {
+  if (!id) return true;
+  const canonical = resolveLang(id);
+  return Boolean(Prism.languages[canonical]);
+}
+
+async function loadOne(id) {
+  const loader = PRISM_LOADERS[id];
+  if (!loader) return;
+  try {
+    await loader();
+  } catch (e) {
+    console.warn(`[velu-ui] failed to load prism lang: ${id}`, e?.message ?? e);
+  }
+}
+
+export function ensureLang(idOrAlias) {
+  const id = resolveLang(idOrAlias);
+  if (!id) return Promise.resolve();
+  if (Prism.languages[id]) return Promise.resolve();
+  let p = loadPromises.get(id);
+  if (p) return p;
+
+  p = (async () => {
+    // Load all dependencies first (recursive, sequential at each level).
+    const deps = LANG_DEPS[id] ?? [];
+    for (const dep of deps) {
+      const depId = resolveLang(dep);
+      if (depId && !Prism.languages[depId]) {
+        await ensureLang(depId);
+      }
+    }
+    // Load the target language itself.
+    if (!Prism.languages[id]) {
+      await loadOne(id);
+    }
+  })();
+
+  loadPromises.set(id, p);
+  return p;
+}

package/runtime/velu-ui/lib/resolveIcon.jsx

@@ -0,0 +1,29 @@
+import React from 'react';
+import { icons as lucideIcons } from 'lucide-react';
+
+/**
+ * Resolve an icon prop to a renderable node — shared by Callout, Sidebar, etc.
+ *
+ * lucide convention: an icon's id is kebab-case; its component / `icons`-map
+ * key is the PascalCase form. So "triangle-alert" → "TriangleAlert" →
+ * lucideIcons.TriangleAlert.
+ *
+ * - string  → resolved as a lucide id (content-driven; serializable)
+ * - node    → returned as-is (power users / custom elements)
+ * - nullish or unknown id → null
+ *
+ * `iconProps` is spread onto the resolved lucide component (e.g. size,
+ * strokeWidth). Callers that style the icon via a CSS wrapper (Sidebar) can
+ * omit it; callers that size inline (Callout) pass it.
+ */
+export default function resolveIcon(icon, iconProps = {}) {
+  if (icon == null) return null;
+  if (typeof icon !== 'string') return icon;
+  const key = icon
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+    .join('');
+  const Cmp = lucideIcons[key];
+  return Cmp ? <Cmp {...iconProps} /> : null;
+}

package/runtime/velu-ui/lib/scrollIntoNearestView.js

@@ -0,0 +1,66 @@
+/**
+ * scrollIntoNearestView — programmatic "scroll so this element is visible"
+ * that reliably honours `scroll-padding-top` / `scroll-padding-bottom` on
+ * the nearest scrollable ancestor.
+ *
+ * Why not `el.scrollIntoView({ block: 'nearest' })`?
+ *   Both Chrome and Firefox implement that opt sporadically with respect
+ *   to scroll-padding-* — sometimes treating the full scrollport as the
+ *   target instead of the scroll-padded inset. That matters here because
+ *   docs sidebars + TOC live behind a footer that visually eclipses their
+ *   bottoms; we use `scroll-padding-bottom` to mark that band as off-limits.
+ *   Computing the delta manually guarantees we always pull the element
+ *   above the footer's eclipsed band, on every engine.
+ *
+ * The optional `padBottom` (and `padTop`) override the values read from
+ * the parent's computed style. This is needed when the visible region's
+ * bottom is driven by a *live* DOM measurement (e.g. a fixed/sticky
+ * footer's getBoundingClientRect) — that value tracks the user's actual
+ * scroll position synchronously, whereas CSS scroll-padding-* driven by
+ * React state lags behind committed renders and can leave the active
+ * item flush against the footer on fast scrolls.
+ *
+ * Behaviour:
+ *   - finds the nearest ancestor with `overflow-y: auto | scroll`
+ *   - does nothing if `el` is already inside that ancestor's
+ *     (effective) scroll-padded visible region — no jitter when the
+ *     active item is already on-screen
+ *   - otherwise scrolls the ancestor by the minimum delta (matching the
+ *     `block: 'nearest'` contract)
+ *
+ * @param {HTMLElement} el target element
+ * @param {{ padTop?: number, padBottom?: number }} [opts]
+ */
+export default function scrollIntoNearestView(el, opts = {}) {
+  if (!el) return;
+  let parent = el.parentElement;
+  while (parent && parent !== document.body) {
+    const overflowY = getComputedStyle(parent).overflowY;
+    if (overflowY === 'auto' || overflowY === 'scroll') break;
+    parent = parent.parentElement;
+  }
+  if (!parent || parent === document.body) return;
+
+  const elRect = el.getBoundingClientRect();
+  const parentRect = parent.getBoundingClientRect();
+  const cs = getComputedStyle(parent);
+  const padTop = opts.padTop ?? (parseFloat(cs.scrollPaddingTop) || 0);
+  const padBottom =
+    opts.padBottom ?? (parseFloat(cs.scrollPaddingBottom) || 0);
+
+  const visibleTop = parentRect.top + padTop;
+  const visibleBottom = parentRect.bottom - padBottom;
+
+  let delta = 0;
+  if (elRect.top < visibleTop) delta = elRect.top - visibleTop;
+  else if (elRect.bottom > visibleBottom) delta = elRect.bottom - visibleBottom;
+  if (delta === 0) return;
+
+  // Direct `scrollTop` assignment (not scrollBy/scrollTo with options):
+  //   - universally supported (no behavior:'instant' compat concerns),
+  //   - synchronous,
+  //   - can't be cancelled by a subsequent scroll event,
+  // which matters because we're often called many times in quick
+  // succession from scroll-spy updates while the user is mid-scroll.
+  parent.scrollTop = parent.scrollTop + delta;
+}

package/runtime/velu-ui/mdx-components.jsx

@@ -0,0 +1,85 @@
+import React from 'react';
+import Callout from './components/Callout.jsx';
+import Card, { CardGroup } from './components/Card.jsx';
+import Accordion, { AccordionGroup } from './components/Accordion.jsx';
+import Columns from './components/Columns.jsx';
+import Field from './components/Field.jsx';
+import Prompt from './components/Prompt.jsx';
+import Steps, { Step } from './components/Steps.jsx';
+import Tree, { Folder, File } from './components/Tree.jsx';
+import Image from './components/Image.jsx';
+import CodeBlock, { CodeGroup } from './components/CodeBlock.jsx';
+import MethodBadge from './components/MethodBadge.jsx';
+import ApiPath from './components/ApiPath.jsx';
+import TryItBar from './components/TryItBar.jsx';
+import ApiField from './components/ApiField.jsx';
+import ApiClient from './components/ApiClient.jsx';
+import ApiSidebar from './components/ApiSidebar.jsx';
+
+/**
+ * defaultMdxComponents — the registry the MDXProvider consumes.
+ *
+ * Two kinds of entries:
+ *
+ *   1. Lowercase keys ('pre', 'h1', …) override the HTML tags that
+ *      Markdown produces. We use these to upgrade plain ``` fenced
+ *      code blocks into our CodeBlock component, etc.
+ *
+ *   2. Capitalised keys ('Callout', 'Card', …) match the exact tag
+ *      names authors write in their .mdx, e.g. `<Callout type="warn">`.
+ *      MDX looks up the name in this map and renders our component
+ *      instead of treating it as an unknown HTML element.
+ *
+ * Tag-name → component is the only contract here. SSR-safe by
+ * construction: identical map on server + client → identical render.
+ */
+
+/* `pre > code` is how Markdown renders ``` blocks. We pull the
+   language out of the code-element's className ("language-js" → "js")
+   and forward children verbatim to CodeBlock. */
+function PreOverride({ children }) {
+  const child = React.Children.only(children);
+  const className = child?.props?.className || '';
+  const m = /language-(\S+)/.exec(className);
+  const language = m ? m[1] : undefined;
+  const code =
+    typeof child?.props?.children === 'string'
+      ? child.props.children.replace(/\n$/, '')
+      : child?.props?.children;
+  return (
+    <CodeBlock language={language}>
+      {code}
+    </CodeBlock>
+  );
+}
+
+export const defaultMdxComponents = {
+  /* HTML-tag overrides (lowercase keys). */
+  pre: PreOverride,
+
+  /* Authored component tags (capitalised keys). */
+  Callout,
+  Card,
+  CardGroup,
+  Accordion,
+  AccordionGroup,
+  Columns,
+  Field,
+  Prompt,
+  Steps,
+  Step,
+  Tree,
+  Folder,
+  File,
+  Image,
+  CodeBlock,
+  CodeGroup,
+  MethodBadge,
+  ApiPath,
+  TryItBar,
+  ApiField,
+  ApiClient,
+  ApiSidebar,
+};
+
+export default defaultMdxComponents;

package/runtime/velu-ui/primitives/Cluster.jsx

@@ -0,0 +1,49 @@
+import React from 'react';
+
+/**
+ * Cluster — Every Layout primitive. Inline group that wraps onto
+ * multiple lines when it runs out of horizontal room. Use for chips,
+ * tags, action button rows, nav links, badge groups — any horizontal
+ * row of inline-ish items that should break gracefully.
+ *
+ * Like Stack, this is pure inline styles (no CSS file needed since
+ * there's no `> *` selector) — React-native, SSR-safe, tokenized.
+ * Mirrors the Every Layout custom element but as React with the same
+ * three knobs.
+ *
+ *  - `space`   gap between items (default --s1)
+ *  - `justify` justify-content (default flex-start)
+ *  - `align`   align-items (default flex-start)
+ *  - `as`      element tag (default 'div')
+ *
+ * @param {object} props
+ * @param {React.ElementType} [props.as='div']
+ * @param {string} [props.space='var(--s1)']
+ * @param {string} [props.justify='flex-start']
+ * @param {string} [props.align='flex-start']
+ */
+export default function Cluster({
+  as: Tag = 'div',
+  space = 'var(--s1)',
+  justify = 'flex-start',
+  align = 'flex-start',
+  style,
+  children,
+  ...rest
+}) {
+  return (
+    <Tag
+      style={{
+        display: 'flex',
+        flexWrap: 'wrap',
+        justifyContent: justify,
+        alignItems: align,
+        gap: space,
+        ...style,
+      }}
+      {...rest}
+    >
+      {children}
+    </Tag>
+  );
+}

package/runtime/velu-ui/primitives/Stack.jsx

@@ -0,0 +1,63 @@
+import React from 'react';
+
+/**
+ * Stack — vertical rhythm primitive (Every Layout), React-native.
+ *
+ * Spacing is delegated to flex `gap`, set inline per instance. This is
+ * leak-free and nesting-independent BY CONSTRUCTION: `gap` is resolved on the
+ * container element itself, never inherited by or computed on children — so a
+ * nested Stack's spacing cannot bleed into the gap its parent puts around it.
+ *
+ * `space` is any CSS length (defaulting to the --s1 modular-scale token).
+ *
+ * NOTE: `recursive` (rhythm at *every* nesting depth) is intentionally not
+ * supported here — `gap` only spaces direct children. That job belongs to a
+ * future Prose/Flow primitive (Markdown iteration), not to Stack.
+ *
+ * @param {object} props
+ * @param {React.ElementType} [props.as='div'] element/component to render as
+ * @param {string} [props.space='var(--s1)'] gap between items (CSS length/token)
+ * @param {number|null} [props.splitAfter=null] 1-based child index; everything
+ *        after it is pushed to the bottom (margin-block-end:auto on that child)
+ */
+const Stack = React.forwardRef(function Stack(
+  {
+    as: Tag = 'div',
+    space = 'var(--s1)',
+    splitAfter = null,
+    style,
+    children,
+    ...rest
+  },
+  ref
+) {
+  let kids = children;
+  if (splitAfter) {
+    kids = React.Children.map(children, (child, i) =>
+      i === splitAfter - 1 && React.isValidElement(child)
+        ? React.cloneElement(child, {
+            style: { ...child.props.style, marginBlockEnd: 'auto' },
+          })
+        : child
+    );
+  }
+
+  return (
+    <Tag
+      ref={ref}
+      style={{
+        display: 'flex',
+        flexDirection: 'column',
+        justifyContent: 'flex-start',
+        gap: space,
+        ...(splitAfter ? { blockSize: '100%' } : null),
+        ...style,
+      }}
+      {...rest}
+    >
+      {kids}
+    </Tag>
+  );
+});
+
+export default Stack;

package/runtime/velu-ui/primitives/Switcher.jsx

@@ -0,0 +1,57 @@
+import React from 'react';
+
+/**
+ * Switcher — Every Layout primitive. Row ↔ column at a container-width point,
+ * with NO media queries: flex-wrap + flex-basis: calc((threshold - 100%)*999).
+ * All-or-nothing (never multi-row wrap).
+ *
+ * Two ways to set the flip point:
+ *  - `threshold`: the container width at which it flips — the raw Every
+ *    Layout knob (default --measure token).
+ *  - `min`: a per-ITEM minimum width (more intuitive). The Switcher knows its
+ *    child count, so it derives the container threshold as
+ *        N * min + (N - 1) * space
+ *    → the row collapses to a full vertical stack the instant any one item
+ *    would fall below `min`. `min` takes precedence over `threshold`.
+ *
+ * Other props:
+ *  - `space` gap between items (default --s1 token)
+ *  - `limit` hard cap of items in a row; beyond it ALL items stack
+ *  - `as`    element to render (semantics; default 'div')
+ *
+ * React-native + SSR-safe + tokenized (vs. the browser-only web component
+ * which injects a runtime <style>). Needs its own CSS (styles `> *`).
+ */
+export default function Switcher({
+  as: Tag = 'div',
+  space = 'var(--s1)',
+  threshold = 'var(--measure)',
+  min,
+  limit,
+  className = '',
+  style,
+  children,
+  ...rest
+}) {
+  const count = React.Children.count(children);
+  const flip =
+    min != null
+      ? `calc((${min} * ${count}) + (${space} * ${Math.max(0, count - 1)}))`
+      : threshold;
+  const exceeded = typeof limit === 'number' && count > limit;
+
+  return (
+    <Tag
+      className={`velu-switcher ${className}`.trim()}
+      data-limit-exceeded={exceeded ? '' : undefined}
+      style={{
+        '--switcher-space': space,
+        '--switcher-threshold': flip,
+        ...style,
+      }}
+      {...rest}
+    >
+      {children}
+    </Tag>
+  );
+}

package/runtime/velu-ui/primitives/stack.css

@@ -0,0 +1,3 @@
+/* DEPRECATED — unused. Stack is now self-contained (inline flex `gap`);
+   it needs no CSS. Safe to delete this file. Kept only because shell
+   deletes are disabled in this session. Not imported anywhere. */

package/runtime/velu-ui/primitives/switcher.css

@@ -0,0 +1,25 @@
+/* Switcher — Every Layout. All values are tokens (passed via the
+   --switcher-* custom properties set inline by Switcher.jsx). Needs the
+   `> *` selector, so it has CSS unlike Stack. */
+
+.velu-switcher {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--switcher-space, var(--s1));
+}
+
+/* The trick: when the row's width drops below `threshold`, the negative
+   product flips flex-basis huge→huge-negative, forcing items onto their
+   own lines (vertical). No media query. */
+.velu-switcher > * {
+  flex-grow: 1;
+  flex-basis: calc(
+    (var(--switcher-threshold, var(--measure)) - 100%) * 999
+  );
+}
+
+/* `limit` exceeded: force every item full-width (always vertical). Set as a
+   static attribute from React's child count — no runtime :nth-last-child. */
+.velu-switcher[data-limit-exceeded] > * {
+  flex-basis: 100%;
+}

package/runtime/velu-ui/styles.css

@@ -0,0 +1,43 @@
+/* Aggregate stylesheet for velu-ui. Consumers import this once.
+
+   Tailwind v4 first (theme/preflight/utilities — all in @layer).
+   base.css is intentionally UNLAYERED, so it wins over Tailwind's
+   preflight `base` layer — our fluid type/measure beat Tailwind's reset
+   by cascade-layer precedence (unlayered > layered). */
+@import 'tailwindcss';
+
+/* Map Tailwind's `dark:` variant onto our [data-theme="dark"] attribute
+   (instead of Tailwind's default prefers-color-scheme). */
+@custom-variant dark (&:where([data-theme="dark"], [data-theme="dark"] *));
+
+/* Tailwind's auto source-detection is rooted at the Vite root (velu-cli)
+   and ignores node_modules — velu-ui is reached via a workspace symlink
+   there, so its component classes would NOT be scanned. This @source is
+   relative to THIS file (packages/velu-ui/src/styles.css); "." == the
+   velu-ui src tree, so Tailwind also scans velu-ui components. */
+@source ".";
+
+@import './base.css';
+@import './primitives/switcher.css';
+@import './components/sidebar.css';
+@import './components/nav-select.css';
+@import './components/accordion.css';
+@import './components/card.css';
+@import './components/image.css';
+@import './components/code-block.css';
+@import './components/field.css';
+@import './components/prompt.css';
+@import './components/steps.css';
+@import './components/tree.css';
+@import './components/api.css';
+@import './components/ask-bar.css';
+@import './components/chatbot.css';
+@import './components/page-feedback.css';
+@import './components/page-nav.css';
+@import './components/page-footer.css';
+@import './components/powered-by.css';
+@import './components/page-header.css';
+@import './components/theme-toggle.css';
+@import './components/docs-layout.css';
+@import './components/toc-bar.css';
+@import './components/search.css';

package/runtime/velu-ui/tokens.css

@@ -0,0 +1,4 @@
+/* DEPRECATED — superseded by base.css (modular scale moved there, ratio
+   changed 1.5 → 1.25, --s-6 added, plus fonts/type/measure). Not imported
+   anywhere. Safe to delete; kept only because shell deletes are disabled
+   in this session. Do NOT re-import — two scale definitions = not DRY. */

package/schema/velu.schema.json

@@ -0,0 +1,167 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://veludocs.com/velu.schema.json",
+  "title": "Velu project configuration",
+  "description": "Configuration for a Velu documentation project (velu.json). This schema is defined internally during iteration; it will be hosted at the $id URL so editors can validate + autocomplete velu.json files.",
+  "type": "object",
+  "required": ["name"],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "URL of this JSON Schema, enabling editor validation + autocomplete."
+    },
+    "name": {
+      "type": "string",
+      "description": "Project name; usually the folder name it's contained in.",
+      "minLength": 1
+    },
+    "colors": {
+      "type": "object",
+      "description": "Accent colors. Maps onto the --accent-color token in base.css.",
+      "additionalProperties": false,
+      "required": ["primary"],
+      "properties": {
+        "primary": {
+          "type": "string",
+          "description": "The accent color used across the UI (--accent-color)."
+        },
+        "light": {
+          "type": "string",
+          "description": "Light-mode accent override. Defaults to `primary`."
+        },
+        "dark": {
+          "type": "string",
+          "description": "Dark-mode accent override. Defaults to `primary`."
+        }
+      }
+    },
+    "favicon": {
+      "type": "string",
+      "description": "Path to the favicon, relative to the project root."
+    },
+    "font": {
+      "type": "object",
+      "description": "Typography. Maps onto the --font-sans token in base.css.",
+      "additionalProperties": false,
+      "required": ["family"],
+      "properties": {
+        "family": {
+          "type": "string",
+          "description": "Google Font family to use (--font-sans)."
+        }
+      }
+    },
+    "navigation": {
+      "$ref": "#/$defs/navContainer",
+      "description": "Site navigation. Mintlify-compatible: products > versions > languages > tabs > groups > pages. Switchable axes (product/version/language) become URL path prefixes; the default value of each is unprefixed. Dropdowns are intentionally unsupported."
+    }
+  },
+  "$defs": {
+    "navContainer": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "A navigation container. Higher-precedence keys nest the lower ones (products contain versions contain languages contain tabs contain groups/pages).",
+      "properties": {
+        "products": { "type": "array", "items": { "$ref": "#/$defs/product" } },
+        "versions": { "type": "array", "items": { "$ref": "#/$defs/version" } },
+        "languages": { "type": "array", "items": { "$ref": "#/$defs/language" } },
+        "tabs": { "type": "array", "items": { "$ref": "#/$defs/tab" } },
+        "anchors": { "type": "array", "items": { "$ref": "#/$defs/anchor" } },
+        "groups": { "type": "array", "items": { "$ref": "#/$defs/group" } },
+        "pages": { "$ref": "#/$defs/pages" }
+      }
+    },
+    "pages": {
+      "type": "array",
+      "description": "Ordered list of page paths (no extension, relative to the project root) and/or nested groups.",
+      "items": {
+        "oneOf": [
+          { "type": "string" },
+          { "$ref": "#/$defs/group" }
+        ]
+      }
+    },
+    "group": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["group"],
+      "properties": {
+        "group": { "type": "string", "description": "Sidebar section heading." },
+        "icon": { "type": "string", "description": "lucide icon id." },
+        "expanded": { "type": "boolean", "description": "Start expanded." },
+        "root": { "type": "string", "description": "Landing page path for the group." },
+        "pages": { "$ref": "#/$defs/pages" }
+      }
+    },
+    "tab": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["tab"],
+      "properties": {
+        "tab": { "type": "string", "description": "Tab label (top nav)." },
+        "icon": { "type": "string" },
+        "href": { "type": "string", "description": "External/override link instead of in-site pages." },
+        "anchors": { "type": "array", "items": { "$ref": "#/$defs/anchor" } },
+        "groups": { "type": "array", "items": { "$ref": "#/$defs/group" } },
+        "pages": { "$ref": "#/$defs/pages" }
+      }
+    },
+    "anchor": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["anchor", "href"],
+      "properties": {
+        "anchor": { "type": "string", "description": "Anchor label (pinned sidebar link)." },
+        "icon": { "type": "string" },
+        "href": { "type": "string" },
+        "color": { "type": "string" }
+      }
+    },
+    "product": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["product"],
+      "properties": {
+        "product": { "type": "string", "description": "Product id (used for the URL slug)." },
+        "name": { "type": "string", "description": "Display name; defaults to `product`." },
+        "icon": { "type": "string" },
+        "color": { "type": "string" },
+        "default": { "type": "boolean", "description": "The default product is unprefixed in URLs." },
+        "versions": { "type": "array", "items": { "$ref": "#/$defs/version" } },
+        "languages": { "type": "array", "items": { "$ref": "#/$defs/language" } },
+        "tabs": { "type": "array", "items": { "$ref": "#/$defs/tab" } },
+        "anchors": { "type": "array", "items": { "$ref": "#/$defs/anchor" } },
+        "groups": { "type": "array", "items": { "$ref": "#/$defs/group" } },
+        "pages": { "$ref": "#/$defs/pages" }
+      }
+    },
+    "version": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["version"],
+      "properties": {
+        "version": { "type": "string", "description": "Version label (used for the URL slug)." },
+        "default": { "type": "boolean", "description": "The default version is unprefixed in URLs." },
+        "languages": { "type": "array", "items": { "$ref": "#/$defs/language" } },
+        "tabs": { "type": "array", "items": { "$ref": "#/$defs/tab" } },
+        "anchors": { "type": "array", "items": { "$ref": "#/$defs/anchor" } },
+        "groups": { "type": "array", "items": { "$ref": "#/$defs/group" } },
+        "pages": { "$ref": "#/$defs/pages" }
+      }
+    },
+    "language": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["language"],
+      "properties": {
+        "language": { "type": "string", "description": "Language code (used for the URL slug)." },
+        "default": { "type": "boolean", "description": "The default language is unprefixed in URLs." },
+        "tabs": { "type": "array", "items": { "$ref": "#/$defs/tab" } },
+        "anchors": { "type": "array", "items": { "$ref": "#/$defs/anchor" } },
+        "groups": { "type": "array", "items": { "$ref": "#/$defs/group" } },
+        "pages": { "$ref": "#/$defs/pages" }
+      }
+    }
+  }
+}