diff --git a/.claude/skills/docusaurus-config/README.md b/.claude/skills/docusaurus-config/README.md
new file mode 100644
index 000000000..53aa1b61a
--- /dev/null
+++ b/.claude/skills/docusaurus-config/README.md
@@ -0,0 +1,14 @@
+# Docusaurus Config
+
+Work with, validate, and modify Docusaurus project configuration
+
+## Structure
+
+- `SKILL.md` - Main skill instructions
+- `references/` - Detailed documentation loaded as needed
+- `scripts/` - Executable code for deterministic operations
+- `assets/` - Templates, images, or other resources
+
+## Usage
+
+This skill is automatically discovered by Claude when relevant to the task.
diff --git a/.claude/skills/docusaurus-config/SKILL.md b/.claude/skills/docusaurus-config/SKILL.md
new file mode 100644
index 000000000..2695108de
--- /dev/null
+++ b/.claude/skills/docusaurus-config/SKILL.md
@@ -0,0 +1,60 @@
+---
+name: docusaurus-config
+# IMPORTANT: Keep description on ONE line for Claude Code compatibility
+# prettier-ignore
+description: Use when working with docusaurus.config.js/ts files to validate or modify Docusaurus configuration
+---
+
+# Docusaurus Config
+
+## Quick Start
+
+Configuration lives in `docusaurus.config.js` or `docusaurus.config.ts` at project root.
+
+```typescript
+import { Config } from "@docusaurus/types";
+
+const config: Config = {
+  title: "My Site", // Required
+  url: "https://example.com", // Required, no trailing /
+  baseUrl: "/", // Required, must start and end with /
+
+  favicon: "img/favicon.ico",
+  organizationName: "my-org",
+  projectName: "my-project",
+
+  presets: [
+    [
+      "@docusaurus/preset-classic",
+      {
+        /* options */
+      },
+    ],
+  ],
+  themeConfig: {
+    /* theme config */
+  },
+  customFields: {
+    /* unknown fields go here */
+  },
+};
+
+export default config;
+```
+
+## Core Principles
+
+- **Required**: `title`, `url`, `baseUrl` are mandatory
+- **Custom fields**: Unknown fields must use `customFields` object
+- **Validation**: `url` no trailing slash, `baseUrl` must be `/path/`
+- **Plugins/themes**: Use string or `[name, options]` array format
+
+## Common Tasks
+
+**Before editing**: Read current config to preserve format (JS/TS, ESM/CommonJS)
+
+**After editing**: Verify required fields, URL formats, and restart dev server
+
+## Reference Files
+
+See [references/detailed-guide.md](references/detailed-guide.md) for comprehensive examples
diff --git a/.claude/skills/docusaurus-config/references/detailed-guide.md b/.claude/skills/docusaurus-config/references/detailed-guide.md
new file mode 100644
index 000000000..c51dab234
--- /dev/null
+++ b/.claude/skills/docusaurus-config/references/detailed-guide.md
@@ -0,0 +1,318 @@
+# Docusaurus Configuration - Detailed Guide
+
+## Configuration File Structure
+
+Docusaurus configuration can be in multiple formats:
+
+### TypeScript (Recommended)
+
+```typescript
+import { Config } from "@docusaurus/types";
+import { themes as prismThemes } from "prism-react-renderer";
+
+const config: Config = {
+  // Configuration here
+};
+
+export default config;
+```
+
+### JavaScript (ESM)
+
+```javascript
+export default {
+  // Configuration here
+};
+```
+
+### JavaScript (CommonJS)
+
+```javascript
+module.exports = {
+  // Configuration here
+};
+```
+
+### Async Configuration
+
+```typescript
+export default async function createConfig(): Promise<Config> {
+  // Import ESM-only packages
+  const mdxMermaid = await import("mdx-mermaid");
+
+  return {
+    // Configuration here
+  };
+}
+```
+
+## Required Fields
+
+### title
+
+- Type: `string`
+- Required: Yes
+- Description: Site title for metadata and browser tabs
+
+### url
+
+- Type: `string`
+- Required: Yes
+- Format: Must not end with trailing slash
+- Example: `'https://example.com'`
+- Description: Full URL where site will be hosted
+
+### baseUrl
+
+- Type: `string`
+- Required: Yes
+- Format: Must start and end with `/`
+- Example: `'/'` or `'/docs/'`
+- Description: Path where site is served from
+
+## Common Optional Fields
+
+### Site Metadata
+
+- `tagline`: Short description of your site
+- `favicon`: Path to favicon (relative to static folder)
+- `organizationName`: GitHub org/user name (for deployment)
+- `projectName`: GitHub repo name (for deployment)
+
+### Deployment
+
+- `deploymentBranch`: Branch for deployment (default: 'gh-pages')
+- `trailingSlash`: Boolean or undefined for trailing slash handling
+
+### Internationalization
+
+```typescript
+i18n: {
+  defaultLocale: 'en',
+  locales: ['en', 'fr', 'es'],
+}
+```
+
+## Themes Configuration
+
+### Using Presets (Recommended)
+
+```typescript
+presets: [
+  [
+    '@docusaurus/preset-classic',
+    {
+      docs: {
+        sidebarPath: './sidebars.ts',
+        editUrl: 'https://github.com/user/repo/tree/main/',
+      },
+      blog: {
+        showReadingTime: true,
+      },
+      theme: {
+        customCss: './src/css/custom.css',
+      },
+    },
+  ],
+],
+```
+
+### Direct Theme Configuration
+
+```typescript
+themes: ['@docusaurus/theme-classic'],
+themeConfig: {
+  navbar: {
+    title: 'My Site',
+    logo: {
+      alt: 'My Site Logo',
+      src: 'img/logo.svg',
+    },
+    items: [
+      {to: '/docs/intro', label: 'Docs', position: 'left'},
+    ],
+  },
+  footer: {
+    style: 'dark',
+    links: [],
+    copyright: `Copyright © ${new Date().getFullYear()}`,
+  },
+},
+```
+
+## Plugins
+
+### Adding Plugins
+
+String format (no options):
+
+```typescript
+plugins: ['@docusaurus/plugin-debug'],
+```
+
+Array format (with options):
+
+```typescript
+plugins: [
+  [
+    '@docusaurus/plugin-content-docs',
+    {
+      id: 'community',
+      path: 'community',
+      routeBasePath: 'community',
+    },
+  ],
+],
+```
+
+### Shorthand Notation
+
+Official Docusaurus packages can use shorthand:
+
+- `'classic'` → `'@docusaurus/preset-classic'`
+- `'plugin-debug'` → `'@docusaurus/plugin-debug'`
+
+## Custom Fields
+
+Unknown fields cause validation errors. Use `customFields` for custom data:
+
+```typescript
+customFields: {
+  apiKey: process.env.API_KEY,
+  customValue: 'my-value',
+  complexData: {
+    nested: true,
+  },
+}
+```
+
+Access in components:
+
+```typescript
+import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
+
+function MyComponent() {
+  const {siteConfig} = useDocusaurusContext();
+  const apiKey = siteConfig.customFields.apiKey;
+
+  return <div>{apiKey}</div>;
+}
+```
+
+## Validation Checklist
+
+When modifying config, verify:
+
+1. **Required fields present**:
+
+   - ✅ `title` exists
+   - ✅ `url` exists and has no trailing slash
+   - ✅ `baseUrl` exists and starts/ends with `/`
+
+2. **Plugins and themes**:
+
+   - ✅ Use proper package names or shorthand
+   - ✅ Options passed as second array element
+   - ✅ No duplicate plugins
+
+3. **Custom data**:
+
+   - ✅ Unknown fields in `customFields` object
+   - ✅ No direct custom properties at root level
+
+4. **File format**:
+
+   - ✅ Valid JS/TS syntax
+   - ✅ Proper export (ESM or CommonJS)
+   - ✅ TypeScript types imported if using TS
+
+5. **Testing**:
+   - ✅ Restart dev server after changes
+   - ✅ Build succeeds: `npm run build`
+   - ✅ No console errors
+
+## Common Patterns
+
+### Multi-Instance Docs
+
+```typescript
+plugins: [
+  [
+    '@docusaurus/plugin-content-docs',
+    {
+      id: 'product',
+      path: 'product',
+      routeBasePath: 'product',
+    },
+  ],
+  [
+    '@docusaurus/plugin-content-docs',
+    {
+      id: 'community',
+      path: 'community',
+      routeBasePath: 'community',
+    },
+  ],
+],
+```
+
+### Environment Variables
+
+```typescript
+const config: Config = {
+  url: process.env.SITE_URL || "https://localhost:3000",
+  customFields: {
+    apiEndpoint: process.env.API_ENDPOINT,
+  },
+};
+```
+
+### Babel Customization
+
+Create `babel.config.js`:
+
+```javascript
+module.exports = {
+  presets: [require.resolve("@docusaurus/babel/preset")],
+  plugins: [
+    // Your custom Babel plugins
+  ],
+};
+```
+
+## Troubleshooting
+
+### Common Errors
+
+**"url must not have a trailing slash"**
+
+- Fix: Change `url: 'https://example.com/'` to `url: 'https://example.com'`
+
+**"baseUrl must start and end with /"**
+
+- Fix: Change `baseUrl: 'docs'` to `baseUrl: '/docs/'`
+
+**"Unknown field 'myField'"**
+
+- Fix: Move to `customFields: { myField: 'value' }`
+
+**"Cannot find module '@docusaurus/types'"**
+
+- Fix: Run `npm install --save-dev @docusaurus/types`
+
+### Best Practices
+
+1. Use TypeScript for better autocomplete and type checking
+2. Always read existing config before modifying
+3. Preserve file format (don't convert ESM to CommonJS)
+4. Test locally before deploying
+5. Use environment variables for deployment-specific values
+6. Document custom fields with comments
+7. Keep config organized with clear sections
+
+## Additional Resources
+
+- [Official Configuration API](https://docusaurus.io/docs/api/docusaurus-config)
+- [Plugin Configuration](https://docusaurus.io/docs/using-plugins)
+- [Theme Configuration](https://docusaurus.io/docs/using-themes)
+- [Deployment Guide](https://docusaurus.io/docs/deployment)
diff --git a/.claude/skills/docusaurus-documentation/README.md b/.claude/skills/docusaurus-documentation/README.md
new file mode 100644
index 000000000..fde07c87b
--- /dev/null
+++ b/.claude/skills/docusaurus-documentation/README.md
@@ -0,0 +1,14 @@
+# Docusaurus Docs
+
+Look up information from the latest Docusaurus documentation at https://docusaurus.io/docs
+
+## Structure
+
+- `SKILL.md` - Main skill instructions
+- `references/` - Detailed documentation loaded as needed
+- `scripts/` - Executable code for deterministic operations
+- `assets/` - Templates, images, or other resources
+
+## Usage
+
+This skill is automatically discovered by Claude when relevant to the task.
diff --git a/.claude/skills/docusaurus-documentation/SKILL.md b/.claude/skills/docusaurus-documentation/SKILL.md
new file mode 100644
index 000000000..cb43622b0
--- /dev/null
+++ b/.claude/skills/docusaurus-documentation/SKILL.md
@@ -0,0 +1,72 @@
+---
+name: docusaurus-documentation
+# IMPORTANT: Keep description on ONE line for Claude Code compatibility
+# prettier-ignore
+description: Use when looking up information from the latest Docusaurus documentation at https://docusaurus.io/docs
+---
+
+# Docusaurus Docs
+
+## Quick Start
+
+When the user asks about Docusaurus features, configuration, or best practices, use the WebFetch tool to look up information from the official Docusaurus documentation.
+
+```typescript
+// Use WebFetch to access Docusaurus documentation
+WebFetch({
+  url: "https://docusaurus.io/docs/[topic]",
+  prompt: "What does this page say about [specific question]?",
+});
+```
+
+## Core Principles
+
+- Always use WebFetch to get the latest documentation from https://docusaurus.io/docs
+- Common documentation paths: /configuration, /api, /guides, /creating-pages, /markdown-features
+- Start with the main docs page if you're unsure of the exact path
+
+## Common Patterns
+
+### Looking Up Configuration Options
+
+When users ask about docusaurus.config.js settings, theming, or plugins:
+
+1. Use WebFetch with https://docusaurus.io/docs/api/docusaurus-config
+2. For specific plugins, check https://docusaurus.io/docs/api/plugins/[plugin-name]
+3. For theming, use https://docusaurus.io/docs/styling-layout
+
+### Finding Feature Documentation
+
+For markdown features, MDX, or content creation:
+
+- Markdown features: https://docusaurus.io/docs/markdown-features
+- MDX and React: https://docusaurus.io/docs/markdown-features/react
+- Docs organization: https://docusaurus.io/docs/create-doc
+
+## Reference Files
+
+For detailed documentation, see:
+
+- [references/](references/) - Cached documentation and guides
+
+## Notes
+
+- Docusaurus documentation is frequently updated; always fetch latest from https://docusaurus.io/docs
+- When uncertain about the exact URL path, start with the main docs page and search
+- For version-specific features, check the version selector on the docs site
+
+<!--
+PROGRESSIVE DISCLOSURE GUIDELINES:
+- Keep this file ~50 lines total (max ~150 lines)
+- Use 1-2 code blocks only (recommend 1)
+- Keep description <200 chars for Level 1 efficiency
+- Move detailed docs to references/ for Level 3 loading
+- This is Level 2 - quick reference ONLY, not a manual
+
+LLM WORKFLOW (when editing this file):
+1. Write/edit SKILL.md
+2. Format (if formatter available)
+3. Run: claude-skills-cli validate <path>
+4. If multi-line description warning: run claude-skills-cli doctor <path>
+5. Validate again to confirm
+-->
diff --git a/.claude/skills/docusaurus-migration/README.md b/.claude/skills/docusaurus-migration/README.md
new file mode 100644
index 000000000..7b0ebd6dc
--- /dev/null
+++ b/.claude/skills/docusaurus-migration/README.md
@@ -0,0 +1,14 @@
+# Docusaurus V2 To V3 Migration
+
+Assist with migrating Docusaurus projects from v2 to v3
+
+## Structure
+
+- `SKILL.md` - Main skill instructions
+- `references/` - Detailed documentation loaded as needed
+- `scripts/` - Executable code for deterministic operations
+- `assets/` - Templates, images, or other resources
+
+## Usage
+
+This skill is automatically discovered by Claude when relevant to the task.
diff --git a/.claude/skills/docusaurus-migration/SKILL.md b/.claude/skills/docusaurus-migration/SKILL.md
new file mode 100644
index 000000000..ce5afc77c
--- /dev/null
+++ b/.claude/skills/docusaurus-migration/SKILL.md
@@ -0,0 +1,53 @@
+---
+name: docusaurus-v2-to-v3-migration
+# IMPORTANT: Keep description on ONE line for Claude Code compatibility
+# prettier-ignore
+description: Use when migrating Docusaurus projects from v2 to v3
+---
+
+# Docusaurus V2 To V3 Migration
+
+## Quick Start
+
+```json
+{
+  "@docusaurus/core": "^3.0.0",
+  "@mdx-js/react": "^3.0.0",
+  "prism-react-renderer": "^2.1.0",
+  "react": "^18.2.0"
+}
+```
+
+## Core Principles
+
+- **MDX v1 → v3**: Main challenge - escape `{` and `<` characters or wrap in code blocks
+- **Node.js >=18.0**: Required for Docusaurus v3
+- **React 18**: Breaking changes may affect custom components
+
+## Migration Steps
+
+1. **Pre-check**: Run `npx docusaurus-mdx-checker` to identify MDX issues
+2. **Update deps**: Upgrade all @docusaurus packages, React, MDX, prism-react-renderer
+3. **Fix MDX**: Escape bare `{` `<` characters, convert GFM autolinks, use code fences
+4. **Update config**: Replace `@tsconfig/docusaurus` with `@docusaurus/tsconfig`, update Prism imports
+5. **Test**: Run `npm start` then `npm run build`
+
+## Reference Files
+
+- [breaking-changes.md](references/breaking-changes.md) - Complete migration guide with examples
+
+<!--
+PROGRESSIVE DISCLOSURE GUIDELINES:
+- Keep this file ~50 lines total (max ~150 lines)
+- Use 1-2 code blocks only (recommend 1)
+- Keep description <200 chars for Level 1 efficiency
+- Move detailed docs to references/ for Level 3 loading
+- This is Level 2 - quick reference ONLY, not a manual
+
+LLM WORKFLOW (when editing this file):
+1. Write/edit SKILL.md
+2. Format (if formatter available)
+3. Run: claude-skills-cli validate <path>
+4. If multi-line description warning: run claude-skills-cli doctor <path>
+5. Validate again to confirm
+-->
diff --git a/.claude/skills/docusaurus-migration/references/breaking-changes.md b/.claude/skills/docusaurus-migration/references/breaking-changes.md
new file mode 100644
index 000000000..fb90834aa
--- /dev/null
+++ b/.claude/skills/docusaurus-migration/references/breaking-changes.md
@@ -0,0 +1,395 @@
+# Docusaurus v2 to v3 Breaking Changes
+
+## Required Dependency Updates
+
+### Core Packages
+
+- `@docusaurus/core`: ^2.x.x → ^3.0.0
+- `@docusaurus/preset-classic`: ^2.x.x → ^3.0.0
+- `@mdx-js/react`: ^1.6.22 → ^3.0.0
+- `prism-react-renderer`: ^1.3.5 → ^2.1.0
+
+### Runtime Requirements
+
+- **Node.js**: >=16.14 → >=18.0
+- **React**: ^17.0.2 → ^18.2.0
+- **TypeScript**: ~4.7.4 → ~5.2.2
+
+### TypeScript Configuration
+
+Replace `@tsconfig/docusaurus` with `@docusaurus/tsconfig`:
+
+```json
+{
+  "extends": "@docusaurus/tsconfig",
+  "compilerOptions": {
+    // your custom options
+  }
+}
+```
+
+## MDX v1 to v3 Migration
+
+The transition from MDX v1 to MDX v3 is the main challenge in adopting Docusaurus v3.
+
+### Common MDX Issues
+
+#### Invalid `{` Characters
+
+**Problem**: Bare braces are now invalid in MDX unless part of JSX expressions.
+
+**Bad**:
+
+```md
+Use the {key} to access the value
+```
+
+**Good**:
+
+```md
+Use the `{key}` to access the value
+Use the \{key\} to access the value
+```
+
+#### Invalid `<` Characters
+
+**Problem**: Bare angle brackets are invalid unless part of HTML/JSX.
+
+**Bad**:
+
+```md
+If x < 5, then...
+```
+
+**Good**:
+
+```md
+If `x < 5`, then...
+If x \< 5, then...
+```
+
+#### GFM Autolinks Removed
+
+**Problem**: `<email@example.com>` and `<https://example.com>` no longer work.
+
+**Bad**:
+
+```md
+Contact us at <support@example.com>
+```
+
+**Good**:
+
+```md
+Contact us at [support@example.com](mailto:support@example.com)
+Visit [https://example.com](https://example.com)
+```
+
+#### Indented Code Blocks
+
+**Problem**: Indented code blocks (4 spaces) are no longer recognized.
+
+**Bad**:
+
+```md
+Example code:
+
+    const foo = 'bar';
+```
+
+**Good**:
+
+```md
+Example code:
+
+\`\`\`js
+const foo = 'bar';
+\`\`\`
+```
+
+#### Emphasis Adjacent to Spaces
+
+**Problem**: Emphasis marks next to spaces may not work as expected.
+
+**Bad**:
+
+```md
+This is _really _ important
+```
+
+**Good**:
+
+```md
+This is _really_ important
+```
+
+## Prism React Renderer Changes
+
+### Theme Import Syntax
+
+**Old (v1)**:
+
+```js
+const lightTheme = require("prism-react-renderer/themes/github");
+const darkTheme = require("prism-react-renderer/themes/dracula");
+```
+
+**New (v2)**:
+
+```js
+const { themes } = require("prism-react-renderer");
+const lightTheme = themes.github;
+const darkTheme = themes.dracula;
+```
+
+### Additional Languages
+
+Prism React Renderer v2 includes fewer languages by default. Add required languages:
+
+```js
+module.exports = {
+  themeConfig: {
+    prism: {
+      additionalLanguages: ["bash", "diff", "json"],
+    },
+  },
+};
+```
+
+## React 18 Migration
+
+### Automatic JSX Runtime
+
+React imports are no longer required in files using JSX:
+
+**Before**:
+
+```jsx
+import React from "react";
+
+export default function MyComponent() {
+  return <div>Hello</div>;
+}
+```
+
+**After**:
+
+```jsx
+// No React import needed
+export default function MyComponent() {
+  return <div>Hello</div>;
+}
+```
+
+### Hydration Changes
+
+React 18 has stricter hydration requirements. Ensure:
+
+- Server and client render the same content
+- No conditional rendering based on `typeof window`
+- Use `useEffect` for client-only code
+
+## Pre-Migration Checklist
+
+1. **Check Node.js version**: `node --version` (must be >=18.0)
+2. **Scan for MDX issues**: `npx docusaurus-mdx-checker`
+3. **Backup your project**: Commit all changes to git
+4. **Review dependencies**: Check for custom plugins that may need updates
+5. **Test in staging**: Don't upgrade production directly
+
+## Migration Steps
+
+### 1. Update package.json
+
+```json
+{
+  "dependencies": {
+    "@docusaurus/core": "^3.0.0",
+    "@docusaurus/preset-classic": "^3.0.0",
+    "@mdx-js/react": "^3.0.0",
+    "prism-react-renderer": "^2.1.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@docusaurus/tsconfig": "^3.0.0",
+    "@docusaurus/types": "^3.0.0",
+    "typescript": "~5.2.2"
+  },
+  "engines": {
+    "node": ">=18.0"
+  }
+}
+```
+
+### 2. Update TypeScript Config
+
+```json
+{
+  "extends": "@docusaurus/tsconfig",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@site/*": ["./*"]
+    }
+  }
+}
+```
+
+### 3. Install Dependencies
+
+```bash
+npm install
+```
+
+### 4. Fix MDX Files
+
+Run the checker and fix reported issues:
+
+```bash
+npx docusaurus-mdx-checker
+```
+
+Common fixes:
+
+- Wrap `{` and `<` in backticks or escape them
+- Convert GFM autolinks to standard Markdown links
+- Replace indented code blocks with fenced code blocks
+
+### 5. Update docusaurus.config.js
+
+Update Prism configuration:
+
+```js
+const { themes } = require("prism-react-renderer");
+
+module.exports = {
+  themeConfig: {
+    prism: {
+      theme: themes.github,
+      darkTheme: themes.dracula,
+      additionalLanguages: ["bash", "diff", "json"],
+    },
+  },
+};
+```
+
+### 6. Test Locally
+
+```bash
+npm start
+```
+
+Visit http://localhost:3000 and check:
+
+- All pages load without errors
+- MDX components render correctly
+- Code blocks display properly
+- Navigation works
+
+### 7. Production Build
+
+```bash
+npm run build
+```
+
+Fix any build errors before deploying.
+
+## Optional Improvements
+
+### Migrate to ESM
+
+Convert `docusaurus.config.js` to `docusaurus.config.mjs`:
+
+```js
+import { themes } from "prism-react-renderer";
+
+export default {
+  // config
+};
+```
+
+### Use TypeScript Config
+
+Rename to `docusaurus.config.ts`:
+
+```typescript
+import type { Config } from "@docusaurus/types";
+import { themes } from "prism-react-renderer";
+
+const config: Config = {
+  // config
+};
+
+export default config;
+```
+
+### Rename MD to MDX
+
+For files containing JSX, rename `.md` → `.mdx`:
+
+```bash
+# Example
+mv blog/my-post.md blog/my-post.mdx
+```
+
+### Update Math Packages
+
+If using math support:
+
+```json
+{
+  "remark-math": "^6.0.0",
+  "rehype-katex": "^7.0.0"
+}
+```
+
+## Troubleshooting
+
+### MDX Parse Errors
+
+Use the [MDX Playground](https://mdxjs.com/playground/) to debug:
+
+1. Enable "remark-gfm" plugin
+2. Enable "remark-directive" plugin
+3. Paste your MDX content
+4. Fix reported errors
+
+### Build Failures
+
+Common causes:
+
+- Outdated plugins or themes
+- Custom components using React 17 APIs
+- Invalid MDX syntax not caught by checker
+
+### Hydration Mismatches
+
+React 18 is stricter about hydration. Check for:
+
+- Client-only code in render
+- Conditional rendering based on `window`
+- Inconsistent server/client output
+
+### Missing Prism Languages
+
+If code blocks don't highlight properly, add to `additionalLanguages`:
+
+```js
+prism: {
+  additionalLanguages: ['java', 'php', 'ruby', 'python'],
+}
+```
+
+## Getting Help
+
+- **Official Docs**: https://docusaurus.io/docs/migration/v3
+- **GitHub Discussions**: https://github.com/facebook/docusaurus/discussions
+- **Discord**: Join the Docusaurus Discord for real-time help
+- **MDX Docs**: https://mdxjs.com/docs/
+
+## Resources
+
+- [MDX v3 Migration Guide](https://mdxjs.com/migrating/v3/)
+- [React 18 Upgrade Guide](https://react.dev/blog/2022/03/08/react-18-upgrade-guide)
+- [Prism React Renderer Changelog](https://github.com/FormidableLabs/prism-react-renderer/blob/master/CHANGELOG.md)
diff --git a/.claude/skills/docusaurus-plugins/README.md b/.claude/skills/docusaurus-plugins/README.md
new file mode 100644
index 000000000..2f76cca94
--- /dev/null
+++ b/.claude/skills/docusaurus-plugins/README.md
@@ -0,0 +1,14 @@
+# Docusaurus Plugin Guide
+
+Guide for creating different types of Docusaurus plugins including remark, rehype, theme, content, and lifecycle plugins
+
+## Structure
+
+- `SKILL.md` - Main skill instructions
+- `references/` - Detailed documentation loaded as needed
+- `scripts/` - Executable code for deterministic operations
+- `assets/` - Templates, images, or other resources
+
+## Usage
+
+This skill is automatically discovered by Claude when relevant to the task.
diff --git a/.claude/skills/docusaurus-plugins/SKILL.md b/.claude/skills/docusaurus-plugins/SKILL.md
new file mode 100644
index 000000000..a21590ecb
--- /dev/null
+++ b/.claude/skills/docusaurus-plugins/SKILL.md
@@ -0,0 +1,65 @@
+---
+name: docusaurus-plugins
+# IMPORTANT: Keep description on ONE line for Claude Code compatibility
+# prettier-ignore
+description: Use when creating Docusaurus plugins (remark, rehype, theme, content, lifecycle) to extend markdown, modify HTML, or add custom functionality
+---
+
+# Docusaurus Plugin Guide
+
+## Quick Start
+
+```javascript
+// Remark plugin - transforms markdown AST
+module.exports = function remarkPlugin(options = {}) {
+  return async function transformer(ast, vfile) {
+    const { visit } = require("unist-util-visit");
+
+    visit(ast, "link", (node) => {
+      // Transform nodes
+      node.data = node.data || {};
+      node.data.hProperties = { className: "custom" };
+    });
+
+    return ast;
+  };
+};
+
+// In docusaurus.config.js:
+// remarkPlugins: [require('./plugins/my-plugin')]
+```
+
+## Core Principles
+
+- **5 Plugin Types**: Remark (markdown), Rehype (HTML), Lifecycle (routes/webpack), Theme (components), Content (custom data)
+- **Remark**: Transforms markdown before HTML conversion, use `unist-util-visit` for AST traversal
+- **Rehype**: Transforms HTML after compilation, processes HAST (HTML AST)
+- **Lifecycle**: Most flexible, implements hooks like `loadContent()`, `contentLoaded()`, `postBuild()`
+- **Export function**: Returns transformer (remark/rehype) or plugin object (lifecycle)
+
+## Reference Files
+
+Detailed guides for each plugin type:
+
+- [references/remark-plugins.md](references/remark-plugins.md) - Markdown transformation
+- [references/rehype-plugins.md](references/rehype-plugins.md) - HTML processing
+- [references/lifecycle-plugins.md](references/lifecycle-plugins.md) - Routes, webpack, global data
+- [references/theme-plugins.md](references/theme-plugins.md) - Themes and swizzling
+- [references/content-plugins.md](references/content-plugins.md) - Custom content types
+- [references/package-structure.md](references/package-structure.md) - Publishing and config
+
+<!--
+PROGRESSIVE DISCLOSURE GUIDELINES:
+- Keep this file ~50 lines total (max ~150 lines)
+- Use 1-2 code blocks only (recommend 1)
+- Keep description <200 chars for Level 1 efficiency
+- Move detailed docs to references/ for Level 3 loading
+- This is Level 2 - quick reference ONLY, not a manual
+
+LLM WORKFLOW (when editing this file):
+1. Write/edit SKILL.md
+2. Format (if formatter available)
+3. Run: claude-skills-cli validate <path>
+4. If multi-line description warning: run claude-skills-cli doctor <path>
+5. Validate again to confirm
+-->
diff --git a/.claude/skills/docusaurus-plugins/references/content-plugins.md b/.claude/skills/docusaurus-plugins/references/content-plugins.md
new file mode 100644
index 000000000..a5c0f90e5
--- /dev/null
+++ b/.claude/skills/docusaurus-plugins/references/content-plugins.md
@@ -0,0 +1,650 @@
+# Content Plugins for Docusaurus
+
+Content plugins create **custom content types** beyond the default docs and blog. They load, process, and make content available throughout your site.
+
+## When to Use Content Plugins
+
+- Custom content types (tutorials, changelog, team members, etc.)
+- External data sources (APIs, databases)
+- Generated content (API docs from code)
+- Multi-source aggregation
+- Custom routing patterns
+
+## Content Plugin Structure
+
+```javascript
+// plugins/plugin-content-changelog/index.js
+const fs = require("fs-extra");
+const path = require("path");
+const matter = require("gray-matter");
+
+module.exports = function contentChangelogPlugin(context, options) {
+  const {
+    changelogPath = "changelog",
+    routeBasePath = "changelog",
+    include = ["**/*.md"],
+  } = options;
+
+  const contentPath = path.resolve(context.siteDir, changelogPath);
+
+  return {
+    name: "docusaurus-plugin-content-changelog",
+
+    // Load all changelog entries
+    async loadContent() {
+      const entries = [];
+      const files = await fs.readdir(contentPath);
+
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+
+        const filePath = path.join(contentPath, file);
+        const content = await fs.readFile(filePath, "utf-8");
+        const { data: frontmatter, content: body } = matter(content);
+
+        entries.push({
+          id: file.replace(".md", ""),
+          slug: frontmatter.slug || file.replace(".md", ""),
+          title: frontmatter.title,
+          version: frontmatter.version,
+          date: frontmatter.date,
+          type: frontmatter.type || "feature", // feature, fix, breaking
+          body,
+          filePath,
+        });
+      }
+
+      // Sort by date (newest first)
+      entries.sort((a, b) => new Date(b.date) - new Date(a.date));
+
+      return entries;
+    },
+
+    // Create routes and make data available
+    async contentLoaded({ content, actions }) {
+      const { createData, addRoute, setGlobalData } = actions;
+
+      // Set global data (accessible via useGlobalData hook)
+      setGlobalData({
+        entries: content,
+        latestVersion: content[0]?.version,
+      });
+
+      // Create changelog list page
+      const listDataPath = await createData(
+        "changelog-list.json",
+        JSON.stringify({ entries: content }),
+      );
+
+      addRoute({
+        path: `/${routeBasePath}`,
+        component: "@site/src/components/ChangelogList.js",
+        exact: true,
+        modules: {
+          entries: listDataPath,
+        },
+      });
+
+      // Create individual entry pages
+      await Promise.all(
+        content.map(async (entry) => {
+          const entryDataPath = await createData(
+            `changelog-${entry.id}.json`,
+            JSON.stringify(entry),
+          );
+
+          addRoute({
+            path: `/${routeBasePath}/${entry.slug}`,
+            component: "@site/src/components/ChangelogEntry.js",
+            exact: true,
+            modules: {
+              entry: entryDataPath,
+            },
+          });
+        }),
+      );
+    },
+
+    // Optional: Generate additional files after build
+    async postBuild({ outDir, content }) {
+      // Generate RSS feed
+      const rss = generateRSSFeed(content);
+      await fs.writeFile(path.join(outDir, "changelog.xml"), rss);
+
+      // Generate JSON API
+      const api = content.map((entry) => ({
+        id: entry.id,
+        title: entry.title,
+        version: entry.version,
+        date: entry.date,
+        type: entry.type,
+      }));
+      await fs.writeFile(
+        path.join(outDir, "changelog.json"),
+        JSON.stringify(api, null, 2),
+      );
+    },
+  };
+};
+```
+
+## Configuration
+
+```javascript
+// docusaurus.config.js
+module.exports = {
+  plugins: [
+    [
+      "./plugins/plugin-content-changelog",
+      {
+        changelogPath: "changelog",
+        routeBasePath: "changelog",
+        include: ["**/*.md"],
+      },
+    ],
+  ],
+};
+```
+
+## Content File Structure
+
+```
+changelog/
+├── 2024-01-15-v2.0.0.md
+├── 2024-01-01-v1.5.0.md
+└── 2023-12-15-v1.4.0.md
+```
+
+### Example Content File
+
+```markdown
+---
+slug: v2-0-0
+title: Version 2.0.0 Released
+version: 2.0.0
+date: 2024-01-15
+type: breaking
+---
+
+# What's New in 2.0.0
+
+Major breaking changes and new features.
+
+## Breaking Changes
+
+- API endpoint restructured
+- Configuration format changed
+
+## New Features
+
+- Dark mode support
+- Improved performance
+```
+
+## Component Examples
+
+### Changelog List Component
+
+```javascript
+// src/components/ChangelogList.js
+import React from "react";
+import Layout from "@theme/Layout";
+import Link from "@docusaurus/Link";
+import clsx from "clsx";
+
+export default function ChangelogList({ entries }) {
+  return (
+    <Layout title="Changelog" description="Product updates and release notes">
+      <div className="container margin-vert--lg">
+        <h1>Changelog</h1>
+
+        <div className="changelog-list">
+          {entries.entries.map((entry) => (
+            <div key={entry.id} className="changelog-item">
+              <div className="changelog-header">
+                <Link to={`/changelog/${entry.slug}`}>
+                  <h2>{entry.title}</h2>
+                </Link>
+
+                <div className="changelog-meta">
+                  <span className={clsx("badge", `badge-${entry.type}`)}>
+                    {entry.type}
+                  </span>
+                  <span className="version">v{entry.version}</span>
+                  <time>{new Date(entry.date).toLocaleDateString()}</time>
+                </div>
+              </div>
+
+              <div className="changelog-preview">
+                {entry.body.slice(0, 200)}...
+              </div>
+            </div>
+          ))}
+        </div>
+      </div>
+    </Layout>
+  );
+}
+```
+
+### Changelog Entry Component
+
+```javascript
+// src/components/ChangelogEntry.js
+import React from "react";
+import Layout from "@theme/Layout";
+import MDXContent from "@theme/MDXContent";
+import Link from "@docusaurus/Link";
+
+export default function ChangelogEntry({ entry }) {
+  return (
+    <Layout
+      title={entry.title}
+      description={`Release notes for version ${entry.version}`}
+    >
+      <div className="container margin-vert--lg">
+        <Link to="/changelog" className="back-link">
+          ← Back to Changelog
+        </Link>
+
+        <article className="changelog-entry">
+          <header>
+            <h1>{entry.title}</h1>
+            <div className="meta">
+              <span className="version">Version {entry.version}</span>
+              <time>{new Date(entry.date).toLocaleDateString()}</time>
+            </div>
+          </header>
+
+          <MDXContent>{entry.body}</MDXContent>
+        </article>
+      </div>
+    </Layout>
+  );
+}
+```
+
+## Real-World Examples
+
+### 1. Team Members Plugin
+
+```javascript
+// plugins/plugin-content-team/index.js
+const fs = require("fs-extra");
+const path = require("path");
+const yaml = require("js-yaml");
+
+module.exports = function teamPlugin(context, options) {
+  const { teamDataPath = "data/team.yml" } = options;
+
+  return {
+    name: "docusaurus-plugin-content-team",
+
+    async loadContent() {
+      const dataPath = path.join(context.siteDir, teamDataPath);
+      const data = await fs.readFile(dataPath, "utf-8");
+      const team = yaml.load(data);
+
+      return team.members;
+    },
+
+    async contentLoaded({ content, actions }) {
+      const { createData, addRoute, setGlobalData } = actions;
+
+      setGlobalData({ members: content });
+
+      // Team list page
+      const dataPath = await createData("team.json", JSON.stringify(content));
+
+      addRoute({
+        path: "/team",
+        component: "@site/src/components/Team.js",
+        exact: true,
+        modules: { members: dataPath },
+      });
+
+      // Individual member pages
+      await Promise.all(
+        content.map(async (member) => {
+          const memberData = await createData(
+            `team-${member.id}.json`,
+            JSON.stringify(member),
+          );
+
+          addRoute({
+            path: `/team/${member.id}`,
+            component: "@site/src/components/TeamMember.js",
+            exact: true,
+            modules: { member: memberData },
+          });
+        }),
+      );
+    },
+  };
+};
+```
+
+### 2. External API Content Plugin
+
+```javascript
+// plugins/plugin-content-api/index.js
+const fetch = require("node-fetch");
+
+module.exports = function apiContentPlugin(context, options) {
+  const { apiUrl, apiKey } = options;
+
+  return {
+    name: "docusaurus-plugin-content-api",
+
+    async loadContent() {
+      // Fetch data from external API
+      const response = await fetch(apiUrl, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+      });
+
+      const data = await response.json();
+
+      return data.items.map((item) => ({
+        id: item.id,
+        title: item.title,
+        description: item.description,
+        category: item.category,
+        updatedAt: item.updated_at,
+      }));
+    },
+
+    async contentLoaded({ content, actions }) {
+      const { createData, addRoute, setGlobalData } = actions;
+
+      // Make data globally available
+      setGlobalData({ items: content });
+
+      // Create category pages
+      const categories = [...new Set(content.map((item) => item.category))];
+
+      await Promise.all(
+        categories.map(async (category) => {
+          const categoryItems = content.filter(
+            (item) => item.category === category,
+          );
+          const dataPath = await createData(
+            `category-${category}.json`,
+            JSON.stringify(categoryItems),
+          );
+
+          addRoute({
+            path: `/items/${category}`,
+            component: "@site/src/components/CategoryPage.js",
+            exact: true,
+            modules: { items: dataPath },
+          });
+        }),
+      );
+    },
+  };
+};
+```
+
+### 3. Generated API Documentation Plugin
+
+```javascript
+// plugins/plugin-api-docs/index.js
+const fs = require("fs-extra");
+const path = require("path");
+const { parseTypeScript } = require("./parser");
+
+module.exports = function apiDocsPlugin(context, options) {
+  const { srcDir = "src", include = ["**/*.ts"] } = options;
+
+  return {
+    name: "docusaurus-plugin-api-docs",
+
+    async loadContent() {
+      const srcPath = path.join(context.siteDir, srcDir);
+
+      // Parse TypeScript files
+      const files = await fs.readdir(srcPath);
+      const apiDocs = [];
+
+      for (const file of files) {
+        if (!file.endsWith(".ts")) continue;
+
+        const filePath = path.join(srcPath, file);
+        const content = await fs.readFile(filePath, "utf-8");
+
+        // Extract functions, classes, interfaces
+        const parsed = parseTypeScript(content);
+        apiDocs.push(...parsed);
+      }
+
+      return apiDocs;
+    },
+
+    async contentLoaded({ content, actions }) {
+      const { createData, addRoute } = actions;
+
+      // Create API reference pages
+      await Promise.all(
+        content.map(async (apiItem) => {
+          const dataPath = await createData(
+            `api-${apiItem.name}.json`,
+            JSON.stringify(apiItem),
+          );
+
+          addRoute({
+            path: `/api/${apiItem.name}`,
+            component: "@site/src/components/ApiDoc.js",
+            exact: true,
+            modules: { apiItem: dataPath },
+          });
+        }),
+      );
+
+      // Create API index page
+      const indexPath = await createData(
+        "api-index.json",
+        JSON.stringify(content),
+      );
+
+      addRoute({
+        path: "/api",
+        component: "@site/src/components/ApiIndex.js",
+        exact: true,
+        modules: { items: indexPath },
+      });
+    },
+  };
+};
+```
+
+## Using Plugin Data in Components
+
+### usePluginData Hook
+
+```javascript
+import React from "react";
+import usePluginData from "@docusaurus/usePluginData";
+
+export default function ChangelogWidget() {
+  const { entries, latestVersion } = usePluginData(
+    "docusaurus-plugin-content-changelog",
+  );
+
+  return (
+    <div className="changelog-widget">
+      <h3>Latest Release: v{latestVersion}</h3>
+      <ul>
+        {entries.slice(0, 3).map((entry) => (
+          <li key={entry.id}>
+            <a href={`/changelog/${entry.slug}`}>{entry.title}</a>
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+}
+```
+
+### useGlobalData Hook
+
+```javascript
+import React from "react";
+import useGlobalData from "@docusaurus/useGlobalData";
+
+export default function AllPluginData() {
+  const globalData = useGlobalData();
+
+  // Access data from all plugins
+  const changelogData = globalData["docusaurus-plugin-content-changelog"];
+  const teamData = globalData["docusaurus-plugin-content-team"];
+
+  return (
+    <div>
+      <p>Latest version: {changelogData.latestVersion}</p>
+      <p>Team members: {teamData.members.length}</p>
+    </div>
+  );
+}
+```
+
+## Package Structure
+
+```json
+{
+  "name": "@org/docusaurus-plugin-content-changelog",
+  "version": "1.0.0",
+  "main": "index.js",
+  "keywords": ["docusaurus", "plugin", "content", "changelog"],
+
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "fs-extra": "^11.0.0"
+  },
+
+  "peerDependencies": {
+    "@docusaurus/core": "^3.0.0"
+  }
+}
+```
+
+## TypeScript Support
+
+```typescript
+// index.d.ts
+import { Plugin, LoadContext } from "@docusaurus/types";
+
+export interface ChangelogEntry {
+  id: string;
+  slug: string;
+  title: string;
+  version: string;
+  date: string;
+  type: "feature" | "fix" | "breaking";
+  body: string;
+}
+
+export interface PluginOptions {
+  changelogPath?: string;
+  routeBasePath?: string;
+  include?: string[];
+}
+
+export interface PluginContent {
+  entries: ChangelogEntry[];
+  latestVersion: string;
+}
+
+declare const plugin: (
+  context: LoadContext,
+  options: PluginOptions,
+) => Plugin<ChangelogEntry[]>;
+
+export default plugin;
+```
+
+## Best Practices
+
+1. **Validate frontmatter** - Ensure required fields exist
+2. **Sort content logically** - By date, priority, or category
+3. **Cache external data** - Avoid repeated API calls during dev
+4. **Provide TypeScript types** - Better DX with autocomplete
+5. **Handle errors gracefully** - Missing files, invalid data
+6. **Create indexes** - List pages for browsing content
+7. **Generate feeds** - RSS, JSON APIs for external consumption
+
+## Common Patterns
+
+### Pagination
+
+```javascript
+async contentLoaded({ content, actions }) {
+  const { createData, addRoute } = actions;
+  const pageSize = 10;
+  const pageCount = Math.ceil(content.length / pageSize);
+
+  for (let i = 0; i < pageCount; i++) {
+    const pageContent = content.slice(i * pageSize, (i + 1) * pageSize);
+    const dataPath = await createData(
+      `page-${i + 1}.json`,
+      JSON.stringify({
+        items: pageContent,
+        page: i + 1,
+        totalPages: pageCount,
+      })
+    );
+
+    addRoute({
+      path: i === 0 ? '/items' : `/items/page/${i + 1}`,
+      component: '@site/src/components/ItemList.js',
+      exact: true,
+      modules: { data: dataPath },
+    });
+  }
+}
+```
+
+### Tagging/Categories
+
+```javascript
+// Group content by tags
+const tagMap = new Map();
+
+content.forEach((item) => {
+  item.tags.forEach((tag) => {
+    if (!tagMap.has(tag)) {
+      tagMap.set(tag, []);
+    }
+    tagMap.get(tag).push(item);
+  });
+});
+
+// Create tag pages
+for (const [tag, items] of tagMap) {
+  const dataPath = await createData(`tag-${tag}.json`, JSON.stringify(items));
+
+  addRoute({
+    path: `/tags/${tag}`,
+    component: "@site/src/components/TagPage.js",
+    modules: { items: dataPath },
+  });
+}
+```
+
+### Search Integration
+
+```javascript
+// Generate search index
+async postBuild({ outDir, content }) {
+  const searchIndex = content.map((item) => ({
+    id: item.id,
+    title: item.title,
+    content: item.body,
+    url: `/changelog/${item.slug}`,
+  }));
+
+  await fs.writeFile(
+    path.join(outDir, 'search-index.json'),
+    JSON.stringify(searchIndex)
+  );
+}
+```
diff --git a/.claude/skills/docusaurus-plugins/references/lifecycle-plugins.md b/.claude/skills/docusaurus-plugins/references/lifecycle-plugins.md
new file mode 100644
index 000000000..ae91334da
--- /dev/null
+++ b/.claude/skills/docusaurus-plugins/references/lifecycle-plugins.md
@@ -0,0 +1,704 @@
+# Lifecycle Plugins for Docusaurus
+
+Lifecycle plugins are the most flexible type of Docusaurus plugin. They implement **lifecycle hooks** that execute at different stages of the build process.
+
+## When to Use Lifecycle Plugins
+
+- Add custom routes and pages
+- Modify webpack configuration
+- Inject scripts or styles into HTML
+- Generate static files during build
+- Add global data accessible across the site
+- Integrate third-party services
+- Custom content processing
+
+## Complete Plugin Structure
+
+```javascript
+// plugins/my-plugin/index.js
+const path = require("path");
+
+module.exports = function myPlugin(context, options) {
+  const { siteConfig, siteDir } = context;
+  const { customOption = "default" } = options;
+
+  return {
+    name: "my-custom-plugin",
+
+    // Load content from files
+    async loadContent() {
+      // Read files, fetch data, etc.
+      const data = await fetchData();
+      return data;
+    },
+
+    // Make content available globally
+    async contentLoaded({ content, actions }) {
+      const { setGlobalData, addRoute, createData } = actions;
+
+      // Add global data (accessible via useGlobalData hook)
+      setGlobalData({ myData: content });
+
+      // Add custom route
+      addRoute({
+        path: "/custom-page",
+        component: "@site/src/components/CustomPage.js",
+        exact: true,
+      });
+
+      // Create data file for component props
+      const dataPath = await createData(
+        "my-data.json",
+        JSON.stringify(content),
+      );
+
+      addRoute({
+        path: "/data-page",
+        component: "@site/src/components/DataPage.js",
+        modules: {
+          data: dataPath,
+        },
+        exact: true,
+      });
+    },
+
+    // Run after build completes
+    async postBuild({ outDir, content }) {
+      // Generate additional files
+      await generateSitemap(outDir);
+    },
+
+    // Inject HTML tags
+    injectHtmlTags() {
+      return {
+        headTags: [
+          {
+            tagName: "link",
+            attributes: {
+              rel: "preconnect",
+              href: "https://fonts.googleapis.com",
+            },
+          },
+          {
+            tagName: "script",
+            attributes: {
+              src: "https://analytics.example.com/script.js",
+              async: true,
+            },
+          },
+        ],
+        preBodyTags: [],
+        postBodyTags: [
+          {
+            tagName: "script",
+            innerHTML: `
+              console.log('Page loaded');
+            `,
+          },
+        ],
+      };
+    },
+
+    // Modify webpack config
+    configureWebpack(config, isServer, utils) {
+      return {
+        resolve: {
+          alias: {
+            "@components": path.resolve(__dirname, "../../src/components"),
+          },
+        },
+        plugins: [
+          // Custom webpack plugins
+        ],
+      };
+    },
+
+    // Provide client modules (run in browser)
+    getClientModules() {
+      return [path.resolve(__dirname, "./clientModule.js")];
+    },
+
+    // Get theme path
+    getThemePath() {
+      return path.resolve(__dirname, "./theme");
+    },
+  };
+};
+```
+
+## Configuration in docusaurus.config.js
+
+```javascript
+// Local plugin
+module.exports = {
+  plugins: [
+    "./plugins/my-plugin",
+    // Or with options
+    [
+      "./plugins/my-plugin",
+      {
+        customOption: "value",
+      },
+    ],
+  ],
+};
+
+// npm package
+module.exports = {
+  plugins: [
+    "@org/docusaurus-plugin-name",
+    // Or with options
+    [
+      "@org/docusaurus-plugin-name",
+      {
+        apiKey: "xxx",
+        enabled: true,
+      },
+    ],
+  ],
+};
+```
+
+## Lifecycle Hooks
+
+### loadContent()
+
+Load data from files, APIs, or databases.
+
+```javascript
+async loadContent() {
+  const posts = await fs.readdir('./blog');
+  const data = await Promise.all(
+    posts.map(async (file) => {
+      const content = await fs.readFile(`./blog/${file}`, 'utf-8');
+      return parseMarkdown(content);
+    })
+  );
+  return data;
+}
+```
+
+### contentLoaded({ content, actions })
+
+Process loaded content and create routes/global data.
+
+```javascript
+async contentLoaded({ content, actions }) {
+  const { setGlobalData, addRoute, createData } = actions;
+
+  // Add global data
+  setGlobalData({ posts: content });
+
+  // Create route for each post
+  await Promise.all(
+    content.map(async (post) => {
+      const dataPath = await createData(
+        `post-${post.id}.json`,
+        JSON.stringify(post)
+      );
+
+      addRoute({
+        path: `/blog/${post.slug}`,
+        component: '@site/src/components/BlogPost.js',
+        modules: { post: dataPath },
+        exact: true,
+      });
+    })
+  );
+}
+```
+
+### postBuild({ outDir, content })
+
+Run after build completes. Generate additional files.
+
+```javascript
+async postBuild({ outDir, content }) {
+  // Generate RSS feed
+  const feed = generateRSS(content);
+  await fs.writeFile(`${outDir}/rss.xml`, feed);
+
+  // Generate sitemap
+  const sitemap = generateSitemap(content);
+  await fs.writeFile(`${outDir}/sitemap.xml`, sitemap);
+}
+```
+
+### injectHtmlTags()
+
+Add scripts, styles, meta tags to HTML.
+
+```javascript
+injectHtmlTags({ content }) {
+  return {
+    headTags: [
+      // Analytics
+      {
+        tagName: 'script',
+        attributes: {
+          async: true,
+          src: 'https://www.googletagmanager.com/gtag/js?id=GA_ID',
+        },
+      },
+      // Meta tags
+      {
+        tagName: 'meta',
+        attributes: {
+          name: 'description',
+          content: 'Site description',
+        },
+      },
+      // Preconnect
+      {
+        tagName: 'link',
+        attributes: {
+          rel: 'preconnect',
+          href: 'https://fonts.googleapis.com',
+        },
+      },
+    ],
+    postBodyTags: [
+      // Inline script
+      {
+        tagName: 'script',
+        innerHTML: `
+          window.customConfig = ${JSON.stringify({ key: 'value' })};
+        `,
+      },
+    ],
+  };
+}
+```
+
+### configureWebpack(config, isServer, utils)
+
+Modify webpack configuration.
+
+```javascript
+configureWebpack(config, isServer, utils) {
+  const { getStyleLoaders } = utils;
+
+  return {
+    resolve: {
+      alias: {
+        '@components': path.resolve(__dirname, '../../src/components'),
+      },
+    },
+    module: {
+      rules: [
+        {
+          test: /\.custom$/,
+          use: ['custom-loader'],
+        },
+      ],
+    },
+    plugins: [
+      new CustomWebpackPlugin(),
+    ],
+  };
+}
+```
+
+### getClientModules()
+
+Provide modules that run in the browser.
+
+```javascript
+// plugins/my-plugin/index.js
+getClientModules() {
+  return [path.resolve(__dirname, './analytics.js')];
+}
+
+// plugins/my-plugin/analytics.js
+export function onRouteUpdate({ location }) {
+  // Track page view
+  if (typeof window !== 'undefined' && window.gtag) {
+    window.gtag('config', 'GA_ID', {
+      page_path: location.pathname,
+    });
+  }
+}
+```
+
+## Real-World Examples
+
+### 1. Analytics Plugin
+
+```javascript
+// plugins/analytics/index.js
+module.exports = function analyticsPlugin(context, options) {
+  const { trackingId, anonymizeIP = true } = options;
+
+  return {
+    name: "docusaurus-plugin-analytics",
+
+    injectHtmlTags() {
+      return {
+        headTags: [
+          {
+            tagName: "script",
+            attributes: {
+              async: true,
+              src: `https://www.googletagmanager.com/gtag/js?id=${trackingId}`,
+            },
+          },
+          {
+            tagName: "script",
+            innerHTML: `
+              window.dataLayer = window.dataLayer || [];
+              function gtag(){dataLayer.push(arguments);}
+              gtag('js', new Date());
+              gtag('config', '${trackingId}', {
+                anonymize_ip: ${anonymizeIP}
+              });
+            `,
+          },
+        ],
+      };
+    },
+
+    getClientModules() {
+      return [path.resolve(__dirname, "./trackPageViews.js")];
+    },
+  };
+};
+
+// plugins/analytics/trackPageViews.js
+export function onRouteUpdate({ location }) {
+  if (typeof window !== "undefined" && window.gtag) {
+    window.gtag("event", "page_view", {
+      page_path: location.pathname,
+    });
+  }
+}
+```
+
+### 2. RSS Feed Generator
+
+```javascript
+// plugins/rss/index.js
+const fs = require("fs-extra");
+const RSS = require("rss");
+
+module.exports = function rssPlugin(context, options) {
+  const { siteConfig } = context;
+  const { feedPath = "rss.xml", limit = 20 } = options;
+
+  return {
+    name: "docusaurus-plugin-rss",
+
+    async postBuild({ outDir }) {
+      // Read blog posts from content
+      const posts = await loadBlogPosts();
+
+      // Create RSS feed
+      const feed = new RSS({
+        title: siteConfig.title,
+        description: siteConfig.tagline,
+        feed_url: `${siteConfig.url}/${feedPath}`,
+        site_url: siteConfig.url,
+        language: "en",
+      });
+
+      // Add posts to feed
+      posts.slice(0, limit).forEach((post) => {
+        feed.item({
+          title: post.title,
+          description: post.description,
+          url: `${siteConfig.url}${post.permalink}`,
+          date: post.date,
+        });
+      });
+
+      // Write RSS file
+      await fs.writeFile(
+        path.join(outDir, feedPath),
+        feed.xml({ indent: true }),
+      );
+    },
+  };
+};
+```
+
+### 3. Dynamic Route Creator
+
+```javascript
+// plugins/custom-pages/index.js
+const fs = require("fs-extra");
+const matter = require("gray-matter");
+
+module.exports = function customPagesPlugin(context, options) {
+  const { pagesDir = "custom-pages" } = options;
+
+  return {
+    name: "docusaurus-plugin-custom-pages",
+
+    async loadContent() {
+      const pagesPath = path.join(context.siteDir, pagesDir);
+      const files = await fs.readdir(pagesPath);
+
+      const pages = await Promise.all(
+        files
+          .filter((file) => file.endsWith(".md"))
+          .map(async (file) => {
+            const content = await fs.readFile(
+              path.join(pagesPath, file),
+              "utf-8",
+            );
+            const { data, content: body } = matter(content);
+
+            return {
+              id: file.replace(".md", ""),
+              ...data,
+              body,
+            };
+          }),
+      );
+
+      return pages;
+    },
+
+    async contentLoaded({ content, actions }) {
+      const { addRoute, createData } = actions;
+
+      await Promise.all(
+        content.map(async (page) => {
+          const dataPath = await createData(
+            `page-${page.id}.json`,
+            JSON.stringify(page),
+          );
+
+          addRoute({
+            path: `/${page.slug || page.id}`,
+            component: "@site/src/components/CustomPage.js",
+            modules: { page: dataPath },
+            exact: true,
+          });
+        }),
+      );
+    },
+  };
+};
+
+// src/components/CustomPage.js
+import React from "react";
+import Layout from "@theme/Layout";
+import MDXContent from "@theme/MDXContent";
+
+export default function CustomPage({ page }) {
+  return (
+    <Layout title={page.title}>
+      <div className="container margin-vert--lg">
+        <h1>{page.title}</h1>
+        <MDXContent>{page.body}</MDXContent>
+      </div>
+    </Layout>
+  );
+}
+```
+
+### 4. Sitemap Generator
+
+```javascript
+// plugins/sitemap/index.js
+const fs = require("fs-extra");
+const { SitemapStream, streamToPromise } = require("sitemap");
+
+module.exports = function sitemapPlugin(context, options) {
+  const { siteConfig } = context;
+  const { changefreq = "weekly", priority = 0.7 } = options;
+
+  return {
+    name: "docusaurus-plugin-sitemap",
+
+    async postBuild({ routes, outDir }) {
+      const sitemap = new SitemapStream({
+        hostname: siteConfig.url,
+      });
+
+      // Add routes to sitemap
+      routes.forEach((route) => {
+        if (!route.path.includes("*") && !route.path.includes(":")) {
+          sitemap.write({
+            url: route.path,
+            changefreq,
+            priority,
+          });
+        }
+      });
+
+      sitemap.end();
+
+      // Write sitemap
+      const xml = await streamToPromise(sitemap);
+      await fs.writeFile(path.join(outDir, "sitemap.xml"), xml.toString());
+    },
+  };
+};
+```
+
+### 5. Environment Variables Plugin
+
+```javascript
+// plugins/env-vars/index.js
+const webpack = require("webpack");
+
+module.exports = function envVarsPlugin(context, options) {
+  const { allowedVars = [] } = options;
+
+  return {
+    name: "docusaurus-plugin-env-vars",
+
+    configureWebpack() {
+      const envVars = {};
+
+      allowedVars.forEach((varName) => {
+        if (process.env[varName]) {
+          envVars[`process.env.${varName}`] = JSON.stringify(
+            process.env[varName],
+          );
+        }
+      });
+
+      return {
+        plugins: [new webpack.DefinePlugin(envVars)],
+      };
+    },
+  };
+};
+
+// Usage in docusaurus.config.js
+plugins: [
+  [
+    "./plugins/env-vars",
+    {
+      allowedVars: ["API_URL", "ANALYTICS_ID"],
+    },
+  ],
+];
+```
+
+## Package Structure
+
+```
+docusaurus-plugin-name/
+├── src/
+│   ├── index.js              # Main plugin file
+│   ├── clientModule.js       # Browser-side code
+│   └── theme/                # Theme components (if any)
+│       └── Component.js
+├── index.js                  # Re-export from src
+├── index.d.ts                # TypeScript definitions
+├── package.json
+└── README.md
+```
+
+## TypeScript Definitions
+
+```typescript
+// index.d.ts
+import {
+  Plugin,
+  LoadContext,
+  OptionValidationContext,
+} from "@docusaurus/types";
+
+export interface PluginOptions {
+  customOption?: string;
+  enabled?: boolean;
+}
+
+export default function plugin(
+  context: LoadContext,
+  options: PluginOptions,
+): Plugin<any>;
+
+export function validateOptions({
+  options,
+  validate,
+}: OptionValidationContext<PluginOptions, PluginOptions>): PluginOptions;
+```
+
+## Option Validation
+
+```javascript
+const { Joi } = require("@docusaurus/utils-validation");
+
+function validateOptions({ options, validate }) {
+  const schema = Joi.object({
+    customOption: Joi.string().default("default"),
+    enabled: Joi.boolean().default(true),
+    apiKey: Joi.string().required(),
+  });
+
+  return validate(schema, options);
+}
+
+module.exports = { validateOptions };
+```
+
+## Best Practices
+
+1. **Validate options** - Use Joi schemas for type safety
+2. **Handle errors gracefully** - Don't crash the build
+3. **Document options** - Clear README with examples
+4. **Use TypeScript** - Better DX and autocomplete
+5. **Cache when possible** - Avoid redundant file reads
+6. **Test thoroughly** - Unit and integration tests
+7. **Follow naming conventions** - `docusaurus-plugin-*` or `@scope/docusaurus-plugin-*`
+
+## Testing
+
+```javascript
+// __tests__/plugin.test.js
+const plugin = require("../src/index");
+
+describe("My Plugin", () => {
+  const context = {
+    siteDir: "/site",
+    siteConfig: {
+      url: "https://example.com",
+      baseUrl: "/",
+    },
+  };
+
+  it("returns correct name", () => {
+    const instance = plugin(context, {});
+    expect(instance.name).toBe("my-plugin");
+  });
+
+  it("loads content correctly", async () => {
+    const instance = plugin(context, {});
+    const content = await instance.loadContent();
+    expect(content).toBeDefined();
+  });
+});
+```
+
+## Common Patterns
+
+### Global Data Access
+
+Use `useGlobalData()` hook in React components:
+
+```javascript
+import useGlobalData from "@docusaurus/useGlobalData";
+
+function MyComponent() {
+  const { myData } = useGlobalData()["my-plugin"];
+  return <div>{myData}</div>;
+}
+```
+
+### Plugin Data Access
+
+Use `usePluginData()` hook:
+
+```javascript
+import usePluginData from "@docusaurus/usePluginData";
+
+function MyComponent() {
+  const data = usePluginData("my-plugin");
+  return <div>{data}</div>;
+}
+```
diff --git a/.claude/skills/docusaurus-plugins/references/package-structure.md b/.claude/skills/docusaurus-plugins/references/package-structure.md
new file mode 100644
index 000000000..46df796fd
--- /dev/null
+++ b/.claude/skills/docusaurus-plugins/references/package-structure.md
@@ -0,0 +1,666 @@
+# Package Structure and Setup for Docusaurus Plugins
+
+This guide covers the complete package structure, dependencies, and configuration for publishing Docusaurus plugins.
+
+## Standard Directory Structure
+
+### Remark/Rehype Plugin
+
+```
+docusaurus-plugin-name/
+├── src/
+│   └── index.js              # Main plugin implementation
+├── test/ or __tests__/
+│   ├── fixtures/             # Test fixtures
+│   └── plugin.test.js        # Tests
+├── index.js                  # Re-export from src
+├── index.d.ts                # TypeScript type definitions
+├── package.json
+├── README.md
+├── LICENSE
+├── .gitignore
+├── .npmignore
+├── .editorconfig
+└── .github/
+    └── workflows/
+        └── ci.yml            # GitHub Actions CI/CD
+```
+
+### Lifecycle/Content Plugin
+
+```
+docusaurus-plugin-name/
+├── src/
+│   ├── index.js              # Main plugin file
+│   ├── clientModule.js       # Browser-side code (optional)
+│   ├── types.ts              # TypeScript types
+│   └── utils/                # Utility functions
+│       ├── parser.js
+│       └── validators.js
+├── theme/                    # Theme components (optional)
+│   ├── Component.js
+│   └── Component.css
+├── test/
+│   └── index.test.js
+├── index.js                  # Entry point
+├── index.d.ts                # Type definitions
+├── package.json
+├── tsconfig.json             # TypeScript config (if using TS)
+├── jest.config.js            # Jest config
+├── README.md
+├── LICENSE
+└── CHANGELOG.md
+```
+
+## package.json Configuration
+
+### Minimal package.json (Remark Plugin)
+
+```json
+{
+  "name": "docusaurus-plugin-glossary",
+  "version": "1.0.0",
+  "description": "Docusaurus remark plugin for glossary tooltips",
+  "main": "index.js",
+  "types": "index.d.ts",
+
+  "keywords": ["docusaurus", "remark", "plugin", "glossary", "documentation"],
+
+  "author": "Your Name <email@example.com>",
+  "license": "MIT",
+
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/username/docusaurus-plugin-glossary"
+  },
+
+  "bugs": {
+    "url": "https://github.com/username/docusaurus-plugin-glossary/issues"
+  },
+
+  "homepage": "https://github.com/username/docusaurus-plugin-glossary#readme",
+
+  "files": ["index.js", "index.d.ts", "lib/", "src/"],
+
+  "dependencies": {
+    "unist-util-visit": "^4.0.0"
+  },
+
+  "peerDependencies": {
+    "@docusaurus/core": "^3.0.0",
+    "remark": "^13.0.0 || ^14.0.0"
+  },
+
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "@types/unist": "^2.0.0",
+    "jest": "^29.0.0",
+    "remark": "^14.0.0"
+  },
+
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "lint": "eslint .",
+    "format": "prettier --write \"**/*.{js,json,md}\""
+  },
+
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}
+```
+
+### Complete package.json (Lifecycle Plugin)
+
+```json
+{
+  "name": "@org/docusaurus-plugin-changelog",
+  "version": "2.1.0",
+  "description": "Changelog content plugin for Docusaurus",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+
+  "keywords": ["docusaurus", "plugin", "content", "changelog", "release-notes"],
+
+  "author": "Organization Name",
+  "license": "MIT",
+
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/org/docusaurus-plugin-changelog",
+    "directory": "packages/plugin-changelog"
+  },
+
+  "publishConfig": {
+    "access": "public"
+  },
+
+  "files": ["lib/", "theme/", "index.js", "index.d.ts"],
+
+  "dependencies": {
+    "fs-extra": "^11.0.0",
+    "gray-matter": "^4.0.3",
+    "js-yaml": "^4.1.0",
+    "rss": "^1.2.2"
+  },
+
+  "peerDependencies": {
+    "@docusaurus/core": "^3.0.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0"
+  },
+
+  "devDependencies": {
+    "@docusaurus/core": "^3.0.0",
+    "@docusaurus/types": "^3.0.0",
+    "@types/jest": "^29.0.0",
+    "@types/node": "^18.0.0",
+    "@types/react": "^18.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "eslint-config-prettier": "^9.0.0",
+    "jest": "^29.0.0",
+    "prettier": "^3.0.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "typescript": "^5.0.0"
+  },
+
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx,js,json}\"",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm test"
+  },
+
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}
+```
+
+## TypeScript Configuration
+
+### tsconfig.json
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020", "DOM"],
+    "jsx": "react",
+
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./lib",
+    "rootDir": "./src",
+
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true
+  },
+
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "lib", "test", "**/*.test.ts"]
+}
+```
+
+## TypeScript Type Definitions
+
+### Remark Plugin Types
+
+```typescript
+// index.d.ts
+import { Plugin } from "unified";
+import { Root } from "mdast";
+
+/**
+ * Options for the glossary plugin
+ */
+export interface RemarkGlossaryOptions {
+  /**
+   * Directory containing term definitions
+   * @default './docs/terms'
+   */
+  termsDir?: string;
+
+  /**
+   * Root documentation directory
+   * @default './docs'
+   */
+  docsDir?: string;
+
+  /**
+   * Output path for generated glossary
+   * @default './docs/glossary.md'
+   */
+  glossaryFilepath?: string;
+
+  /**
+   * Custom component path for tooltips
+   */
+  componentPath?: string;
+}
+
+/**
+ * Remark plugin for adding glossary tooltips to documentation
+ */
+declare const remarkGlossary: Plugin<[RemarkGlossaryOptions?], Root>;
+
+export default remarkGlossary;
+```
+
+### Lifecycle Plugin Types
+
+```typescript
+// index.d.ts
+import {
+  Plugin,
+  LoadContext,
+  OptionValidationContext,
+} from "@docusaurus/types";
+
+/**
+ * Changelog entry data structure
+ */
+export interface ChangelogEntry {
+  id: string;
+  slug: string;
+  title: string;
+  version: string;
+  date: string;
+  type: "feature" | "fix" | "breaking" | "improvement";
+  body: string;
+  filePath: string;
+}
+
+/**
+ * Plugin options
+ */
+export interface PluginOptions {
+  /**
+   * Path to changelog directory
+   * @default 'changelog'
+   */
+  changelogPath?: string;
+
+  /**
+   * Base URL path for changelog routes
+   * @default 'changelog'
+   */
+  routeBasePath?: string;
+
+  /**
+   * Glob patterns for files to include
+   * @default ['**\/*.md']
+   */
+  include?: string[];
+
+  /**
+   * Generate RSS feed
+   * @default true
+   */
+  generateRss?: boolean;
+}
+
+/**
+ * Plugin content loaded in browser
+ */
+export interface PluginContent {
+  entries: ChangelogEntry[];
+  latestVersion: string;
+}
+
+declare const plugin: (
+  context: LoadContext,
+  options: PluginOptions,
+) => Plugin<ChangelogEntry[]>;
+
+export default plugin;
+
+/**
+ * Validate plugin options
+ */
+export function validateOptions(
+  context: OptionValidationContext<PluginOptions, PluginOptions>,
+): PluginOptions;
+```
+
+## Jest Configuration
+
+### jest.config.js
+
+```javascript
+module.exports = {
+  testEnvironment: "node",
+  testMatch: ["**/__tests__/**/*.js", "**/*.test.js"],
+  collectCoverageFrom: [
+    "src/**/*.js",
+    "!src/**/*.test.js",
+    "!**/node_modules/**",
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+  },
+  transform: {
+    "^.+\\.jsx?$": "babel-jest",
+  },
+};
+```
+
+## ESLint Configuration
+
+### .eslintrc.js
+
+```javascript
+module.exports = {
+  root: true,
+  env: {
+    node: true,
+    es2020: true,
+  },
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier",
+  ],
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: "module",
+  },
+  rules: {
+    "@typescript-eslint/no-explicit-any": "warn",
+    "@typescript-eslint/explicit-module-boundary-types": "off",
+    "no-console": "warn",
+  },
+};
+```
+
+## Prettier Configuration
+
+### .prettierrc
+
+```json
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": true,
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false
+}
+```
+
+## .npmignore
+
+```
+# Source files
+src/
+test/
+__tests__/
+
+# Config files
+.github/
+.vscode/
+*.config.js
+tsconfig.json
+.eslintrc.js
+.prettierrc
+
+# Documentation
+*.md
+!README.md
+!LICENSE
+
+# Misc
+coverage/
+.DS_Store
+*.log
+```
+
+## .gitignore
+
+```
+# Dependencies
+node_modules/
+
+# Build output
+lib/
+dist/
+*.tsbuildinfo
+
+# Testing
+coverage/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+
+# Environment
+.env
+.env.local
+```
+
+## GitHub Actions CI/CD
+
+### .github/workflows/ci.yml
+
+```yaml
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run linter
+        run: npm run lint
+
+      - name: Run tests
+        run: npm test -- --coverage
+
+      - name: Type check
+        run: npm run typecheck
+
+      - name: Build
+        run: npm run build
+
+      - name: Upload coverage
+        uses: codecov/codecov-action@v3
+        with:
+          file: ./coverage/coverage-final.json
+
+  publish:
+    needs: test
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "18.x"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Publish to npm
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+```
+
+## README.md Template
+
+````markdown
+# docusaurus-plugin-name
+
+> Brief description of what the plugin does
+
+## Installation
+
+```bash
+npm install docusaurus-plugin-name
+# or
+yarn add docusaurus-plugin-name
+```
+````
+
+## Usage
+
+Add to your `docusaurus.config.js`:
+
+```javascript
+module.exports = {
+  plugins: [
+    [
+      "docusaurus-plugin-name",
+      {
+        // Options
+        option1: "value1",
+        option2: true,
+      },
+    ],
+  ],
+};
+```
+
+## Options
+
+| Option    | Type      | Default     | Description |
+| --------- | --------- | ----------- | ----------- |
+| `option1` | `string`  | `'default'` | Description |
+| `option2` | `boolean` | `false`     | Description |
+
+## Examples
+
+### Basic Example
+
+```javascript
+// Example code
+```
+
+### Advanced Example
+
+```javascript
+// Advanced usage
+```
+
+## API
+
+### Plugin Methods
+
+#### `loadContent()`
+
+Description...
+
+#### `contentLoaded({ content, actions })`
+
+Description...
+
+## License
+
+MIT
+
+````
+
+## Versioning and Publishing
+
+### Semantic Versioning
+
+- **MAJOR** (1.0.0 → 2.0.0): Breaking changes
+- **MINOR** (1.0.0 → 1.1.0): New features (backward compatible)
+- **PATCH** (1.0.0 → 1.0.1): Bug fixes
+
+### Publishing to npm
+
+```bash
+# 1. Login to npm
+npm login
+
+# 2. Test build
+npm run build
+npm test
+
+# 3. Update version
+npm version patch  # or minor, major
+
+# 4. Publish
+npm publish
+
+# For scoped packages
+npm publish --access public
+````
+
+## Best Practices
+
+1. **Use TypeScript** - Better DX, fewer bugs
+2. **Write tests** - Aim for 80%+ coverage
+3. **Document thoroughly** - README, JSDoc, examples
+4. **Semantic versioning** - Follow SemVer strictly
+5. **CI/CD** - Automate testing and publishing
+6. **Peer dependencies** - Mark Docusaurus as peer dep
+7. **Keep minimal** - Only include necessary files in package
+8. **Changelog** - Maintain CHANGELOG.md
diff --git a/.claude/skills/docusaurus-plugins/references/rehype-plugins.md b/.claude/skills/docusaurus-plugins/references/rehype-plugins.md
new file mode 100644
index 000000000..7db38cf37
--- /dev/null
+++ b/.claude/skills/docusaurus-plugins/references/rehype-plugins.md
@@ -0,0 +1,541 @@
+# Rehype Plugins for Docusaurus
+
+Rehype plugins transform **HTML content** after markdown has been converted to HTML. They operate on the HAST (HTML Abstract Syntax Tree).
+
+## When to Use Rehype Plugins
+
+- HTML post-processing and cleanup
+- Adding wrapper divs or containers
+- Accessibility improvements (ARIA attributes)
+- Modifying HTML attributes
+- Syntax highlighting customization
+- Lazy loading images
+- Adding classes to elements
+
+## Remark vs Rehype
+
+| Aspect       | Remark                     | Rehype                |
+| ------------ | -------------------------- | --------------------- |
+| **Input**    | Markdown                   | HTML                  |
+| **AST**      | MDAST                      | HAST                  |
+| **Timing**   | Before HTML conversion     | After HTML conversion |
+| **Use Case** | Markdown syntax extensions | HTML manipulation     |
+| **Example**  | Custom `[[term]]` syntax   | Add wrapper divs      |
+
+## Complete Plugin Structure
+
+```javascript
+// index.js - Rehype plugin
+const { visit } = require("unist-util-visit");
+const { h } = require("hastscript");
+
+module.exports = function rehypeCustomPlugin(options = {}) {
+  const {
+    wrapperClass = "content-wrapper",
+    addLazyLoading = true,
+    externalLinkIcon = true,
+  } = options;
+
+  return function transformer(tree, file) {
+    // Add lazy loading to images
+    if (addLazyLoading) {
+      visit(tree, "element", (node) => {
+        if (node.tagName === "img") {
+          node.properties.loading = "lazy";
+          node.properties.decoding = "async";
+        }
+      });
+    }
+
+    // Add icon to external links
+    if (externalLinkIcon) {
+      visit(tree, "element", (node) => {
+        if (node.tagName === "a" && node.properties.href) {
+          const href = node.properties.href;
+
+          if (
+            href.startsWith("http") &&
+            !href.includes(options.siteUrl || "")
+          ) {
+            // Add external link class
+            node.properties.className = [
+              ...(node.properties.className || []),
+              "external-link",
+            ];
+
+            // Add rel attributes for security
+            node.properties.rel = "noopener noreferrer";
+            node.properties.target = "_blank";
+
+            // Add icon element
+            node.children.push({
+              type: "element",
+              tagName: "span",
+              properties: { className: ["external-icon"] },
+              children: [{ type: "text", value: " ↗" }],
+            });
+          }
+        }
+      });
+    }
+
+    // Wrap content sections
+    visit(tree, "element", (node, index, parent) => {
+      if (
+        node.tagName === "div" &&
+        node.properties.className?.includes("markdown")
+      ) {
+        // Wrap in custom container
+        const wrapper = h(`div.${wrapperClass}`, {}, [node]);
+        parent.children[index] = wrapper;
+      }
+    });
+
+    return tree;
+  };
+};
+```
+
+## Configuration in docusaurus.config.js
+
+```javascript
+// Basic configuration
+module.exports = {
+  presets: [
+    [
+      "@docusaurus/preset-classic",
+      {
+        docs: {
+          rehypePlugins: [require("./plugins/my-rehype-plugin")],
+        },
+      },
+    ],
+  ],
+};
+
+// With options
+module.exports = {
+  presets: [
+    [
+      "@docusaurus/preset-classic",
+      {
+        docs: {
+          rehypePlugins: [
+            [
+              require("./plugins/my-rehype-plugin"),
+              {
+                wrapperClass: "custom-wrapper",
+                addLazyLoading: true,
+                externalLinkIcon: true,
+                siteUrl: "https://mysite.com",
+              },
+            ],
+          ],
+        },
+      },
+    ],
+  ],
+};
+```
+
+## Common HTML Node Types
+
+### Element Nodes
+
+```javascript
+{
+  type: 'element',
+  tagName: 'div',
+  properties: {
+    className: ['my-class'],
+    id: 'my-id',
+    dataCustom: 'value'
+  },
+  children: [...]
+}
+```
+
+### Text Nodes
+
+```javascript
+{
+  type: 'text',
+  value: 'Text content'
+}
+```
+
+### Common Elements
+
+```javascript
+// Link
+{
+  type: 'element',
+  tagName: 'a',
+  properties: {
+    href: 'https://example.com',
+    rel: 'noopener',
+    target: '_blank'
+  },
+  children: [{ type: 'text', value: 'Link text' }]
+}
+
+// Image
+{
+  type: 'element',
+  tagName: 'img',
+  properties: {
+    src: '/img/photo.jpg',
+    alt: 'Description',
+    loading: 'lazy'
+  },
+  children: []
+}
+
+// Heading
+{
+  type: 'element',
+  tagName: 'h2',
+  properties: { id: 'heading-id' },
+  children: [{ type: 'text', value: 'Heading' }]
+}
+```
+
+## Using hastscript
+
+The `hastscript` library (`h()` function) makes creating HTML nodes easier:
+
+```javascript
+const { h } = require("hastscript");
+
+// Create elements
+const div = h("div", { className: "container" }, [
+  h("p", "Paragraph text"),
+  h("a", { href: "#" }, "Link"),
+]);
+
+// Shorthand with classes and IDs
+const header = h("div.header#main", [h("h1.title", "Page Title")]);
+
+// Result:
+// <div class="header" id="main">
+//   <h1 class="title">Page Title</h1>
+// </div>
+```
+
+## Real-World Examples
+
+### 1. Add Wrapper Divs to Code Blocks
+
+```javascript
+const { visit } = require("unist-util-visit");
+const { h } = require("hastscript");
+
+module.exports = function rehypeCodeWrapper() {
+  return function transformer(tree) {
+    visit(tree, "element", (node, index, parent) => {
+      if (node.tagName === "pre") {
+        // Get language from code element
+        const codeNode = node.children[0];
+        const language =
+          codeNode?.properties?.className?.[0]?.replace("language-", "") ||
+          "text";
+
+        // Create wrapper with copy button
+        const wrapper = h(
+          "div.code-block-wrapper",
+          { dataLanguage: language },
+          [
+            h("div.code-header", [
+              h("span.language-label", language),
+              h("button.copy-button", { type: "button" }, "Copy"),
+            ]),
+            node,
+          ],
+        );
+
+        parent.children[index] = wrapper;
+      }
+    });
+
+    return tree;
+  };
+};
+```
+
+### 2. Lazy Load Images with Blur Placeholder
+
+```javascript
+const { visit } = require("unist-util-visit");
+
+module.exports = function rehypeLazyImages(options = {}) {
+  const { blurDataURL = "data:image/..." } = options;
+
+  return function transformer(tree) {
+    visit(tree, "element", (node) => {
+      if (node.tagName === "img") {
+        // Add lazy loading
+        node.properties.loading = "lazy";
+        node.properties.decoding = "async";
+
+        // Add blur placeholder
+        node.properties.style = `background-image: url('${blurDataURL}'); background-size: cover;`;
+
+        // Wrap in picture element for responsive images
+        const picture = {
+          type: "element",
+          tagName: "picture",
+          properties: {},
+          children: [
+            // WebP source
+            {
+              type: "element",
+              tagName: "source",
+              properties: {
+                srcset: node.properties.src.replace(/\.(jpg|png)$/, ".webp"),
+                type: "image/webp",
+              },
+              children: [],
+            },
+            // Original img
+            node,
+          ],
+        };
+
+        return picture;
+      }
+    });
+
+    return tree;
+  };
+};
+```
+
+### 3. Add Accessibility Improvements
+
+```javascript
+const { visit } = require("unist-util-visit");
+
+module.exports = function rehypeA11y() {
+  return function transformer(tree) {
+    visit(tree, "element", (node) => {
+      // Add ARIA labels to links without text
+      if (node.tagName === "a") {
+        const hasText = node.children.some(
+          (child) =>
+            child.type === "text" ||
+            (child.type === "element" && child.tagName !== "img"),
+        );
+
+        if (!hasText) {
+          node.properties.ariaLabel = node.properties.href;
+        }
+
+        // Mark external links
+        if (node.properties.href?.startsWith("http")) {
+          node.properties.ariaLabel =
+            `${node.properties.ariaLabel || ""} (opens in new tab)`.trim();
+        }
+      }
+
+      // Ensure images have alt text
+      if (node.tagName === "img" && !node.properties.alt) {
+        console.warn(`Image missing alt text: ${node.properties.src}`);
+        node.properties.alt = "Image"; // Fallback
+      }
+
+      // Add role to nav elements
+      if (node.tagName === "nav" && !node.properties.role) {
+        node.properties.role = "navigation";
+      }
+    });
+
+    return tree;
+  };
+};
+```
+
+### 4. Add Reading Time Meta
+
+```javascript
+const { visit } = require("unist-util-visit");
+const { h } = require("hastscript");
+
+module.exports = function rehypeReadingTime() {
+  return function transformer(tree, file) {
+    let wordCount = 0;
+
+    // Count words
+    visit(tree, "text", (node) => {
+      wordCount += node.value.split(/\s+/).length;
+    });
+
+    // Calculate reading time (average 200 words per minute)
+    const readingTime = Math.ceil(wordCount / 200);
+
+    // Add to frontmatter or tree
+    file.data.readingTime = readingTime;
+
+    // Insert reading time element at the beginning
+    if (tree.children[0]) {
+      tree.children.unshift(
+        h("div.reading-time", { dataMinutes: readingTime }, [
+          h("span", `${readingTime} min read`),
+        ]),
+      );
+    }
+
+    return tree;
+  };
+};
+```
+
+### 5. Enhance Tables
+
+```javascript
+const { visit } = require("unist-util-visit");
+const { h } = require("hastscript");
+
+module.exports = function rehypeTables() {
+  return function transformer(tree) {
+    visit(tree, "element", (node, index, parent) => {
+      if (node.tagName === "table") {
+        // Wrap table in responsive container
+        const wrapper = h("div.table-wrapper", [h("div.table-scroll", [node])]);
+
+        // Add sortable classes to headers
+        visit(node, "element", (headerNode) => {
+          if (headerNode.tagName === "th") {
+            headerNode.properties.className = [
+              ...(headerNode.properties.className || []),
+              "sortable",
+            ];
+            headerNode.properties.tabIndex = 0;
+          }
+        });
+
+        parent.children[index] = wrapper;
+      }
+    });
+
+    return tree;
+  };
+};
+```
+
+## Package Dependencies
+
+```json
+{
+  "dependencies": {
+    "unist-util-visit": "^4.0.0",
+    "hastscript": "^7.0.0"
+  },
+  "peerDependencies": {
+    "@docusaurus/core": "^3.0.0",
+    "rehype": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/hast": "^2.0.0",
+    "jest": "^29.0.0"
+  }
+}
+```
+
+## TypeScript Definitions
+
+```typescript
+// index.d.ts
+import { Plugin } from "unified";
+import { Root } from "hast";
+
+export interface RehypePluginOptions {
+  wrapperClass?: string;
+  addLazyLoading?: boolean;
+  externalLinkIcon?: boolean;
+  siteUrl?: string;
+}
+
+declare const rehypePlugin: Plugin<[RehypePluginOptions?], Root>;
+export default rehypePlugin;
+```
+
+## Testing
+
+```javascript
+// __tests__/plugin.test.js
+const rehype = require("rehype");
+const customPlugin = require("../index");
+
+describe("Rehype Custom Plugin", () => {
+  const processor = rehype().use(customPlugin, {
+    addLazyLoading: true,
+  });
+
+  it("adds lazy loading to images", async () => {
+    const input = '<img src="/photo.jpg" alt="Photo" />';
+    const result = await processor.process(input);
+
+    expect(result.toString()).toContain('loading="lazy"');
+  });
+
+  it("adds external link icons", async () => {
+    const input = '<a href="https://external.com">Link</a>';
+    const result = await processor.process(input);
+
+    expect(result.toString()).toContain("external-link");
+    expect(result.toString()).toContain('target="_blank"');
+  });
+});
+```
+
+## Best Practices
+
+1. **Use hastscript for creating nodes** - Cleaner than manual object creation
+2. **Preserve existing properties** - Don't overwrite, merge instead
+3. **Handle edge cases** - Check for missing children, properties
+4. **Add security attributes** - Use `rel="noopener noreferrer"` for external links
+5. **Maintain accessibility** - Add ARIA labels, alt text
+6. **Wrap destructive changes** - Use options to enable/disable transformations
+7. **Log warnings, not errors** - Don't crash on missing attributes
+
+## Common Use Cases
+
+### Responsive Images
+
+Add `srcset`, lazy loading, and blur placeholders.
+
+### Code Block Enhancement
+
+Add copy buttons, language labels, line numbers.
+
+### Link Processing
+
+Add icons for external links, security attributes, analytics tracking.
+
+### Accessibility
+
+ARIA labels, semantic HTML, keyboard navigation.
+
+### Performance
+
+Lazy loading, async decoding, resource hints.
+
+### SEO
+
+Structured data, meta tags, Open Graph images.
+
+## Debugging
+
+```javascript
+// Log all HTML elements
+visit(tree, "element", (node) => {
+  console.log(node.tagName, node.properties);
+});
+
+// Log tree structure
+console.log(JSON.stringify(tree, null, 2));
+```
+
+Use online AST explorers:
+
+- https://astexplorer.net/ (select "HTML" and "rehype")
diff --git a/.claude/skills/docusaurus-plugins/references/remark-plugins.md b/.claude/skills/docusaurus-plugins/references/remark-plugins.md
new file mode 100644
index 000000000..a4a8d8544
--- /dev/null
+++ b/.claude/skills/docusaurus-plugins/references/remark-plugins.md
@@ -0,0 +1,455 @@
+# Remark Plugins for Docusaurus
+
+Remark plugins transform **markdown content** during the parsing phase, before it's converted to HTML. They operate on the MDAST (Markdown Abstract Syntax Tree).
+
+## When to Use Remark Plugins
+
+- Custom markdown syntax (e.g., `%%term%%` for glossary terms)
+- Link processing and validation
+- Auto-generating content from markdown patterns
+- Adding metadata or classes to markdown elements
+- Content transformation before HTML rendering
+
+## Complete Plugin Structure
+
+```javascript
+// index.js - Main plugin file
+const { visit } = require("unist-util-visit");
+const fs = require("fs");
+const path = require("path");
+
+module.exports = function remarkCustomPlugin(options = {}) {
+  // Validate and process options
+  const {
+    pattern = /%%(.+?)%%/g,
+    dataFile = "./data/terms.json",
+    componentName = "CustomTooltip",
+  } = options;
+
+  // Load external data if needed
+  let glossaryData = {};
+  if (fs.existsSync(dataFile)) {
+    glossaryData = JSON.parse(fs.readFileSync(dataFile, "utf-8"));
+  }
+
+  // Return the transformer function
+  return async function transformer(ast, vfile) {
+    const filePath = vfile.path || "";
+
+    // Visit specific node types
+    visit(ast, "text", (node, index, parent) => {
+      const matches = [...node.value.matchAll(pattern)];
+
+      if (matches.length === 0) return;
+
+      // Build replacement nodes
+      const newNodes = [];
+      let lastIndex = 0;
+
+      matches.forEach((match) => {
+        const [fullMatch, termKey] = match;
+        const startIndex = match.index;
+
+        // Add text before match
+        if (startIndex > lastIndex) {
+          newNodes.push({
+            type: "text",
+            value: node.value.slice(lastIndex, startIndex),
+          });
+        }
+
+        // Add custom component node
+        const termData = glossaryData[termKey];
+        if (termData) {
+          newNodes.push({
+            type: "jsx",
+            value: `<${componentName} term="${termKey}" tooltip="${termData.tooltip}">${termData.display}</${componentName}>`,
+          });
+        } else {
+          // Fallback if term not found
+          newNodes.push({
+            type: "text",
+            value: fullMatch,
+          });
+        }
+
+        lastIndex = startIndex + fullMatch.length;
+      });
+
+      // Add remaining text
+      if (lastIndex < node.value.length) {
+        newNodes.push({
+          type: "text",
+          value: node.value.slice(lastIndex),
+        });
+      }
+
+      // Replace the original node
+      parent.children.splice(index, 1, ...newNodes);
+    });
+
+    // Visit links
+    visit(ast, "link", (node) => {
+      if (node.url.endsWith(".md")) {
+        // Transform internal markdown links
+        node.data = node.data || {};
+        node.data.hProperties = {
+          className: "internal-link",
+          "data-internal": true,
+        };
+      }
+    });
+
+    return ast;
+  };
+};
+```
+
+## Configuration in docusaurus.config.js
+
+```javascript
+// Basic configuration
+module.exports = {
+  presets: [
+    [
+      "@docusaurus/preset-classic",
+      {
+        docs: {
+          remarkPlugins: [require("./plugins/my-remark-plugin")],
+        },
+      },
+    ],
+  ],
+};
+
+// With options
+module.exports = {
+  presets: [
+    [
+      "@docusaurus/preset-classic",
+      {
+        docs: {
+          remarkPlugins: [
+            [
+              require("./plugins/my-remark-plugin"),
+              {
+                pattern: /\[\[(.+?)\]\]/g,
+                dataFile: "./glossary.json",
+                componentName: "GlossaryTerm",
+              },
+            ],
+          ],
+        },
+      },
+    ],
+  ],
+};
+
+// Execute BEFORE default Docusaurus plugins
+module.exports = {
+  presets: [
+    [
+      "@docusaurus/preset-classic",
+      {
+        docs: {
+          beforeDefaultRemarkPlugins: [require("./plugins/my-remark-plugin")],
+        },
+      },
+    ],
+  ],
+};
+```
+
+## Common Node Types
+
+### Text Nodes
+
+```javascript
+{
+  type: 'text',
+  value: 'Some text content'
+}
+```
+
+### Link Nodes
+
+```javascript
+{
+  type: 'link',
+  url: 'https://example.com',
+  children: [{ type: 'text', value: 'Link text' }]
+}
+```
+
+### Paragraph Nodes
+
+```javascript
+{
+  type: 'paragraph',
+  children: [...]
+}
+```
+
+### JSX Nodes (for MDX)
+
+```javascript
+{
+  type: 'jsx',
+  value: '<CustomComponent prop="value">Content</CustomComponent>'
+}
+```
+
+### Heading Nodes
+
+```javascript
+{
+  type: 'heading',
+  depth: 2,  // h2
+  children: [{ type: 'text', value: 'Heading text' }]
+}
+```
+
+## Using unist-util-visit
+
+```javascript
+const { visit } = require("unist-util-visit");
+
+// Visit all nodes of a specific type
+visit(ast, "link", (node) => {
+  console.log(node.url);
+});
+
+// Visit multiple types
+visit(ast, ["link", "image"], (node) => {
+  console.log(node.type, node.url);
+});
+
+// Visit with index and parent access
+visit(ast, "text", (node, index, parent) => {
+  // Modify parent.children to replace nodes
+  parent.children[index] = newNode;
+});
+
+// Visit all nodes
+visit(ast, (node) => {
+  if (node.type === "link" && node.url.startsWith("http")) {
+    // Process external links
+  }
+});
+```
+
+## Real-World Example: Glossary Plugin
+
+Based on docusaurus-plugin-glossary pattern:
+
+```javascript
+// plugins/glossary-plugin.js
+const { visit } = require("unist-util-visit");
+const fs = require("fs");
+const path = require("path");
+const yaml = require("js-yaml");
+
+module.exports = function glossaryPlugin(options = {}) {
+  const {
+    termsDir = "./docs/terms",
+    docsDir = "./docs",
+    glossaryFilepath = "./docs/glossary.md",
+  } = options;
+
+  // Load all term files
+  const loadTerms = () => {
+    const terms = {};
+    const termFiles = fs.readdirSync(termsDir);
+
+    termFiles.forEach((file) => {
+      if (!file.endsWith(".md")) return;
+
+      const content = fs.readFileSync(path.join(termsDir, file), "utf-8");
+      const [, frontmatter, body] = content.match(
+        /^---\n([\s\S]+?)\n---\n([\s\S]*)$/,
+      );
+
+      const meta = yaml.load(frontmatter);
+      terms[meta.id] = {
+        title: meta.title,
+        hoverText: meta.hoverText || body.slice(0, 200),
+        path: `terms/${file.replace(".md", "")}`,
+      };
+    });
+
+    return terms;
+  };
+
+  return function transformer(ast, vfile) {
+    const terms = loadTerms();
+
+    // Convert [[term]] syntax to tooltipped links
+    visit(ast, "text", (node, index, parent) => {
+      const matches = [...node.value.matchAll(/\[\[(.+?)\]\]/g)];
+
+      if (matches.length === 0) return;
+
+      const newNodes = [];
+      let lastIndex = 0;
+
+      matches.forEach((match) => {
+        const [fullMatch, termKey] = match;
+        const term = terms[termKey];
+
+        if (!term) {
+          console.warn(`Term not found: ${termKey}`);
+          return;
+        }
+
+        // Add text before match
+        if (match.index > lastIndex) {
+          newNodes.push({
+            type: "text",
+            value: node.value.slice(lastIndex, match.index),
+          });
+        }
+
+        // Add glossary link with tooltip
+        newNodes.push({
+          type: "jsx",
+          value: `<GlossaryTerm term="${termKey}" tooltip="${term.hoverText}" href="/${term.path}">${term.title}</GlossaryTerm>`,
+        });
+
+        lastIndex = match.index + fullMatch.length;
+      });
+
+      // Remaining text
+      if (lastIndex < node.value.length) {
+        newNodes.push({
+          type: "text",
+          value: node.value.slice(lastIndex),
+        });
+      }
+
+      parent.children.splice(index, 1, ...newNodes);
+    });
+
+    return ast;
+  };
+};
+```
+
+## Package Dependencies
+
+```json
+{
+  "dependencies": {
+    "unist-util-visit": "^4.0.0"
+  },
+  "peerDependencies": {
+    "@docusaurus/core": "^3.0.0",
+    "remark": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/unist": "^2.0.0",
+    "jest": "^29.0.0"
+  }
+}
+```
+
+## TypeScript Definitions
+
+```typescript
+// index.d.ts
+import { Plugin } from "unified";
+import { Root } from "mdast";
+
+export interface RemarkPluginOptions {
+  pattern?: RegExp;
+  dataFile?: string;
+  componentName?: string;
+  termsDir?: string;
+  docsDir?: string;
+  glossaryFilepath?: string;
+}
+
+declare const remarkPlugin: Plugin<[RemarkPluginOptions?], Root>;
+export default remarkPlugin;
+```
+
+## Testing
+
+```javascript
+// __tests__/plugin.test.js
+const remark = require("remark");
+const remarkMdx = require("remark-mdx");
+const glossaryPlugin = require("../index");
+
+describe("Glossary Plugin", () => {
+  const processor = remark().use(remarkMdx).use(glossaryPlugin, {
+    termsDir: "./__fixtures__/terms",
+  });
+
+  it("transforms glossary syntax", async () => {
+    const input = "This is a [[test-term]] example.";
+    const result = await processor.process(input);
+
+    expect(result.toString()).toContain("<GlossaryTerm");
+    expect(result.toString()).toContain("test-term");
+  });
+
+  it("handles missing terms gracefully", async () => {
+    const input = "This is a [[missing-term]] example.";
+    const result = await processor.process(input);
+
+    // Should leave unmatched terms as-is or show warning
+    expect(result.toString()).toBeTruthy();
+  });
+});
+```
+
+## Best Practices
+
+1. **Keep dependencies minimal** - Only use `unist-util-visit` for traversal
+2. **Cache external data** - Load files once, not per-transform
+3. **Handle missing data gracefully** - Don't crash on missing terms/files
+4. **Preserve node position** - Maintain `position` property for error reporting
+5. **Use JSX nodes for components** - Type `jsx` integrates with MDX
+6. **Validate options** - Provide sensible defaults
+7. **Support async operations** - Use `async/await` when reading files
+8. **Add TypeScript definitions** - Improves developer experience
+
+## Common Patterns
+
+### Auto-linking Terms
+
+Transform text patterns into links automatically.
+
+### Custom Syntax
+
+Add markdown extensions like `::note[text]` or `%%term%%`.
+
+### Content Generation
+
+Generate tables, lists, or summaries from markdown structure.
+
+### Link Validation
+
+Check internal links exist, add attributes to external links.
+
+### Metadata Injection
+
+Add frontmatter data as HTML attributes or classes.
+
+## Debugging
+
+```javascript
+// Add logging to see AST structure
+visit(ast, (node) => {
+  console.log(JSON.stringify(node, null, 2));
+});
+
+// Log only specific types
+visit(ast, "link", (node) => {
+  console.log("Link:", node.url);
+});
+```
+
+Use online AST explorers:
+
+- https://astexplorer.net/ (select "Markdown" and "remark")
diff --git a/.claude/skills/docusaurus-plugins/references/theme-plugins.md b/.claude/skills/docusaurus-plugins/references/theme-plugins.md
new file mode 100644
index 000000000..46696f5b3
--- /dev/null
+++ b/.claude/skills/docusaurus-plugins/references/theme-plugins.md
@@ -0,0 +1,578 @@
+# Theme Plugins for Docusaurus
+
+Theme plugins provide custom **themes** and allow **component swizzling** to override default Docusaurus components.
+
+## When to Use Theme Plugins
+
+- Create custom themes
+- Override default components (Navbar, Footer, etc.)
+- Provide reusable component sets
+- Brand customization across sites
+- Custom layouts
+
+## Theme Plugin Structure
+
+```javascript
+// plugins/theme-custom/index.js
+const path = require("path");
+
+module.exports = function themePlugin(context, options) {
+  return {
+    name: "docusaurus-theme-custom",
+
+    getThemePath() {
+      // Return path to theme components
+      return path.resolve(__dirname, "./theme");
+    },
+
+    getTypeScriptThemePath() {
+      // Return path to TypeScript theme types
+      return path.resolve(__dirname, "./theme");
+    },
+
+    getClientModules() {
+      // Global CSS and client-side code
+      return [
+        path.resolve(__dirname, "./theme/global.css"),
+        path.resolve(__dirname, "./theme/prism-theme.js"),
+      ];
+    },
+  };
+};
+```
+
+## Theme Directory Structure
+
+```
+plugins/theme-custom/
+├── index.js                    # Plugin definition
+└── theme/
+    ├── global.css              # Global styles
+    ├── Layout.js               # Main layout component
+    ├── Navbar.js               # Navigation bar
+    ├── Footer.js               # Footer
+    ├── DocPage.js              # Documentation page layout
+    ├── BlogPostPage.js         # Blog post layout
+    ├── MDXComponents.js        # Custom MDX components
+    └── hooks/
+        └── useCustomHook.js    # Custom React hooks
+```
+
+## Configuration
+
+```javascript
+// docusaurus.config.js
+module.exports = {
+  themes: [
+    "./plugins/theme-custom",
+    // Or npm package
+    "@org/docusaurus-theme-custom",
+  ],
+
+  // Or with options
+  themes: [
+    [
+      "./plugins/theme-custom",
+      {
+        customColors: {
+          primary: "#007bff",
+          secondary: "#6c757d",
+        },
+      },
+    ],
+  ],
+};
+```
+
+## Component Swizzling
+
+### What is Swizzling?
+
+Swizzling allows you to **override** or **wrap** default Docusaurus components.
+
+### Swizzle Commands
+
+```bash
+# List all swizzleable components
+npm run swizzle @docusaurus/theme-classic -- --list
+
+# Eject a component (full control, breaks with updates)
+npm run swizzle @docusaurus/theme-classic Navbar -- --eject
+
+# Wrap a component (safer, preserves original)
+npm run swizzle @docusaurus/theme-classic Navbar -- --wrap
+
+# Swizzle TypeScript version
+npm run swizzle @docusaurus/theme-classic Navbar -- --typescript
+```
+
+### Ejecting vs Wrapping
+
+**Ejecting (--eject)**
+
+- Full control over component
+- Copy entire component to your src/theme
+- ⚠️ Breaks with Docusaurus updates
+- Use for major customizations
+
+**Wrapping (--wrap)**
+
+- Wraps original component
+- Preserve default behavior
+- ✅ Safer, updates compatible
+- Use for minor additions
+
+## Example: Custom Theme Components
+
+### 1. Custom Navbar
+
+```javascript
+// theme/Navbar.js
+import React from "react";
+import Link from "@docusaurus/Link";
+import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
+import "./Navbar.css";
+
+export default function Navbar() {
+  const { siteConfig } = useDocusaurusContext();
+
+  return (
+    <nav className="custom-navbar">
+      <div className="navbar-brand">
+        <Link to="/">
+          <img src={siteConfig.logo} alt={siteConfig.title} />
+          <span>{siteConfig.title}</span>
+        </Link>
+      </div>
+
+      <div className="navbar-links">
+        <Link to="/docs">Docs</Link>
+        <Link to="/blog">Blog</Link>
+        <Link to="/about">About</Link>
+      </div>
+
+      <div className="navbar-actions">
+        <button className="theme-toggle">🌓</button>
+        <a href={siteConfig.githubUrl} className="github-link">
+          GitHub
+        </a>
+      </div>
+    </nav>
+  );
+}
+```
+
+### 2. Custom Footer
+
+```javascript
+// theme/Footer.js
+import React from "react";
+import Link from "@docusaurus/Link";
+import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
+
+export default function Footer() {
+  const { siteConfig } = useDocusaurusContext();
+  const currentYear = new Date().getFullYear();
+
+  return (
+    <footer className="custom-footer">
+      <div className="footer-content">
+        <div className="footer-section">
+          <h4>Documentation</h4>
+          <ul>
+            <li>
+              <Link to="/docs/intro">Getting Started</Link>
+            </li>
+            <li>
+              <Link to="/docs/api">API Reference</Link>
+            </li>
+            <li>
+              <Link to="/docs/guides">Guides</Link>
+            </li>
+          </ul>
+        </div>
+
+        <div className="footer-section">
+          <h4>Community</h4>
+          <ul>
+            <li>
+              <a href={siteConfig.discord}>Discord</a>
+            </li>
+            <li>
+              <a href={siteConfig.twitter}>Twitter</a>
+            </li>
+            <li>
+              <a href={siteConfig.github}>GitHub</a>
+            </li>
+          </ul>
+        </div>
+
+        <div className="footer-section">
+          <h4>More</h4>
+          <ul>
+            <li>
+              <Link to="/blog">Blog</Link>
+            </li>
+            <li>
+              <a href="/changelog">Changelog</a>
+            </li>
+            <li>
+              <Link to="/privacy">Privacy Policy</Link>
+            </li>
+          </ul>
+        </div>
+      </div>
+
+      <div className="footer-bottom">
+        <p>
+          © {currentYear} {siteConfig.organizationName}. All rights reserved.
+        </p>
+      </div>
+    </footer>
+  );
+}
+```
+
+### 3. Custom MDX Components
+
+```javascript
+// theme/MDXComponents.js
+import React from "react";
+import MDXComponents from "@theme-original/MDXComponents";
+import Highlight from "@site/src/components/Highlight";
+import CodeBlock from "@theme/CodeBlock";
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+// Custom components available in MDX
+export default {
+  ...MDXComponents,
+
+  // Override default components
+  code: CodeBlock,
+
+  // Add custom components
+  Highlight,
+  Callout: ({ type = "info", children }) => (
+    <div className={`callout callout-${type}`}>{children}</div>
+  ),
+
+  YouTube: ({ id }) => (
+    <div className="video-container">
+      <iframe
+        src={`https://www.youtube.com/embed/${id}`}
+        frameBorder="0"
+        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+        allowFullScreen
+      />
+    </div>
+  ),
+
+  Tabs,
+  TabItem,
+};
+```
+
+### 4. Custom Layout
+
+```javascript
+// theme/Layout.js
+import React from "react";
+import Head from "@docusaurus/Head";
+import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
+import Navbar from "@theme/Navbar";
+import Footer from "@theme/Footer";
+import "./Layout.css";
+
+export default function Layout({ children, title, description }) {
+  const { siteConfig } = useDocusaurusContext();
+  const pageTitle = title ? `${title} | ${siteConfig.title}` : siteConfig.title;
+
+  return (
+    <>
+      <Head>
+        <title>{pageTitle}</title>
+        <meta name="description" content={description || siteConfig.tagline} />
+        <meta property="og:title" content={pageTitle} />
+        <meta
+          property="og:description"
+          content={description || siteConfig.tagline}
+        />
+      </Head>
+
+      <div className="layout">
+        <Navbar />
+        <main className="main-content">{children}</main>
+        <Footer />
+      </div>
+    </>
+  );
+}
+```
+
+### 5. Wrapped Component Example
+
+```javascript
+// theme/DocPage.js (wrapped)
+import React from "react";
+import DocPage from "@theme-original/DocPage";
+import { useLocation } from "@docusaurus/router";
+
+export default function DocPageWrapper(props) {
+  const location = useLocation();
+
+  // Add custom behavior before/after original component
+  React.useEffect(() => {
+    console.log("Doc page viewed:", location.pathname);
+  }, [location]);
+
+  return (
+    <>
+      {/* Custom elements before */}
+      <div className="custom-banner">Special announcement!</div>
+
+      {/* Original DocPage component */}
+      <DocPage {...props} />
+
+      {/* Custom elements after */}
+      <div className="custom-feedback">Was this helpful?</div>
+    </>
+  );
+}
+```
+
+## Global Styles
+
+```css
+/* theme/global.css */
+:root {
+  /* Custom CSS variables */
+  --ifm-color-primary: #2e8555;
+  --ifm-color-primary-dark: #29784c;
+  --ifm-color-primary-darker: #277148;
+  --ifm-color-primary-darkest: #205d3b;
+  --ifm-color-primary-light: #33925d;
+  --ifm-color-primary-lighter: #359962;
+  --ifm-color-primary-lightest: #3cad6e;
+
+  --ifm-code-font-size: 95%;
+  --ifm-font-family-base: "Inter", system-ui, sans-serif;
+}
+
+html[data-theme="dark"] {
+  --ifm-color-primary: #25c2a0;
+  --ifm-background-color: #1b1b1d;
+}
+
+/* Custom styles */
+.custom-navbar {
+  /* Navbar styles */
+}
+
+.custom-footer {
+  /* Footer styles */
+}
+```
+
+## Custom Prism Theme
+
+```javascript
+// theme/prism-theme.js
+const theme = {
+  plain: {
+    color: "#F8F8F2",
+    backgroundColor: "#282A36",
+  },
+  styles: [
+    {
+      types: ["prolog", "constant", "builtin"],
+      style: {
+        color: "rgb(189, 147, 249)",
+      },
+    },
+    {
+      types: ["inserted", "function"],
+      style: {
+        color: "rgb(80, 250, 123)",
+      },
+    },
+    {
+      types: ["deleted"],
+      style: {
+        color: "rgb(255, 85, 85)",
+      },
+    },
+    {
+      types: ["changed"],
+      style: {
+        color: "rgb(255, 184, 108)",
+      },
+    },
+    {
+      types: ["punctuation", "symbol"],
+      style: {
+        color: "rgb(248, 248, 242)",
+      },
+    },
+    {
+      types: ["string", "char", "tag", "selector"],
+      style: {
+        color: "rgb(255, 121, 198)",
+      },
+    },
+    {
+      types: ["keyword", "variable"],
+      style: {
+        color: "rgb(189, 147, 249)",
+        fontStyle: "italic",
+      },
+    },
+    {
+      types: ["comment"],
+      style: {
+        color: "rgb(98, 114, 164)",
+      },
+    },
+  ],
+};
+
+export default theme;
+```
+
+## Package Structure
+
+```json
+{
+  "name": "@org/docusaurus-theme-custom",
+  "version": "1.0.0",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "keywords": ["docusaurus", "theme"],
+
+  "peerDependencies": {
+    "@docusaurus/core": "^3.0.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0"
+  },
+
+  "dependencies": {
+    "clsx": "^2.0.0"
+  }
+}
+```
+
+## TypeScript Support
+
+```typescript
+// index.d.ts
+import { Plugin, LoadContext } from "@docusaurus/types";
+
+export interface ThemeOptions {
+  customColors?: {
+    primary?: string;
+    secondary?: string;
+  };
+}
+
+declare const theme: (
+  context: LoadContext,
+  options: ThemeOptions,
+) => Plugin<void>;
+
+export default theme;
+```
+
+## Best Practices
+
+1. **Prefer wrapping over ejecting** - More update-safe
+2. **Use CSS variables** - Easy theming and consistency
+3. **Keep components modular** - Reusable across pages
+4. **Provide TypeScript types** - Better DX
+5. **Document swizzled components** - Team awareness
+6. **Test responsive design** - Mobile-first approach
+7. **Maintain accessibility** - ARIA labels, keyboard navigation
+
+## Common Customizations
+
+### Dark Mode Toggle
+
+```javascript
+// theme/ColorModeToggle.js
+import React from "react";
+import { useColorMode } from "@docusaurus/theme-common";
+
+export default function ColorModeToggle() {
+  const { colorMode, setColorMode } = useColorMode();
+
+  return (
+    <button
+      onClick={() => setColorMode(colorMode === "dark" ? "light" : "dark")}
+      aria-label="Toggle dark mode"
+    >
+      {colorMode === "dark" ? "🌞" : "🌙"}
+    </button>
+  );
+}
+```
+
+### Search Integration
+
+```javascript
+// theme/SearchBar.js
+import React from "react";
+import { DocSearch } from "@docsearch/react";
+
+export default function SearchBar() {
+  return (
+    <DocSearch
+      appId="YOUR_APP_ID"
+      indexName="YOUR_INDEX_NAME"
+      apiKey="YOUR_SEARCH_API_KEY"
+    />
+  );
+}
+```
+
+### Version Dropdown
+
+```javascript
+// theme/NavbarItem/DocsVersionDropdown.js
+import React from "react";
+import {
+  useActiveVersion,
+  useVersions,
+} from "@docusaurus/plugin-content-docs/client";
+
+export default function DocsVersionDropdown() {
+  const versions = useVersions();
+  const activeVersion = useActiveVersion();
+
+  return (
+    <select
+      value={activeVersion.name}
+      onChange={(e) => (window.location.href = e.target.value)}
+    >
+      {versions.map((version) => (
+        <option key={version.name} value={version.path}>
+          {version.label}
+        </option>
+      ))}
+    </select>
+  );
+}
+```
+
+## Debugging
+
+Check which components can be swizzled:
+
+```bash
+npm run swizzle @docusaurus/theme-classic -- --list
+```
+
+Find component source code:
+
+```bash
+# Located in node_modules/@docusaurus/theme-classic/src/theme/
+ls node_modules/@docusaurus/theme-classic/src/theme/
+```
diff --git a/.claude/skills/docusaurus-themes/README.md b/.claude/skills/docusaurus-themes/README.md
new file mode 100644
index 000000000..69a541773
--- /dev/null
+++ b/.claude/skills/docusaurus-themes/README.md
@@ -0,0 +1,14 @@
+# Docusaurus Swizzle
+
+Use when swizzling Docusaurus theme components and editing theme elements
+
+## Structure
+
+- `SKILL.md` - Main skill instructions
+- `references/` - Detailed documentation loaded as needed
+- `scripts/` - Executable code for deterministic operations
+- `assets/` - Templates, images, or other resources
+
+## Usage
+
+This skill is automatically discovered by Claude when relevant to the task.
diff --git a/.claude/skills/docusaurus-themes/SKILL.md b/.claude/skills/docusaurus-themes/SKILL.md
new file mode 100644
index 000000000..741c95d0a
--- /dev/null
+++ b/.claude/skills/docusaurus-themes/SKILL.md
@@ -0,0 +1,62 @@
+---
+name: docusaurus-themes
+# IMPORTANT: Keep description on ONE line for Claude Code compatibility
+# prettier-ignore
+description: Use when swizzling Docusaurus theme components and editing theme elements
+---
+
+# Docusaurus Swizzle
+
+## Quick Start
+
+Swizzle components to customize Docusaurus theme behavior:
+
+```bash
+npm run swizzle @docusaurus/theme-classic ComponentName -- --wrap
+```
+
+## Core Principles
+
+- **Wrap** (safe): Extends original component, easier to upgrade
+- **Eject** (unsafe): Full copy for maximum control, harder to maintain
+- **Interactive mode**: Use `npm run swizzle` to browse available components
+- Swizzled components go in `src/theme/ComponentName/`
+
+## Common Patterns
+
+**List available components:**
+
+```bash
+npm run swizzle @docusaurus/theme-classic -- --list
+```
+
+**Commonly swizzled:** Footer, Navbar, DocItem, DocSidebar, TOC
+
+## Reference Files
+
+For detailed documentation, see:
+
+- [references/commands.md](references/commands.md) - All swizzle commands and options
+- [references/components.md](references/components.md) - Component-specific guides
+
+## Notes
+
+- Prefer `--wrap` for minor changes to maintain upgrade compatibility
+- Test thoroughly after swizzling components
+- Check official docs for component-specific swizzle safety ratings
+
+<!--
+PROGRESSIVE DISCLOSURE GUIDELINES:
+- Keep this file ~50 lines total (max ~150 lines)
+- Use 1-2 code blocks only (recommend 1)
+- Keep description <200 chars for Level 1 efficiency
+- Move detailed docs to references/ for Level 3 loading
+- This is Level 2 - quick reference ONLY, not a manual
+
+LLM WORKFLOW (when editing this file):
+1. Write/edit SKILL.md
+2. Format (if formatter available)
+3. Run: claude-skills-cli validate <path>
+4. If multi-line description warning: run claude-skills-cli doctor <path>
+5. Validate again to confirm
+-->
diff --git a/.claude/skills/docusaurus-themes/references/commands.md b/.claude/skills/docusaurus-themes/references/commands.md
new file mode 100644
index 000000000..c5372fff0
--- /dev/null
+++ b/.claude/skills/docusaurus-themes/references/commands.md
@@ -0,0 +1,113 @@
+# Docusaurus Swizzle Commands Reference
+
+## Basic Commands
+
+### Interactive Swizzling
+
+Browse and select components interactively:
+
+```bash
+npm run swizzle
+```
+
+This will prompt you to:
+
+1. Select a theme (e.g., @docusaurus/theme-classic)
+2. Choose a component to swizzle
+3. Select wrap or eject mode
+
+### List Available Components
+
+See all swizzlable components from a theme:
+
+```bash
+npm run swizzle @docusaurus/theme-classic -- --list
+```
+
+### Safe Swizzle (Wrap)
+
+Wrap a component to add customizations while keeping the original:
+
+```bash
+npm run swizzle @docusaurus/theme-classic ComponentName -- --wrap
+```
+
+**When to use wrap:**
+
+- You want to add functionality without replacing the original
+- You need to preserve upgrade compatibility
+- You're making minor customizations
+
+### Unsafe Swizzle (Eject)
+
+Eject to fully replace and customize a component:
+
+```bash
+npm run swizzle @docusaurus/theme-classic ComponentName -- --eject
+```
+
+**When to use eject:**
+
+- You need full control over component internals
+- You're making significant structural changes
+- You understand you'll need to manually merge updates
+
+## Command Options
+
+- `--wrap` - Safe swizzle mode (wraps original component)
+- `--eject` - Unsafe swizzle mode (copies full source)
+- `--list` - List all available components to swizzle
+- `--typescript` - Generate TypeScript files (default)
+- `--javascript` - Generate JavaScript files
+
+## File Locations
+
+After swizzling, components are created in:
+
+- `src/theme/ComponentName/` - Directory-based components (with index.tsx)
+- `src/theme/ComponentName.tsx` - Single-file components
+
+## Examples
+
+### Example: Swizzle Footer
+
+```bash
+npm run swizzle @docusaurus/theme-classic Footer -- --eject
+```
+
+After running this, edit the footer in `src/theme/Footer/index.tsx`.
+
+### Example: Wrap Navbar
+
+```bash
+npm run swizzle @docusaurus/theme-classic Navbar -- --wrap
+```
+
+This creates a wrapper in `src/theme/Navbar/index.tsx` that imports and extends the original.
+
+### Example: List and Choose
+
+```bash
+# First, see what's available
+npm run swizzle @docusaurus/theme-classic -- --list
+
+# Then swizzle the component you need
+npm run swizzle @docusaurus/theme-classic DocItem -- --wrap
+```
+
+## Troubleshooting
+
+**Component not found:**
+
+- Ensure you're using the correct theme package name
+- Run `--list` to see available components
+
+**TypeScript errors after swizzling:**
+
+- Check that you have the correct type definitions installed
+- Ensure your tsconfig.json includes the src/theme directory
+
+**Changes not appearing:**
+
+- Clear the `.docusaurus` cache: `npm run clear`
+- Restart the development server
diff --git a/.claude/skills/docusaurus-themes/references/components.md b/.claude/skills/docusaurus-themes/references/components.md
new file mode 100644
index 000000000..abb8c32a1
--- /dev/null
+++ b/.claude/skills/docusaurus-themes/references/components.md
@@ -0,0 +1,173 @@
+# Common Docusaurus Components to Swizzle
+
+## Layout Components
+
+### Footer
+
+**Path:** `src/theme/Footer/`
+**Use case:** Customize footer content, links, copyright, social media icons
+
+**Example customization:**
+
+```tsx
+import React from "react";
+import Footer from "@theme-original/Footer";
+
+export default function FooterWrapper(props) {
+  return (
+    <>
+      <Footer {...props} />
+      <div className="custom-footer-section">
+        {/* Add custom footer content */}
+      </div>
+    </>
+  );
+}
+```
+
+### Navbar
+
+**Path:** `src/theme/Navbar/`
+**Use case:** Modify navigation bar appearance, add custom elements, change behavior
+
+**Common modifications:**
+
+- Add custom logo behavior
+- Insert additional navigation items
+- Modify mobile menu behavior
+
+### Layout
+
+**Path:** `src/theme/Layout/`
+**Use case:** Wrap all pages with custom providers, analytics, or global components
+
+## Documentation Components
+
+### DocItem
+
+**Path:** `src/theme/DocItem/`
+**Use case:** Customize documentation page layout, add custom elements to doc pages
+
+**Common modifications:**
+
+- Add custom headers or footers to docs
+- Insert advertisements or announcements
+- Add custom metadata display
+
+### DocSidebar
+
+**Path:** `src/theme/DocSidebar/`
+**Use case:** Adjust sidebar behavior, styling, and interaction
+
+**Common modifications:**
+
+- Custom sidebar item rendering
+- Add search functionality to sidebar
+- Change collapsible behavior
+
+### TOC (Table of Contents)
+
+**Path:** `src/theme/TOC/`
+**Use case:** Modify table of contents display, add custom elements
+
+**Common modifications:**
+
+- Add "Edit this page" links
+- Customize heading filtering
+- Add custom TOC actions
+
+## Blog Components
+
+### BlogPostPage
+
+**Path:** `src/theme/BlogPostPage/`
+**Use case:** Customize blog post layout and structure
+
+### BlogListPage
+
+**Path:** `src/theme/BlogListPage/`
+**Use case:** Modify blog list view, pagination, filtering
+
+## Code Components
+
+### CodeBlock
+
+**Path:** `src/theme/CodeBlock/`
+**Use case:** Customize code block rendering, add features like copy button customization
+
+### MDXComponents
+
+**Path:** `src/theme/MDXComponents/`
+**Use case:** Override or extend default MDX components used in markdown
+
+## Best Practices by Component
+
+### Safe to Wrap (Low Risk)
+
+- Footer - Usually safe to wrap for adding content
+- Navbar - Wrapping is often sufficient for minor changes
+- Layout - Good candidate for wrapping to add providers
+
+### Consider Ejecting (When Needed)
+
+- CodeBlock - Often need full control for custom highlighting
+- DocItem - May need eject for significant layout changes
+- BlogPostPage - Eject for custom post templates
+
+## Swizzle Safety Levels
+
+Docusaurus marks components with safety levels:
+
+- **Safe**: Safe to swizzle, low breaking change risk
+- **Unsafe**: May break with Docusaurus updates
+- **Forbidden**: Cannot be swizzled (internal components)
+
+Check safety level:
+
+```bash
+npm run swizzle @docusaurus/theme-classic -- --list
+```
+
+Components are marked with their safety level in the list output.
+
+## Component Hierarchies
+
+Understanding component relationships helps you choose what to swizzle:
+
+```
+Layout (top-level wrapper)
+├── Navbar
+├── DocPage
+│   ├── DocSidebar
+│   └── DocItem
+│       └── TOC
+└── Footer
+```
+
+**Tip:** Swizzle at the lowest level that meets your needs to minimize maintenance burden.
+
+## Examples by Use Case
+
+### Use Case: Add Custom Analytics
+
+**Component:** Layout
+**Mode:** Wrap
+**Why:** Wrapping Layout lets you add providers without replacing core functionality
+
+### Use Case: Custom Footer Design
+
+**Component:** Footer
+**Mode:** Eject
+**Why:** Significant design changes usually require full control
+
+### Use Case: Add Version Badge to Docs
+
+**Component:** DocItem
+**Mode:** Wrap
+**Why:** Can inject custom elements without modifying core doc rendering
+
+### Use Case: Custom Syntax Highlighting
+
+**Component:** CodeBlock
+**Mode:** Eject
+**Why:** Deep integration with highlighting engine requires full access
diff --git a/.claude/skills/google-style-guide/README.md b/.claude/skills/google-style-guide/README.md
new file mode 100644
index 000000000..a97371192
--- /dev/null
+++ b/.claude/skills/google-style-guide/README.md
@@ -0,0 +1,14 @@
+# Google Style Guide
+
+Google's documentation style guide for technical writing - https://developers.google.com/style
+
+## Structure
+
+- `SKILL.md` - Main skill instructions
+- `references/` - Detailed documentation loaded as needed
+- `scripts/` - Executable code for deterministic operations
+- `assets/` - Templates, images, or other resources
+
+## Usage
+
+This skill is automatically discovered by Claude when relevant to the task.
diff --git a/.claude/skills/google-style-guide/SKILL.md b/.claude/skills/google-style-guide/SKILL.md
new file mode 100644
index 000000000..f42c665ec
--- /dev/null
+++ b/.claude/skills/google-style-guide/SKILL.md
@@ -0,0 +1,77 @@
+---
+name: google-style-guide
+# IMPORTANT: Keep description on ONE line for Claude Code compatibility
+# prettier-ignore
+description: Use when writing or reviewing technical documentation to follow Google's documentation style guide - https://developers.google.com/style
+---
+
+# Google Style Guide
+
+## Quick Start
+
+Apply Google's documentation style guide principles to technical writing:
+
+- Use **active voice** and **present tense**
+- Write clear, concise headings
+- Use numbered lists for procedures, bulleted lists for non-sequential items
+- Put conditional clauses before instructions
+
+## Core Principles
+
+- **Clarity first**: Write for software developers and technical practitioners
+- **Consistency**: Follow project-specific > Google > third-party style guides
+- **Accessibility**: Use inclusive language and consider global audiences
+- **Timeless**: Avoid time-specific references; use "currently" or "as of [date]"
+- **Reader-focused**: Prioritize user understanding over strict grammatical rules
+
+## Common Patterns
+
+### Voice and Tense
+
+Use active voice and present tense. Example: "The API returns..." not "The API will return..."
+
+### Headings
+
+Use sentence case for headings. Make them descriptive and actionable.
+
+### Lists and Procedures
+
+- Numbered lists: For sequential steps
+- Bulleted lists: For non-sequential items
+- Start each item with a capital letter
+
+### Code and UI Elements
+
+- Use `code font` for code elements, filenames, and UI elements
+- Use **bold** for UI elements users interact with
+- Use descriptive placeholder names like `YOUR_PROJECT_ID`
+
+## Reference Files
+
+For detailed documentation, see:
+
+- [references/language-grammar.md](references/language-grammar.md) - Voice, tense, pronouns
+- [references/formatting.md](references/formatting.md) - Dates, numbers, lists
+- [references/inclusive-language.md](references/inclusive-language.md) - Accessibility guidelines
+
+## Notes
+
+- Official guide: https://developers.google.com/style
+- Third-party references: Merriam-Webster (spelling), Chicago Manual of Style
+- When in doubt: Choose clarity over strict rule adherence
+
+<!--
+PROGRESSIVE DISCLOSURE GUIDELINES:
+- Keep this file ~50 lines total (max ~150 lines)
+- Use 1-2 code blocks only (recommend 1)
+- Keep description <200 chars for Level 1 efficiency
+- Move detailed docs to references/ for Level 3 loading
+- This is Level 2 - quick reference ONLY, not a manual
+
+LLM WORKFLOW (when editing this file):
+1. Write/edit SKILL.md
+2. Format (if formatter available)
+3. Run: claude-skills-cli validate <path>
+4. If multi-line description warning: run claude-skills-cli doctor <path>
+5. Validate again to confirm
+-->
diff --git a/.claude/skills/google-style-guide/references/formatting.md b/.claude/skills/google-style-guide/references/formatting.md
new file mode 100644
index 000000000..645bb64eb
--- /dev/null
+++ b/.claude/skills/google-style-guide/references/formatting.md
@@ -0,0 +1,233 @@
+# Formatting Guidelines
+
+## Lists
+
+### List Types
+
+**Numbered lists:**
+Use when sequence is significant (ordered steps, phases, priorities).
+
+**Example:**
+
+1. Open the configuration file.
+2. Add your API key.
+3. Save the file.
+
+**Bulleted lists:**
+Use for nonsequential items (options, features, examples).
+
+**Example:**
+
+- API supports JSON and XML
+- Rate limits apply per project
+- Authentication is required
+
+**Description lists:**
+Use for terms with descriptions, definitions, or explanations.
+
+**Example:**
+
+- **API Key**: A unique identifier for your project
+- **Endpoint**: The URL where you send requests
+- **Response**: The data returned by the API
+
+### Introductory Context
+
+Introduce lists with complete sentences.
+
+**Recommended:**
+
+- "The API supports the following formats:"
+- "To configure authentication, complete these steps:"
+
+**Introduce with colon:**
+Use a colon when the introduction immediately precedes the list.
+
+### Capitalization and Punctuation
+
+**For numbered, lettered, and bulleted lists:**
+
+**Capital letters:**
+
+- Start each item with a capital letter (unless case matters, like code)
+
+**Periods:**
+
+- Add periods to items containing verbs or complete thoughts
+- Omit punctuation for:
+  - Single-word items
+  - Items without verbs
+  - Code-only items
+  - Link text
+
+**Consistency rule:**
+If punctuation is inconsistent, either:
+
+1. Rewrite using parallel construction, or
+2. Add end punctuation to every item
+
+### Parallel Construction
+
+Use the same syntax/structure for all list items.
+
+**Recommended:**
+
+- Configure the settings
+- Install the dependencies
+- Run the tests
+
+**Avoid mixing structures:**
+
+- Configure the settings (verb phrase)
+- Dependencies must be installed (passive voice)
+- You should run the tests (full sentence)
+
+### Description List Formatting
+
+**Run-in headings:**
+
+- Bold the term
+- End consistently with periods OR colons within the same list
+
+**After periods:** Capitalize descriptions
+**After colons:** Use lowercase
+
+**Example with periods:**
+
+- **GET.** Retrieves data from the server.
+- **POST.** Sends data to the server.
+
+**Example with colons:**
+
+- **GET**: retrieves data from the server
+- **POST**: sends data to the server
+
+### Multiple Paragraphs in Lists
+
+Use `<p>` elements rather than `<br>` tags for list items with multiple paragraphs.
+
+## Comma-Separated Lists
+
+**Use serial commas:**
+"The API supports JSON, XML, and YAML formats."
+
+**Avoid ending with "etc."**
+Instead, introduce lists to clarify they're non-exhaustive.
+
+**Recommended:**
+"The API supports formats such as JSON, XML, and YAML."
+
+## Numbers
+
+### When to Use Numerals
+
+**Use numerals for:**
+
+- Numbers 10 and above
+- All numbers in technical contexts (measurements, versions, quantities)
+- Negative numbers
+- Decimals and fractions
+
+**Spell out:**
+
+- Numbers zero through nine (except in technical contexts)
+- Numbers at the beginning of sentences
+
+### Ranges
+
+Use en dash for ranges: "10–20 seconds"
+
+## Dates and Times
+
+### Date Format
+
+Use international format to avoid confusion:
+
+- **Recommended:** "17 January 2025" or "2025-01-17" (ISO 8601)
+- **Avoid:** "1/17/2025" (ambiguous internationally)
+
+### Time References
+
+**Avoid time-specific references:**
+
+- Don't use "currently" without a date
+- Don't use "recently," "soon," "in the future"
+
+**When necessary:**
+
+- "As of January 2025..."
+- "In version 2.0 (released January 2025)..."
+
+### Timezones
+
+Always specify timezone when providing specific times:
+
+- "The service updates at 00:00 UTC"
+- "Maintenance window: 3:00 AM–5:00 AM PST"
+
+## Code and Technical Elements
+
+### Code Font
+
+Use `code font` for:
+
+- Code elements (variables, functions, classes)
+- Filenames and paths
+- Command-line commands
+- API endpoints
+
+### UI Elements
+
+**Bold for interactive elements:**
+
+- Buttons: "Click **Submit**"
+- Menu items: "Select **File** > **Open**"
+
+### Placeholders
+
+Use descriptive placeholder names in ALL_CAPS:
+
+**Recommended:**
+
+```
+gcloud projects create YOUR_PROJECT_ID
+```
+
+**Make placeholders obvious:**
+
+- `YOUR_PROJECT_ID` not `project-id`
+- `YOUR_API_KEY` not `key`
+- `YOUR_REGION` not `region`
+
+## Procedures
+
+### Structure
+
+1. **Introduce the procedure** with a sentence describing what the user will accomplish
+2. **Number the steps** in sequence
+3. **Start each step with a verb** (imperative mood)
+4. **Put conditionals first:** "If X, then do Y" not "Do Y if X"
+
+### Example
+
+To deploy your application:
+
+1. Build the application:
+   ```
+   npm run build
+   ```
+2. If you haven't already, authenticate with the service:
+   ```
+   gcloud auth login
+   ```
+3. Deploy the build:
+   ```
+   gcloud app deploy
+   ```
+
+## Tables
+
+- Use tables for structured, comparable data
+- Include clear column headers
+- Keep cell content concise
+- Consider using lists for simple data
diff --git a/.claude/skills/google-style-guide/references/inclusive-language.md b/.claude/skills/google-style-guide/references/inclusive-language.md
new file mode 100644
index 000000000..62e013f12
--- /dev/null
+++ b/.claude/skills/google-style-guide/references/inclusive-language.md
@@ -0,0 +1,118 @@
+# Inclusive Language and Accessibility
+
+## Ableist Language
+
+Avoid ableist terms that marginalize people with disabilities.
+
+**Avoid:**
+
+- crazy, insane, blind to, cripple, dumb, lame, handicapped
+- "sanity-check" → use "final check for completeness"
+- "crazy outliers" → use "baffling outliers"
+
+## Gendered Language
+
+Replace gendered terms with neutral alternatives.
+
+**Avoid → Use:**
+
+- man-hours → person-hours
+- mankind → humanity
+- manpower → workforce, staffing
+- he/she → they
+
+## Violent Language
+
+Avoid graphically violent or harmful terms.
+
+**Replace violent metaphors:**
+
+- Avoid figurative language like "hang," "kill," "hit," "abort" when possible
+- Choose neutral alternatives that don't evoke violence
+
+## Diverse Examples
+
+Create inclusive examples in your documentation.
+
+### Name Diversity
+
+Use diverse names, genders, ages, and locations in examples.
+
+**Example names to consider:**
+
+- Avoid only Western names
+- Include names from various cultures
+- Use gender-neutral names when appropriate
+
+### Gender-Neutral Pronouns
+
+Consistently use "they/them" for singular references.
+
+### Avoid US-Centric References
+
+- Don't assume US location, currency, or cultural context
+- Use international date formats
+- Specify timezone when relevant
+
+## Writing About Older Adults
+
+**Recommended:**
+
+- "older adults"
+- "aging population"
+
+**Avoid:**
+
+- "elderly"
+- "seniors"
+- "the aged"
+
+## Disability and Accessibility
+
+### Describe People Appropriately
+
+**Don't:**
+
+- Describe nondisabled people as "normal" or "healthy"
+- Use terms like "wheelchair-bound" or "confined to a wheelchair"
+
+**Do:**
+
+- Use neutral terms: "uses a wheelchair"
+- Research community preferences for identity-first vs. person-first language
+- Note: The Deaf community often prefers "Deaf person" (identity-first)
+
+## Features and Technical Terms
+
+### Socially Charged Terms
+
+Replace socially charged technical terms.
+
+**Avoid → Use:**
+
+- blacklist → denylist, blocklist
+- whitelist → allowlist, allowedlist
+- master/slave → primary/replica, main/secondary
+
+### Acknowledging Established Terms
+
+For established industry terms, acknowledge the old term on first use:
+
+"Use an allowlist (sometimes called a whitelist) to specify..."
+
+### Divisive Categorizations
+
+**Avoid:**
+
+- "native speakers" vs. "non-native speakers"
+- "normal users" vs. other categorizations
+- Assumptions about user capabilities
+
+## General Principle
+
+When in doubt, choose language that:
+
+- Respects all people
+- Doesn't perpetuate stereotypes
+- Focuses on what people do, not who they are
+- Considers the global, diverse audience
diff --git a/.claude/skills/google-style-guide/references/language-grammar.md b/.claude/skills/google-style-guide/references/language-grammar.md
new file mode 100644
index 000000000..2ec144a4f
--- /dev/null
+++ b/.claude/skills/google-style-guide/references/language-grammar.md
@@ -0,0 +1,71 @@
+# Language and Grammar Guidelines
+
+## Active Voice
+
+Use active voice where the grammatical subject performs the action.
+
+**Recommended:**
+
+- "Send a query to the service."
+- "The server sends an acknowledgment."
+
+**Avoid passive voice like:**
+
+- "A query should be sent to the service."
+- "An acknowledgment is sent by the server."
+
+### Why Active Voice Matters
+
+Passive voice can obscure responsibility, making it unclear whether the reader, computer, server, or another entity should perform an action.
+
+### Exceptions
+
+Active voice isn't always required:
+
+- When emphasizing the object: "The file is saved"
+- When de-emphasizing the subject
+- When the actor's identity is irrelevant to readers
+
+## Present Tense
+
+Use present tense for actions and states.
+
+**Recommended:**
+
+- "The API returns a response."
+- "The function calculates the total."
+
+**Avoid future tense:**
+
+- "The API will return a response."
+- "The function will calculate the total."
+
+## Second Person
+
+Address the reader directly using "you" (implied or explicit).
+
+**Recommended:**
+
+- "To start the server, run the command."
+- "You can configure the settings in the config file."
+
+## Pronouns
+
+Use appropriate pronouns consistently throughout documentation.
+
+### Gender-Neutral Pronouns
+
+- Use "they/them" for singular gender-neutral references
+- Avoid gendered assumptions in examples
+
+**Recommended:**
+
+- "When a user logs in, they see their dashboard."
+
+**Avoid:**
+
+- "When a user logs in, he sees his dashboard."
+
+## Reference
+
+For deeper exploration, see Google's _Technical Writing One_ guide on active versus passive voice principles.
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 8be7d430e..286f3ebaa 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -5,13 +5,20 @@
 
 version: 2
 updates:
-  - package-ecosystem: "npm" # See documentation for possible values
-    directory: "/" # Location of package manifests
+  - package-ecosystem: "npm"
+    directory: "/"
     schedule:
       interval: "weekly"
     assignees:
-    - "mcclowes"
-    - "dcoplowe"
+      - "pmckinney-codat"
     reviewers:
-    - "mcclowes"
-    - "dcoplowe"
+      - "pmckinney-codat"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    assignees:
+      - "pmckinney-codat"
+    reviewers:
+      - "pmckinney-codat"
diff --git a/.github/workflows/check-links.yml b/.github/workflows/check-links.yml
index 10d9cb091..936b758ef 100644
--- a/.github/workflows/check-links.yml
+++ b/.github/workflows/check-links.yml
@@ -12,10 +12,10 @@ jobs:
     if: github.event_name != 'pull_request' || github.actor != 'codatbot' 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
-      
+        uses: actions/checkout@v4
+
       - name: Set up Node.js
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
           node-version: '20'
       
diff --git a/.github/workflows/check-spelling.yml b/.github/workflows/check-spelling.yml
index 38a480a46..0c725bbd8 100644
--- a/.github/workflows/check-spelling.yml
+++ b/.github/workflows/check-spelling.yml
@@ -22,4 +22,4 @@ jobs:
         run: npm install -g cspell
         
       - name: Run spell check
-        run: cspell "**/*.md" "**/*.mdx" --words-only cspell-words.txt 
\ No newline at end of file
+        run: cspell "**/*.md" "**/*.mdx" --config cspell.json
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 26775670f..5aa0d13ef 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,14 +1,57 @@
 # Dependencies
 /node_modules
+static/**/node_modules/
 
-# Production
+# Build outputs
 /build
-
-# Generated files
+/dist
 .docusaurus
 .cache-loader
-src/components/page/reference/ReleaseNotes/release-notes.json
+
+# Environment
+.env
+.env.*
+!.env.example
+
+# Logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+*.log
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDEs
+.idea/
+*.sln.iml
 /.vs
+.vscode/
+*.sublime-project
+*.sublime-workspace
+*.swp
+*.swo
+*~
+
+# Test coverage
+coverage/
+
+# Temp files
+*.tmp
+*.temp
+.cache/
+
+# Vercel
+.vercel
+
+# TypeScript
+*.tsbuildinfo
+
+# Generated files
+src/components/page/reference/ReleaseNotes/release-notes.json
 
 # Code utilities - generated files
 code_utils/files_with_code.txt
@@ -22,24 +65,3 @@ __pycache__/
 .venv/
 venv/
 env/
-dist/
-build/
-
-
-# Misc
-.DS_Store
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-.env
-
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-static/**/node_modules/
-
-# JetBrains Rider
-.idea/
-*.sln.iml
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 000000000..873ec6e31
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,39 @@
+# Claude Code Project Instructions
+
+This is the Codat documentation site, built with Docusaurus.
+
+## Project Structure
+
+- `docs/` - Main documentation content (Markdown/MDX)
+- `blog/` - Blog posts
+- `src/` - React components and custom pages
+- `static/` - Static assets (images, files)
+- `.github/workflows/` - CI/CD workflows
+
+## Development
+
+```sh
+npm install
+npm start
+```
+
+Requires Node.js v20+.
+
+## Code Style
+
+- Documentation is written in Markdown/MDX
+- Use Prettier for formatting (`npm run format:js:check`, `npm run format:mdx:check`)
+- Follow existing patterns for component structure
+
+## Testing
+
+- `npm run build` - Build the site
+- Spell check runs via cspell
+- Link checking via linkinator
+- Readability checks via Lexi
+
+## Key Files
+
+- `docusaurus.config.js` - Main Docusaurus configuration
+- `sidebars.js` - Sidebar navigation structure
+- `cspell.json` - Spell check dictionary and settings
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e6627ab4e..f662bc4df 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -13,7 +13,7 @@ $ npm install
 $ npm start
 ```
 
-We recommend npm -v 8+ and Node.js -v 16+.
+We recommend npm v10+ and Node.js v20+.
 
 ---
 
diff --git a/blog/250703-deprecation-enh-cashflow-endpoints.md b/blog/250703-deprecation-enh-cashflow-endpoints.md
index b39de4bc2..c1fd4dde0 100644
--- a/blog/250703-deprecation-enh-cashflow-endpoints.md
+++ b/blog/250703-deprecation-enh-cashflow-endpoints.md
@@ -5,7 +5,7 @@ tags: ["Deprecation", "Assess", "Enhanced Cashflow"]
 authors: ivasiutkova
 ---
 
-On **July 10, 2026**, the Enhanced Cashflow report type will be deprecated from the Assess endpoints. This follows the launch of its replacement, the **Categorized Bank Statement** report, available  through our report management workflow. The new workflow offers enhanced functionality and a more streamlined user experience.
+On **July 10, 2026**, the Enhanced Cashflow report type will be deprecated from the Assess endpoints. This follows the launch of its replacement, the **Categorized Bank Statement** report, available through our report management workflow. The new workflow offers enhanced functionality and a more streamlined user experience.
 
 <!--truncate-->
 
@@ -22,7 +22,6 @@ This deprecation affects the following endpoints:
 Only requests for the `enhancedCashFlow` report type will be affected. Other report types using Assess generation endpoints are unaffected.
 :::
 
-
 ## Action required
 
 To avoid disruption, update your integration to use the new [Manage Reports](/lending-api#/operations/generate-report) endpoints before July 10, 2026. For detailed, step-by-step instructions, refer to our [Migration guide](https://docs.codat.io/lending/features/enhanced-cash-flow-migration).
@@ -31,7 +30,6 @@ To avoid disruption, update your integration to use the new [Manage Reports](/le
 
 If your integration is not updated by **July 10, 2026**, all API calls to the deprecated `enhancedCashFlow` report type will fail. This will prevent the generation of these reports and may disrupt your application's functionality.
 
-
 :::note Get ahead of the change
 
 You can get ahead of this change by enabling the new Categorized Bank Statement report in the [Portal](https://app.codat.io/developers/api-deprecations). Learn how to do that [here](https://docs.codat.io/configure/portal/developers), or read our [change policy](https://docs.codat.io/using-the-api/change-policy).
diff --git a/blog/250801-oas-updates.md b/blog/250801-oas-updates.md
index 97d1540a9..0083b2750 100644
--- a/blog/250801-oas-updates.md
+++ b/blog/250801-oas-updates.md
@@ -9,12 +9,10 @@ This update summarizes recent changes made to our OpenAPI Specifications.
 
 <!--truncate-->
 
-
 ## Codat-Lending
 
 View the full API reference: [Codat-Lending](https://docs.codat.io/lending-api#/)
 
-
 ### New Endpoints
 
 - [`/companies/{companyId}/reports/creditModel/{reportId}/financialSummary`](https://docs.codat.io/lending-api#/operations/get-closed-books-indicator)
@@ -39,7 +37,6 @@ View the full API reference: [Codat-Lending](https://docs.codat.io/lending-api#/
 
 ## Codat-Spend-Insights
 
-
 ### Modified Endpoints
 
 - `/companies/{companyId}/reports/{reportType}/{reportId}/status`
@@ -48,7 +45,6 @@ View the full API reference: [Codat-Lending](https://docs.codat.io/lending-api#/
 
 ## Codat-Accounting
 
-
 ### Modified Endpoints
 
 - `/companies/{companyId}/connections/{connectionId}/options/customers`
@@ -69,7 +65,6 @@ View the full API reference: [Codat-Lending](https://docs.codat.io/lending-api#/
 
 View the full API reference: [Codat-Bank-Feeds](https://docs.codat.io/bank-feeds-api#/)
 
-
 ### Modified Endpoints
 
 - [`/companies/{companyId}/connections/{connectionId}/options/bankAccounts`](https://docs.codat.io/bank-feeds-api#/operations/get-create-bankAccounts-model)
@@ -78,7 +73,6 @@ View the full API reference: [Codat-Bank-Feeds](https://docs.codat.io/bank-feeds
 
 View the full API reference: [Codat-Sync-Expenses](https://docs.codat.io/sync-for-expenses-api#/)
 
-
 ### Modified Endpoints
 
 - [`/companies/{companyId}/sync/expenses/transfer-transactions/{transactionId}`](https://docs.codat.io/sync-for-expenses-api#/operations/create-transfer-transaction)
@@ -90,7 +84,6 @@ View the full API reference: [Codat-Sync-Expenses](https://docs.codat.io/sync-fo
 
 View the full API reference: [Codat-Sync-Payables-v1](https://docs.codat.io/sync-for-payables-api#/)
 
-
 ### Modified Endpoints
 
 - [`/companies/{companyId}/connections/{connectionId}/options/bankAccounts`](https://docs.codat.io/sync-for-payables-api#/operations/get-create-bankAccounts-model)
@@ -102,7 +95,6 @@ View the full API reference: [Codat-Sync-Payables-v1](https://docs.codat.io/sync
 
 ## Codat-Sync-Payroll
 
-
 ### Modified Endpoints
 
 - `/companies/{companyId}/connections/{connectionId}/options/journalEntries`
@@ -110,7 +102,6 @@ View the full API reference: [Codat-Sync-Payables-v1](https://docs.codat.io/sync
 
 ## Codat-Bank-Feeds-v2
 
-
 ### Modified Endpoints
 
 - `/companies/{companyId}/connections/{connectionId}/options/bankAccounts`
diff --git a/blog/250929-sage-intacct-financials.md b/blog/250929-sage-intacct-financials.md
index 40464cbff..f4ce54bfe 100644
--- a/blog/250929-sage-intacct-financials.md
+++ b/blog/250929-sage-intacct-financials.md
@@ -21,4 +21,3 @@ This update is relevant to **all clients using or planning to use** Codat’s [L
 ## How to get started?
 
 To enable Sage Intacct, follow our guide to [setting up Sage Intacct](/integrations/accounting/sage-intacct/accounting-sage-intacct-setup) and configure your instance to work with the enhanced financial statements feature.
-
diff --git a/blog/250930-jes-transactional-amount-currency.md b/blog/250930-jes-transactional-amount-currency.md
index 1cd591fda..5e7e67ba4 100644
--- a/blog/250930-jes-transactional-amount-currency.md
+++ b/blog/250930-jes-transactional-amount-currency.md
@@ -1,7 +1,18 @@
 ---
 title: "Journal Entries: Transactional amount and currency now supported"
 date: "2025-09-30"
-tags: ["Product", "Update", "Lending", "Quickbooks Online", "NetSuite", "Dynamics 365 BC", "Sage Intacct", "Sage 50", "Sage BC"]
+tags:
+  [
+    "Product",
+    "Update",
+    "Lending",
+    "Quickbooks Online",
+    "NetSuite",
+    "Dynamics 365 BC",
+    "Sage Intacct",
+    "Sage 50",
+    "Sage BC",
+  ]
 authors: ivasiutkova
 ---
 
@@ -14,12 +25,12 @@ We've expanded our data model to include **transactional amount** and **transact
 Our data model for **journal entries** now supports both the **transactional amount** and the **transactional currency** fields.  
 This enhancement is available for the following accounting and ERP software:
 
-- QuickBooks Online  
-- NetSuite  
-- Dynamics 365 Business Central  
-- Sage Intacct  
-- Sage 50  
-- Sage BC  
+- QuickBooks Online
+- NetSuite
+- Dynamics 365 Business Central
+- Sage Intacct
+- Sage 50
+- Sage BC
 
 You can now find these fields within `journalLines`:
 
diff --git a/blog/251003-closed-books-indicator.md b/blog/251003-closed-books-indicator.md
index 1e3c119f2..c126a2bc8 100644
--- a/blog/251003-closed-books-indicator.md
+++ b/blog/251003-closed-books-indicator.md
@@ -8,6 +8,7 @@ authors: ivasiutkova
 You can now see whether your customers’ accounting books are closed — and the date they were last closed.
 
 <!--truncate-->
+
 :::note Available as beta release
 This endpoint is part of a beta release. Please contact your account manager if you want to enable it.
 :::
@@ -28,4 +29,3 @@ All clients who need to know when their customers have officially closed their b
 
 Contact your **Account Manager** or our **support team** to enable this feature.  
 Once enabled, follow our [API documentation](/lending-api#/operations/get-closed-books-indicator) to implement the Closed Books Date Indicator in your application.
-
diff --git a/blog/251003-deprecation-of-integrations.md b/blog/251003-deprecation-of-integrations.md
index 0d17492e3..44756f3e5 100644
--- a/blog/251003-deprecation-of-integrations.md
+++ b/blog/251003-deprecation-of-integrations.md
@@ -5,7 +5,7 @@ tags: ["Deprecation"]
 authors: habbajobir
 ---
 
-To streamline our platform and enable us to focus on our key products, Codat is deprecating integrations with low or no usage. 
+To streamline our platform and enable us to focus on our key products, Codat is deprecating integrations with low or no usage.
 
 <!--truncate-->
 
@@ -14,27 +14,25 @@ To streamline our platform and enable us to focus on our key products, Codat is
 The following integrations will be **fully deprecated and permanently removed** from the Codat platform on **October 31, 2025**:
 
 | Commerce Integrations | Banking Integrations | Accounting Integrations |
-| :--- | :--- | :--- |
-| Lightspeed K | Tide | Reckon |
-| Mollie | Basiq | Chargify/ Maxio |
-| PayPal | | |
-| Prestashop | | |
+| :-------------------- | :------------------- | :---------------------- |
+| Lightspeed K          | Tide                 | Reckon                  |
+| Mollie                | Basiq                | Chargify/ Maxio         |
+| PayPal                |                      |                         |
+| Prestashop            |                      |                         |
 
 #### Action required
 
 If you don't use these integrations, there is no action required on your part. If you do use these integrations, please notify your clients to prevent any confusion.
 
-
 ## Q1 2026 deprecations
 
 The following integrations will be **fully deprecated and permanently removed** from the Codat platform on **January 10, 2026**:
 
 | Commerce Integrations | Accounting Integrations |
-| :--- | :--- |
-| SumUp | Kashflow |
-| Chargebee | Clear Books |
-| Recurly | Pandle |
-
+| :-------------------- | :---------------------- |
+| SumUp                 | Kashflow                |
+| Chargebee             | Clear Books             |
+| Recurly               | Pandle                  |
 
 #### Action required
 
diff --git a/blog/251003-deprecation-of-legacy-products.md b/blog/251003-deprecation-of-legacy-products.md
index 449b874e2..efb3580c6 100644
--- a/blog/251003-deprecation-of-legacy-products.md
+++ b/blog/251003-deprecation-of-legacy-products.md
@@ -13,25 +13,22 @@ To streamline our platform and enable us to focus on our key products, Codat is
 
 The following products will be **fully deprecated and permanently removed** from the Codat platform on **October 31, 2025**:
 
-
 ### Legacy products:
 
-* Visualise
-* Commerce Visualise
+- Visualise
+- Commerce Visualise
 
 #### Action required
 
 There is no action required on your part.
 
-
 ## Q1 2026 deprecations
 
 The following products will be **fully deprecated and permanently removed** from the Codat platform on **January 10, 2026**:
 
-
 ### Legacy versions of integrations:
 
-* Xero Bank Feeds v1- legacy version of Xero Bank Feeds
+- Xero Bank Feeds v1- legacy version of Xero Bank Feeds
 
 #### Action required
 
@@ -39,7 +36,7 @@ Impacted clients will be supported through migration to the new version, and the
 
 ### Legacy products:
 
-* Sync for Commerce (v1): This is a legacy product, and we will cease support for it from October 31, 2025. It will then be removed on January 10, 2026.
+- Sync for Commerce (v1): This is a legacy product, and we will cease support for it from October 31, 2025. It will then be removed on January 10, 2026.
 
 #### Action required
 
diff --git a/blog/251006-deprecation-quickbooks-desktop-changes-to-sync-schedule.md b/blog/251006-deprecation-quickbooks-desktop-changes-to-sync-schedule.md
index eca79211c..ba94d2019 100644
--- a/blog/251006-deprecation-quickbooks-desktop-changes-to-sync-schedule.md
+++ b/blog/251006-deprecation-quickbooks-desktop-changes-to-sync-schedule.md
@@ -12,6 +12,7 @@ On **January 10, 2026**, we will deprecate the current behavior where data is sy
 This change aligns with upcoming improvements to the QuickBooks Desktop Link flow, which will introduce **configurable sync schedules**. These enhancements are designed to minimize disruption by ensuring the Intuit Web Connector only runs at times defined by the customer.
 
 Under the new behavior (once available):
+
 - **Fetch on first link will no longer run immediately** after linking. It will wait until the next permitted sync window.
 - **All future syncs** will also respect the user-defined sync schedule, including any custom hours or pauses they configure.
 
@@ -27,4 +28,4 @@ To prepare for this change:
 
 ## Expected impact if no action is taken
 
-If no action is taken by **January 10, 2026**, new QuickBooks Desktop connections may appear inactive or missing data immediately after linking. Since initial and ongoing syncs will only run during the customer’s defined schedule, any assumptions that data will be available immediately may lead to broken workflows, delayed data processing, or incorrect user messaging.
\ No newline at end of file
+If no action is taken by **January 10, 2026**, new QuickBooks Desktop connections may appear inactive or missing data immediately after linking. Since initial and ongoing syncs will only run during the customer’s defined schedule, any assumptions that data will be available immediately may lead to broken workflows, delayed data processing, or incorrect user messaging.
diff --git a/blog/251006-quickbooks-desktop-improved-scheduling-and-reduced-disruption.md b/blog/251006-quickbooks-desktop-improved-scheduling-and-reduced-disruption.md
index 838bd6bbc..657ef52d7 100644
--- a/blog/251006-quickbooks-desktop-improved-scheduling-and-reduced-disruption.md
+++ b/blog/251006-quickbooks-desktop-improved-scheduling-and-reduced-disruption.md
@@ -16,6 +16,7 @@ We’ve updated the QuickBooks Desktop Link flow to provide clearer guidance on
 By default, data now syncs **7pm–7am, Monday to Friday and weekends**. This schedule is designed to **allow users to continue using QuickBooks Desktop while the Intuit Web Connector is running**.
 
 Users can also:
+
 - **Set custom sync schedules** to suit their workflow.
 - **Pause syncing for 24 hours** when they need to temporarily minimize activity.
 
@@ -27,6 +28,6 @@ This update is relevant for clients whose customers use our QuickBooks Desktop L
 
 ## How to get started?
 
-This update will **automatically be enabled on January 10, 2026**, but you can turn it on earlier by going to [**Developers > API deprecations**](https://app.codat.io/developers/api-deprecations) in the Portal and enabling **"Improved QuickBooks Desktop Link flow"**.  
+This update will **automatically be enabled on January 10, 2026**, but you can turn it on earlier by going to [**Developers > API deprecations**](https://app.codat.io/developers/api-deprecations) in the Portal and enabling **"Improved QuickBooks Desktop Link flow"**.
 
 If your customers want to adjust their sync settings or pause syncing, they can do so directly within Link.
diff --git a/code_utils/README.md b/code_utils/README.md
index da9afe9ff..5bda431e0 100644
--- a/code_utils/README.md
+++ b/code_utils/README.md
@@ -2,11 +2,13 @@
 
 A CLI tool for extracting, managing and checking code snippets from Codat documentation.
 Currently consists of two commands
-- extract:  This will find every markdown file
-in the docs directory containing a code snippet. It will then extract those snippets into files under a `temp/` directory.
+
+- extract: This will find every markdown file
+  in the docs directory containing a code snippet. It will then extract those snippets into files under a `temp/` directory.
 - check: This will copy those files into a container with all nessecary Codat SDK dependancies and perform checks that the imports and code are correct and would build.
 
 ## Development
+
 This project uses [uv](https://astral.sh/uv) for dependency management.
 
 ```bash
@@ -30,10 +32,9 @@ uv run code-util check -l programming-language
 uv run code-util --help
 ```
 
-
 ## Structure
 
-- `main.py` - Entrypoint for the CLI. 
+- `main.py` - Entrypoint for the CLI.
 - `code_finder/` - module for code relating to the CodeFinder class a.k.a the functionality to scan through markdown documents.
 - `code_checker/` - module for code relating to the CodeChecker class a.k.a the functionality to build containers and run commands in them.
 - `code_checker/docker/` - docker files, scripts and config that the containers use.
@@ -43,12 +44,11 @@ uv run code-util --help
 ## Dependancies
 
 - [Click](https://click.palletsprojects.com/en/stable/) - Framework for building CLIs.
-- [Docker SDK For Python](https://docker-py.readthedocs.io/en/stable/) - Library for interacting with the Docker API. 
+- [Docker SDK For Python](https://docker-py.readthedocs.io/en/stable/) - Library for interacting with the Docker API.
 - [Pytest](https://docs.pytest.org/en/stable/index.html) - Python Unit testing Framework.
 - [Pyfakefs](https://pytest-pyfakefs.readthedocs.io/en/latest/) - Python utility for faking a filesystem during testing.
 
 ## Notes
 
- - Hard coded to only deal with python, javascript(typescript) and C#
- - Javascript container uses a private npm package. Please set PAT_TOKEN and CODAT_EMAIL env vars in order to build.
-
+- Hard coded to only deal with python, javascript(typescript) and C#
+- Javascript container uses a private npm package. Please set PAT_TOKEN and CODAT_EMAIL env vars in order to build.
diff --git a/docs/auth-flow/migration-guide.md b/docs/auth-flow/migration-guide.md
index 2cc0ed8e6..189837644 100644
--- a/docs/auth-flow/migration-guide.md
+++ b/docs/auth-flow/migration-guide.md
@@ -22,7 +22,7 @@ You need a JavaScript application to render the Link component. Our component wo
 ### User experience
 
 Your current implementation likely starts with a consent page, confirming that your customers are happy to share their financial data with you before they interact with Codat.
-This often includes information on the purpose, platform data accessed, and your retention policy. 
+This often includes information on the purpose, platform data accessed, and your retention policy.
 
 Codat's Link component optionally supports consent management and more, as part of your migration you may wish to leverage this native functionality to remove maintenance overhead in your application.
 
@@ -113,4 +113,4 @@ Link SDK is imported at runtime, so you'll always get the latest version of our
 
 ## Read next
 
-- [Customize your auth flow](/auth-flow/customize/sdk-customize-code)
\ No newline at end of file
+- [Customize your auth flow](/auth-flow/customize/sdk-customize-code)
diff --git a/docs/bank-feeds/guides/bank-feeds-tutorial.md b/docs/bank-feeds/guides/bank-feeds-tutorial.md
index 8131a75bb..a686906d6 100644
--- a/docs/bank-feeds/guides/bank-feeds-tutorial.md
+++ b/docs/bank-feeds/guides/bank-feeds-tutorial.md
@@ -122,7 +122,7 @@ var bankFeedsClient = new CodatBankFeedsSDK(
 import { CodatBankFeeds } from "@codat/bank-feeds";
 
 const bankFeedsClient = new CodatBankFeeds({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 ```
 
diff --git a/docs/bank-feeds/setup.md b/docs/bank-feeds/setup.md
index b1a87ca6d..83a4ee696 100644
--- a/docs/bank-feeds/setup.md
+++ b/docs/bank-feeds/setup.md
@@ -128,7 +128,7 @@ yarn add @codat/bank-feeds
 import { CodatBankFeeds } from "@codat/bank-feeds";
 
 const bankFeedsClient = new CodatBankFeeds({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 ```
 
diff --git a/docs/commerce/setup.md b/docs/commerce/setup.md
index 4e3941d03..9ad532cfa 100644
--- a/docs/commerce/setup.md
+++ b/docs/commerce/setup.md
@@ -52,15 +52,15 @@ You can view the accounting and commerce software Sync for Commerce supports in
 
 Sync for Commerce currently supports the following accounting software:
 
-| Accounting software               | Platform key |
-| --------------------------------- | ------------ |
-| Exact (NL)                        | qudb         |
-| Exact (UK)                        | pbbf         |
-| FreeAgent                         | fbrh         |
-| MYOB                              | pdvj         |
+| Accounting software           | Platform key |
+| ----------------------------- | ------------ |
+| Exact (NL)                    | qudb         |
+| Exact (UK)                    | pbbf         |
+| FreeAgent                     | fbrh         |
+| MYOB                          | pdvj         |
 | Sage Accounting (coming soon) | tgff         |
-| QuickBooks Online                 | qhyg         |
-| Xero                              | gbol         |
+| QuickBooks Online             | qhyg         |
+| Xero                          | gbol         |
 
   </TabItem>
 
diff --git a/docs/core-concepts/connections.md b/docs/core-concepts/connections.md
index 73937994b..cfa8538ab 100644
--- a/docs/core-concepts/connections.md
+++ b/docs/core-concepts/connections.md
@@ -124,20 +124,22 @@ req = codat_platform.connections.unlink(request={
 import { CodatPlatform } from "@codat/platform";
 
 const codatPlatform = new CodatPlatform({
-    authHeader: "",
+  authHeader: "",
 });
 
-codatPlatform.connections.unlink({
-  companyId: "8a210b68-6988-11ed-a1eb-0242ac120002",
-  connectionId: "2e9d2c44-f675-40ba-8049-353bfcb5e171",
-  updateConnectionStatus: {
-    status: "Unlinked",
-  },
-}).then((res) => {
-  if (res) {
-    // handle response
-  }
-});
+codatPlatform.connections
+  .unlink({
+    companyId: "8a210b68-6988-11ed-a1eb-0242ac120002",
+    connectionId: "2e9d2c44-f675-40ba-8049-353bfcb5e171",
+    updateConnectionStatus: {
+      status: "Unlinked",
+    },
+  })
+  .then((res) => {
+    if (res) {
+      // handle response
+    }
+  });
 ```
 
 </TabItem>
@@ -271,15 +273,17 @@ res = codat_platform.connections.delete(
 import { CodatPlatform } from "@codat/platform";
 
 const codatPlatform = new CodatPlatform({
-    authHeader: "{codatAuthHeader}",
+  authHeader: "{codatAuthHeader}",
 });
 
-codatPlatform.connections.delete({
-  companyId: "{companyId}",
-  connectionId: "{connectionId}",
-}).then((res) => {
-    console.log('Connection deleted successfully')
-});
+codatPlatform.connections
+  .delete({
+    companyId: "{companyId}",
+    connectionId: "{connectionId}",
+  })
+  .then((res) => {
+    console.log("Connection deleted successfully");
+  });
 ```
 
   </TabItem>
diff --git a/docs/enterprise/tech-overview/security/product-based-permissions.md b/docs/enterprise/tech-overview/security/product-based-permissions.md
index 08e6ede11..96b5d1ac5 100644
--- a/docs/enterprise/tech-overview/security/product-based-permissions.md
+++ b/docs/enterprise/tech-overview/security/product-based-permissions.md
@@ -3,50 +3,51 @@ title: "Product-based permissions"
 description: "Managing product-based permissions in the Codat Portal"
 ---
 
-Product-based permissions give clients more control over which companies users can access, based on the products assigned to them.  
+Product-based permissions give clients more control over which companies users can access, based on the products assigned to them.
 
-These permissions work alongside existing roles. Only administrators can assign product-based permissions.  
+These permissions work alongside existing roles. Only administrators can assign product-based permissions.
 
 ---
 
 ## How permissions work
 
 ### Administrator and Developer roles
-- Full access to all products  
-- Cannot edit their own product assignment, as they already have unrestricted access  
+
+- Full access to all products
+- Cannot edit their own product assignment, as they already have unrestricted access
 
 ### Analyst and Onboarding roles
-- Can’t access **Settings > Users**  
-- Can’t change user roles  
-- Can’t change product assignments  
-- Must be assigned a product before they can create or view companies  
-- From a user perspective: until a product is assigned, no companies are visible and new companies can’t be created  
 
-Once a product has been assigned, these users can create companies.  
+- Can’t access **Settings > Users**
+- Can’t change user roles
+- Can’t change product assignments
+- Must be assigned a product before they can create or view companies
+- From a user perspective: until a product is assigned, no companies are visible and new companies can’t be created
+
+Once a product has been assigned, these users can create companies.
 
 ---
 
 ## Role permissions at a glance
 
-| Role           | Access to product | Can edit user roles | Can assign products | Can access **Settings > Users** | Can create/view companies        |
-|----------------|-------------------|---------------------|---------------------|----------------------------------|----------------------------------|
-| **Administrator** | Full access       | ✔                   | ✔                   | ✔                                | ✔                                |
-| **Developer**     | Full access       | ✘                   | ✘                   | ✔                                | ✔                                |
-| **Analyst**       | Product required  | ✘                   | ✘                   | ✘                                | Only after product assigned      |
-| **Onboarding**    | Product required  | ✘                   | ✘                   | ✘                                | Only after product assigned      |
+| Role              | Access to product | Can edit user roles | Can assign products | Can access **Settings > Users** | Can create/view companies   |
+| ----------------- | ----------------- | ------------------- | ------------------- | ------------------------------- | --------------------------- |
+| **Administrator** | Full access       | ✔                  | ✔                  | ✔                              | ✔                          |
+| **Developer**     | Full access       | ✘                   | ✘                   | ✔                              | ✔                          |
+| **Analyst**       | Product required  | ✘                   | ✘                   | ✘                               | Only after product assigned |
+| **Onboarding**    | Product required  | ✘                   | ✘                   | ✘                               | Only after product assigned |
 
 ---
 
 ## Using SSO
 
-- If you’re using Enterprise SSO, ensure the correct Active Directory group is assigned to each user (**Administrator**, **Developer**, **Analyst**, or **Onboarding**).  
-- New users set up as **Analysts** or **Onboarders** must log in to the Portal via SSO before a product can be assigned.  
+- If you’re using Enterprise SSO, ensure the correct Active Directory group is assigned to each user (**Administrator**, **Developer**, **Analyst**, or **Onboarding**).
+- New users set up as **Analysts** or **Onboarders** must log in to the Portal via SSO before a product can be assigned.
 
 ---
 
 ## Notes
 
-- Changes to a company’s product assignments update automatically when users refresh the Portal.  
-- If an Administrator adds a product to a company that a user doesn’t have access to, the user can still see that the product has been assigned but won’t have access to it.  
+- Changes to a company’s product assignments update automatically when users refresh the Portal.
+- If an Administrator adds a product to a company that a user doesn’t have access to, the user can still see that the product has been assigned but won’t have access to it.
 - When a company has multiple products assigned, users see all products they have permission to access.
-
diff --git a/docs/enterprise/tech-overview/security/sso.md b/docs/enterprise/tech-overview/security/sso.md
index 5722cf938..70db77edf 100644
--- a/docs/enterprise/tech-overview/security/sso.md
+++ b/docs/enterprise/tech-overview/security/sso.md
@@ -83,6 +83,7 @@ After a user has been added to the relevant group within your identity provider,
 #### Removing a user
 
 Preventing a user from accessing the Codat Portal can be done through:
+
 - Removal from all specified access groups in your identity provider.
 - Prevention of authentication via your identity provider.
 
diff --git a/docs/expenses/fx-management.md b/docs/expenses/fx-management.md
index 3df8f8e4c..58bf63d17 100644
--- a/docs/expenses/fx-management.md
+++ b/docs/expenses/fx-management.md
@@ -285,11 +285,11 @@ In multi-currency scenarios, there are five possible combinations of currencies
 
 We validate the multi-currency transactions you write to Expenses to ensure the currency combination will be accepted by the target accounting software as a valid expense.
 
-| Integration       | Option 1 | Option 2 | Option 3 | Option 4 | Option 5 |
-| ----------------- | -------- | -------- | -------- | -------- | -------- |
-| QuickBooks Online | ✔️       | ✔️      | ✔️       | ✔️      | ❌       |
-| QuickBooks Desktop |✔️       | ❌      | ❌       |   ❌    |  ❌      |
-| Xero              | ✔️       | ✔️      | ❌       | ❌      | ❌       |
+| Integration        | Option 1 | Option 2 | Option 3 | Option 4 | Option 5 |
+| ------------------ | -------- | -------- | -------- | -------- | -------- |
+| QuickBooks Online  | ✔️       | ✔️       | ✔️       | ✔️       | ❌       |
+| QuickBooks Desktop | ✔️       | ❌       | ❌       | ❌       | ❌       |
+| Xero               | ✔️       | ✔️       | ❌       | ❌       | ❌       |
 
 ---
 
diff --git a/docs/get-started/first-steps.md b/docs/get-started/first-steps.md
index e95d449d4..6a487fe4c 100644
--- a/docs/get-started/first-steps.md
+++ b/docs/get-started/first-steps.md
@@ -95,7 +95,7 @@ or
 import { CodatPlatform } from "@codat/platform";
 
 const codatPlatform = new CodatPlatform({
-    authHeader: "{basicAuthHeader}",
+  authHeader: "{basicAuthHeader}",
 });
 ```
 
@@ -194,11 +194,12 @@ if(res.Company != null) {
   <TabItem value="nodejs" label="TypeScript">
 
 ```javascript
-
-  codatPlatform.companies.create({
+codatPlatform.companies
+  .create({
     description: "Requested early access to the new financing scheme.",
     name: "Bank of Dave",
-  }).then((res) => {
+  })
+  .then((res) => {
     // handle response
   });
 ```
@@ -329,11 +330,11 @@ if res.statusCode == (int)HttpStatusCode.OK {
   <TabItem value="nodejs" label="TypeScript">
 
 ```javascript
-
-
-  codatPlatform.companies.get({
+codatPlatform.companies
+  .get({
     companyId: "{companyId}",
-  }).then((res) => {
+  })
+  .then((res) => {
     //handle response
   });
 ```
@@ -484,15 +485,17 @@ or
 ##### Usage
 
 ```javascript
-  import { CodatLending } from "@codat/lending";
+import { CodatLending } from "@codat/lending";
 
-  const codatLending = new CodatLending({
-      authHeader: "{basicAuthHeader}",
-  });
+const codatLending = new CodatLending({
+  authHeader: "{basicAuthHeader}",
+});
 
-  codatLending.accountsReceivable.invoices.list({
-    companyId: "{companyId}"
-  }).then((res) => {
+codatLending.accountsReceivable.invoices
+  .list({
+    companyId: "{companyId}",
+  })
+  .then((res) => {
     //handle response
   });
 ```
diff --git a/docs/integrations/accounting/dynamics365financeoperations/overview.md b/docs/integrations/accounting/dynamics365financeoperations/overview.md
index 86bc1ccfc..cccdef90b 100644
--- a/docs/integrations/accounting/dynamics365financeoperations/overview.md
+++ b/docs/integrations/accounting/dynamics365financeoperations/overview.md
@@ -15,10 +15,10 @@ Dynamics 365 F&O is a cloud-based enterprise resource planning (ERP) solution th
 
 ## Getting started
 
-No setup is required to start using Dynamics 365 F&O. Reach out to your Account Manager or Customer Success Manager to enable the integration and invite your customers to connect their data. 
+No setup is required to start using Dynamics 365 F&O. Reach out to your Account Manager or Customer Success Manager to enable the integration and invite your customers to connect their data.
 
 ### Enable the Dynamics 365 F&O integration
 
-If you need to manage the integration, navigate to **Settings > Integrations > Accounting** to view the [Accounting integrations](https://app.codat.io/settings/integrations/accounting) page in the Codat Portal. 
+If you need to manage the integration, navigate to **Settings > Integrations > Accounting** to view the [Accounting integrations](https://app.codat.io/settings/integrations/accounting) page in the Codat Portal.
 
-There, locate **Dynamics 365 Finance & Operations** and use the toggle to manage the integration. Alternatively, click **Manage** to view the integration's settings page and use the toggle from there.
\ No newline at end of file
+There, locate **Dynamics 365 Finance & Operations** and use the toggle to manage the integration. Alternatively, click **Manage** to view the integration's settings page and use the toggle from there.
diff --git a/docs/integrations/accounting/netsuite/oracle-netsuite-integration-reference.md b/docs/integrations/accounting/netsuite/oracle-netsuite-integration-reference.md
index db7c11f19..87e88a051 100644
--- a/docs/integrations/accounting/netsuite/oracle-netsuite-integration-reference.md
+++ b/docs/integrations/accounting/netsuite/oracle-netsuite-integration-reference.md
@@ -54,6 +54,7 @@ Say you have a vendor bill in NetSuite with a line item of $39.05, inclusive of
         }
       ]
 ```
+
 ### Companies with SuiteTax enabled
 
 Codat does not currently support SuiteTax. Companies with SuiteTax enabled can connect to Codat successfully; however, tax data will not be available. This affects all Accounts Receivable and Accounts Payable use cases where tax rates or tax amounts are required.
diff --git a/docs/integrations/accounting/overview.md b/docs/integrations/accounting/overview.md
index 5898412d7..65f3c6094 100644
--- a/docs/integrations/accounting/overview.md
+++ b/docs/integrations/accounting/overview.md
@@ -37,14 +37,14 @@ Some integrations have more complex requirements in terms of registration and pa
 | [Oracle NetSuite](https://www.netsuite.com/portal/home.shtml)                                                     | Registration not required | Yes\*                       | ❌                      | \* Rarely open to new joiners                                                                                                                                                                                                                                                                |
 | [QuickBooks Online](https://quickbooks.intuit.com/uk/online/)                                                     | Easy                      | ✅                          | ❌                      | You must complete a security questionnaire to access production data.                                                                                                                                                                                                                        |
 | [QuickBooks Desktop](https://quickbooks.intuit.com/desktop/) <br/> `On-premise`                                   | Registration not required | ✅                          | ❌                      |                                                                                                                                                                                                                                                                                              |
-| [Sage Accounting](https://www.sage.com/en-gb/sage-business-cloud/accounting/)                      | Easy                      | ✅                          | ❌                      |                                                                                                                                                                                                                                                                                              |
+| [Sage Accounting](https://www.sage.com/en-gb/sage-business-cloud/accounting/)                                     | Easy                      | ✅                          | ❌                      |                                                                                                                                                                                                                                                                                              |
 | [Sage Intacct](https://www.sage.com/en-gb/sage-business-cloud/intacct/)                                           | Registration not required | ✅                          | ✅                      | \* You can request Codat's marketplace credentials to avoid registration by emailing solutions@codat.io                                                                                                                                                                                      |
 | [Sage 50 UK & Ireland](https://www.sage.com/en-gb/products/sage-50-accounts/) <br/> `On-premise`                  | Registration not required | ✅                          | ❌                      |                                                                                                                                                                                                                                                                                              |
 | [Sage 200 Cloud](https://www.sage.com/en-gb/products/sage-200/)                                                   | Hard                      | ❌                          | ❌                      | New partners are approved manually within several days after registration. Contact your solutions engineer in case of complications.                                                                                                                                                         |
 | [Wave](https://www.waveapps.com/)                                                                                 | Easy                      | ❌                          | ❌                      | Registrations completed before July 2022 need to request partner status via wave@codat.io to access profit & loss and balance sheet report. The reports are enabled by default for registrations completed after July 2022.                                                                  |
 | [Workday](https://www.workday.com/)                                                                               | Registration not required | ✅                          | None known              | This integration is only supported by our [Spend Insights](/spend-insights/overview) solution.                                                                                                                                                                                               |
 | [Xero](https://www.xero.com/)                                                                                     | Easy                      | ✅                          | ✅                      | You must certify your integration and partner with Xero to connect more than 25 companies. This involves extra technical requirements and, in some cases, additional charges. Use cases such as financial brokering, insurance, FX hending, and lending (in some regions) are not permitted. |
-| [Zoho Books](https://www.zoho.com/uk/books/)                                                                       | Easy                      | ✅                          | ❌                      |                                                                                                                                                                                                                                                                                              |
+| [Zoho Books](https://www.zoho.com/uk/books/)                                                                      | Easy                      | ✅                          | ❌                      |                                                                                                                                                                                                                                                                                              |
 
 ## Accounting software per region
 
@@ -75,7 +75,7 @@ Each integration has a unique 4-character key that identifies it in our APIs. Fo
 | QuickBooks Online Sandbox      | ndsk         |
 | Sage 200 Standard              | jcrp         |
 | Sage 50 (UK)                   | hbql         |
-| Sage Accounting | tgff         |
+| Sage Accounting                | tgff         |
 | Sage Intacct                   | knfz         |
 | Sandbox                        | mqjo         |
 | Wave                           | pbtz         |
diff --git a/docs/integrations/bank-feeds/xero-bank-feeds/xero-bank-feeds-push-bank-transactions.md b/docs/integrations/bank-feeds/xero-bank-feeds/xero-bank-feeds-push-bank-transactions.md
index 91089993f..9769f4d21 100644
--- a/docs/integrations/bank-feeds/xero-bank-feeds/xero-bank-feeds-push-bank-transactions.md
+++ b/docs/integrations/bank-feeds/xero-bank-feeds/xero-bank-feeds-push-bank-transactions.md
@@ -67,7 +67,7 @@ When writing bank transactions to Xero:
 - A maximum of 1000 transactions can be written at a time.
 
 :::note Writing historic transactions
-The `feedStartDate` on the source bank account is determined by the **Feed start date** selected by the SMB user in the account mapping UI, but it is not enforced and should be used as a guide.  
+The `feedStartDate` on the source bank account is determined by the **Feed start date** selected by the SMB user in the account mapping UI, but it is not enforced and should be used as a guide.
 
 You can write bank transactions to Xero which are dated up to one year prior to the current date. Write operations that contain bank transactions dated older than one year will fail.
 :::
diff --git a/docs/integrations/banking/plaid/banking-plaid-setup.md b/docs/integrations/banking/plaid/banking-plaid-setup.md
index 2599b5670..85bd4e29e 100644
--- a/docs/integrations/banking/plaid/banking-plaid-setup.md
+++ b/docs/integrations/banking/plaid/banking-plaid-setup.md
@@ -71,6 +71,7 @@ Plaid allows you to customize the look, feel, and content of the link flow that
 2. Create a new configuration or select an existing one by clicking the dropdown.
 
    Make a note of the **Name** you assign to the configuration and the **Countries** you select as you will need these later in Codat.
+
 3. Configure the journey to match your needs: adjust branding, institution options, and account selection options as required. For a full list of available customization options, see Plaid’s [Link customization documentation](https://plaid.com/docs/link/customization/).
 4. Click **Publish changes** to save and apply your customizations.
 5. In the Codat Portal, navigate to [**Settings > Integrations > Banking > Plaid**](https://app.codat.io/settings/integrations/banking/manage/suuo?integrationName=Plaid).
@@ -87,7 +88,7 @@ When a customer connects their bank account using Plaid, they can choose which a
 1. In the **Plaid Dashboard**, navigate to [**Platform > Link > Link customization**](https://dashboard.plaid.com/link).
 2. Select [**Account Select**](https://dashboard.plaid.com/link/account-select) in the right-hand menu.
 3. To allow your customers to choose which accounts to share, select **Enable for multiple accounts**.
-![A screenshot highlighting the 'Enable for mutiple accounts' in the Account Select view](/img/integrations/banking/plaid/plaid-account-select.png)
+   ![A screenshot highlighting the 'Enable for mutiple accounts' in the Account Select view](/img/integrations/banking/plaid/plaid-account-select.png)
 4. Click **Publish changes** to save and apply your changes.
 
 Once complete, Plaid will only share the accounts explicitly selected by your customers, and only those accounts will be passed to you via Codat.
@@ -99,4 +100,4 @@ When you are ready to connect to live data, you will need to request access from
 1. Log in to the [**Plaid Dashboard**](https://dashboard.plaid.com/link).
 2. Select **Migrate to Production** and follow the process to request access to the Plaid production environment, and to get your secure credentials.
 3. Once you have your Production Secret, enter it in the box for the Production Secret within the Plaid configuration page in the Codat Portal.
-4. Please note that the Country Codes default value in Plaid's Production environment is the following: `US,CA`.
\ No newline at end of file
+4. Please note that the Country Codes default value in Plaid's Production environment is the following: `US,CA`.
diff --git a/docs/lending/features/enhanced-cash-flow-migration.md b/docs/lending/features/enhanced-cash-flow-migration.md
index bd5d6dba7..752902f65 100644
--- a/docs/lending/features/enhanced-cash-flow-migration.md
+++ b/docs/lending/features/enhanced-cash-flow-migration.md
@@ -8,7 +8,7 @@ image: "/img/banners/social/lending.png"
 import Tabs from "@theme/Tabs";
 import TabItem from "@theme/TabItem";
 
-We have recently launched the **Categorized Bank Statement** report, which replaces the legacy **Enhanced Cashflow** report. The new report includes built-in orchestration for fetching required data from third-party integrations and provides webhook notifications when the report is ready. 
+We have recently launched the **Categorized Bank Statement** report, which replaces the legacy **Enhanced Cashflow** report. The new report includes built-in orchestration for fetching required data from third-party integrations and provides webhook notifications when the report is ready.
 
 To ensure a smooth transition, we recommend migrating to the new endpoints ahead of the [upcoming deprecation](https://docs.codat.io/updates/250703-deprecation-enh-cashflow-endpoints) on **July 10, 2026**.
 
@@ -27,7 +27,7 @@ This report is not generated automatically on a predefined schedule. If you need
 
 To prepare for the deprecation, you’ll need to update your application to use the Categorized Bank Statement endpoints in place of the Enhanced Cashflow ones.
 
-To switch to the Categorized Bank Statement report we recommend an "expand/contract" strategy. 
+To switch to the Categorized Bank Statement report we recommend an "expand/contract" strategy.
 Before you start your migration enable the new report in the [Portal](https://app.codat.io/developers/api-deprecations). Learn how to do that [here](https://docs.codat.io/configure/portal/developers).
 
 Once enabled, you can run both the legacy and new endpoints in parallel, allowing for a phased transition before the deprecation deadline.
@@ -86,20 +86,19 @@ To generate the report asynchronously, update your application logic to call the
 
 </Tabs>
 
-| **Old schema property** | **New schema equivalent**                                                                                     |
-|-------------------------|----------------------------------------------------------------------------------------------------------------|
-| `lastGenerated`         | 🔁 Use `GET /companies/{companyId}/reports` endpoint instead to retrieve previously generated reports                                                                                               |
-| `inProgress`            | ✅ Replaced by `status` – indicates the current state of the report (`InProgress`, `Complete`, `Error`)       |
-| `queued`                | ✅ Replaced by `requestedDate` – timestamp for when the report was requested                                   |
-| `success`               | ✅ Use `status` instead                                                                                        |
-| `errorMessage`          | ✅ Remains `errorMessage`                                                                                      |
-| `lastInvocationId`      | ❌ Not available                                                                                               |
-| `reportType`            | ✅ Renamed to `type`                                                                                           |
-| `fileSize`              | ❌ Not available                                                                                               |
+| **Old schema property** | **New schema equivalent**                                                                               |
+| ----------------------- | ------------------------------------------------------------------------------------------------------- |
+| `lastGenerated`         | 🔁 Use `GET /companies/{companyId}/reports` endpoint instead to retrieve previously generated reports   |
+| `inProgress`            | ✅ Replaced by `status` – indicates the current state of the report (`InProgress`, `Complete`, `Error`) |
+| `queued`                | ✅ Replaced by `requestedDate` – timestamp for when the report was requested                            |
+| `success`               | ✅ Use `status` instead                                                                                 |
+| `errorMessage`          | ✅ Remains `errorMessage`                                                                               |
+| `lastInvocationId`      | ❌ Not available                                                                                        |
+| `reportType`            | ✅ Renamed to `type`                                                                                    |
+| `fileSize`              | ❌ Not available                                                                                        |
 
 </details>
 
-
 Refer to the [Generate report](https://docs.codat.io/lending-api#/operations/generate-report) API reference for more details.
 
 ### 2. Check report status
@@ -154,16 +153,16 @@ The **response object has changed**. The response has been updated to return the
 
 </Tabs>
 
-| **Old schema property** | **New schema equivalent**                                                                                     |
-|-------------------------|----------------------------------------------------------------------------------------------------------------|
-| `lastGenerated`         | 🔁 Use `GET /companies/{companyId}/reports` endpoint instead to retrieve previously generated reports                                                                                             |
-| `inProgress`            | ✅ Replaced by `status` – indicates the current state of the report (`InProgress`, `Complete`, `Error`)       |
-| `queued`                | ✅ Replaced by `requestedDate` – timestamp for when the report was requested                                   |
-| `success`               | ✅ Use `status` instead                                                                                        |
-| `errorMessage`          | ✅ Remains `errorMessage`                                                                                      |
-| `lastInvocationId`      | ❌ Not available                                                                                               |
-| `reportType`            | ✅ Renamed to `type`                                                                                           |
-| `fileSize`              | ❌ Not available                                                                                               |
+| **Old schema property** | **New schema equivalent**                                                                               |
+| ----------------------- | ------------------------------------------------------------------------------------------------------- |
+| `lastGenerated`         | 🔁 Use `GET /companies/{companyId}/reports` endpoint instead to retrieve previously generated reports   |
+| `inProgress`            | ✅ Replaced by `status` – indicates the current state of the report (`InProgress`, `Complete`, `Error`) |
+| `queued`                | ✅ Replaced by `requestedDate` – timestamp for when the report was requested                            |
+| `success`               | ✅ Use `status` instead                                                                                 |
+| `errorMessage`          | ✅ Remains `errorMessage`                                                                               |
+| `lastInvocationId`      | ❌ Not available                                                                                        |
+| `reportType`            | ✅ Renamed to `type`                                                                                    |
+| `fileSize`              | ❌ Not available                                                                                        |
 
 </details>
 
@@ -200,7 +199,7 @@ Unlike the legacy endpoints, the new endpoints require that a report already exi
 1. Call `POST /companies/{companyId}/reports/categorizedBankStatement`
 
 2. Confirm the report status is `Complete` before calling Categorized Bank Statement accounts or transactions endpoints.
-:::
+   :::
 
 You can determine whether the report has finished generating using one of the following methods:
 
@@ -221,11 +220,12 @@ You can determine whether the report has finished generating using one of the fo
 Instead of a single endpoint, account and transaction data is now available via two dedicated endpoints.
 Before calling these, ensure that a report has been generated and is in the `Complete` state.
 There are a few implications for your integration.
-* You’ll need to update your data parsing logic to extract transactions from the results array instead of navigating nested structures.
 
-* If you previously depended on embedded account information (e.g. balances or bank codes), you'll now need to use the accounts endpoint `GET /companies/{companyId}/reports/categorizedBankStatement/latest/accounts`
+- You’ll need to update your data parsing logic to extract transactions from the results array instead of navigating nested structures.
+
+- If you previously depended on embedded account information (e.g. balances or bank codes), you'll now need to use the accounts endpoint `GET /companies/{companyId}/reports/categorizedBankStatement/latest/accounts`
 
-* The new response follows standard REST conventions, which simplifies pagination and improves performance when working with large datasets.
+- The new response follows standard REST conventions, which simplifies pagination and improves performance when working with large datasets.
 
 #### Legacy endpoint
 
@@ -239,13 +239,12 @@ There are a few implications for your integration.
 
 #### Response changes
 
-
-| Change                      | Legacy Enhanced Cashflow                                     | Categorized Bank Statement                                      |
-|----------------------------|---------------------------------------------------------------|------------------------------------------------------------------|
-| **Top-level shape**        | Nested object with `reportInfo`, `dataSources`, `reportItems` | Flat object with `results` array                                |
-| **Transactions**           | Nested under `reportItems.transactions`                       | Flattened under `results` array                                 |
-| **Accounts**               | Embedded in `dataSources.accounts` with full account details  | Referenced via `accountRef`; full details retrieved separately  |
-| **Metadata**               | Included in `reportInfo`                                      | Retrieved separately via status endpoint                        |
+| Change              | Legacy Enhanced Cashflow                                      | Categorized Bank Statement                                     |
+| ------------------- | ------------------------------------------------------------- | -------------------------------------------------------------- |
+| **Top-level shape** | Nested object with `reportInfo`, `dataSources`, `reportItems` | Flat object with `results` array                               |
+| **Transactions**    | Nested under `reportItems.transactions`                       | Flattened under `results` array                                |
+| **Accounts**        | Embedded in `dataSources.accounts` with full account details  | Referenced via `accountRef`; full details retrieved separately |
+| **Metadata**        | Included in `reportInfo`                                      | Retrieved separately via status endpoint                       |
 
 <details>
   <summary><b>Compare sample responses</b></summary>
@@ -326,6 +325,7 @@ There are a few implications for your integration.
   ]
 }
 ```
+
 </TabItem>
 
 <TabItem value="newtr" label="New schema - Transactions">
@@ -364,26 +364,25 @@ There are a few implications for your integration.
 
 </Tabs>
 
-| **Old schema property**                     | **New schema - Accounts**                            | **New schema - Transactions**                         |
-|---------------------------------------------|---------------------------------------------------------------|----------------------------------------------------------------|
-| `reportInfo.pageNumber`                     | ✅ `pageNumber`                                               | ✅ `pageNumber`                                                 |
-| `reportInfo.pageSize`                       | ✅ `pageSize`                                                 | ✅ `pageSize`                                                   |
-| `reportInfo.totalResults`                   | ✅ `totalResults`                                             | ✅ `totalResults`                                               |
-| `reportInfo.generatedDate`                  | ❌ Not available (see report status for `updatedDate`)        | ❌ Not available (see report status for `updatedDate`)          |
-| `dataSources.accounts[].id`                 | ✅ `results[].id`                                             | 🔁 Referenced via `accountRef.id`                              |
-| `dataSources.accounts[].accountName`        | ✅ `accountName`                                              | 🔁 Referenced via `accountRef.name`                            |
-| `dataSources.accounts[].accountType`        | ✅ `accountType`                                              | ❌ Not available                                                |
-| `dataSources.accounts[].currency`           | ✅ `currency`                                                 | ✅ `currency`                                                   |
-| `dataSources.accounts[].currentBalance`     | ✅ `currentBalance`                                           | ❌ Not available                                                |
-| `reportItems[].transactions[].id`           | ❌ Not available                                              | ✅ `results[].id`                                               |
-| `reportItems[].transactions[].accountRef`   | ❌ Not available                                              | ✅ `accountRef`                                                 |
-| `reportItems[].transactions[].date`         | ❌ Not available                                              | ✅ `date`                                                       |
-| `reportItems[].transactions[].description`  | ❌ Not available                                              | ✅ `description`                                                |
-| `reportItems[].transactions[].amount`       | ❌ Not available                                              | ✅ `amount`                                                     |
-| `reportItems[].transactions[].currency`     | ❌ Not available                                              | ✅ `currency`                                                   |
-| `reportItems[].transactions[].platformName` | ❌ Not available                                              | ✅ `platformName`                                               |
+| **Old schema property**                     | **New schema - Accounts**                              | **New schema - Transactions**                          |
+| ------------------------------------------- | ------------------------------------------------------ | ------------------------------------------------------ |
+| `reportInfo.pageNumber`                     | ✅ `pageNumber`                                        | ✅ `pageNumber`                                        |
+| `reportInfo.pageSize`                       | ✅ `pageSize`                                          | ✅ `pageSize`                                          |
+| `reportInfo.totalResults`                   | ✅ `totalResults`                                      | ✅ `totalResults`                                      |
+| `reportInfo.generatedDate`                  | ❌ Not available (see report status for `updatedDate`) | ❌ Not available (see report status for `updatedDate`) |
+| `dataSources.accounts[].id`                 | ✅ `results[].id`                                      | 🔁 Referenced via `accountRef.id`                      |
+| `dataSources.accounts[].accountName`        | ✅ `accountName`                                       | 🔁 Referenced via `accountRef.name`                    |
+| `dataSources.accounts[].accountType`        | ✅ `accountType`                                       | ❌ Not available                                       |
+| `dataSources.accounts[].currency`           | ✅ `currency`                                          | ✅ `currency`                                          |
+| `dataSources.accounts[].currentBalance`     | ✅ `currentBalance`                                    | ❌ Not available                                       |
+| `reportItems[].transactions[].id`           | ❌ Not available                                       | ✅ `results[].id`                                      |
+| `reportItems[].transactions[].accountRef`   | ❌ Not available                                       | ✅ `accountRef`                                        |
+| `reportItems[].transactions[].date`         | ❌ Not available                                       | ✅ `date`                                              |
+| `reportItems[].transactions[].description`  | ❌ Not available                                       | ✅ `description`                                       |
+| `reportItems[].transactions[].amount`       | ❌ Not available                                       | ✅ `amount`                                            |
+| `reportItems[].transactions[].currency`     | ❌ Not available                                       | ✅ `currency`                                          |
+| `reportItems[].transactions[].platformName` | ❌ Not available                                       | ✅ `platformName`                                      |
 
 </details>
 
 Refer to the [List Accounts Endpoint](https://docs.codat.io/lending-api#/operations/list-categorized-bank-statement-accounts) and [List Transactions Endpoint](https://docs.codat.io/lending-api#/operations/get-categorized-bank-statement-transactions) documentations for details.
-
diff --git a/docs/lending/premium-products/credit-model-overview.md b/docs/lending/premium-products/credit-model-overview.md
index 7b6db9675..e05ae4b0d 100644
--- a/docs/lending/premium-products/credit-model-overview.md
+++ b/docs/lending/premium-products/credit-model-overview.md
@@ -6,7 +6,10 @@ description: "Access a detailed data-driven assessment of a business's financial
 
 import Products from "@components/Products";
 import { IntegrationsList } from "@components/Integrations";
-import { integrationsAccountingFilterCreditModel, bankingIntegrations } from "@components/Integrations/integrations";
+import {
+  integrationsAccountingFilterCreditModel,
+  bankingIntegrations,
+} from "@components/Integrations/integrations";
 import Tabs from "@theme/Tabs";
 import TabItem from "@theme/TabItem";
 
@@ -92,17 +95,17 @@ You can generate and retrieve the data read and enriched by this feature in an E
 
 Use the [Generate report](/lending-api#/operations/generate-report) endpoint to asynchronously generate the report. Set the `reportType` parameter to `creditModel`. Initiating the report will trigger a new data sync.
 
-Next, call the [Download credit model Excel](/lending-api#/operations/download-credit-model-excel) endpoint to retrieve the resulting report. 
+Next, call the [Download credit model Excel](/lending-api#/operations/download-credit-model-excel) endpoint to retrieve the resulting report.
 
-You can also view individual Credit Model metrics using the [Get financial summary insights](/lending-api#/operations/get-financial-summary) endpoint. 
+You can also view individual Credit Model metrics using the [Get financial summary insights](/lending-api#/operations/get-financial-summary) endpoint.
 
 The Credit Model feature must be enabled before you can generate the _Credit Model_ report and its metrics via API. Speak to your Account Manager to enable it.
 
 #### Get report via Portal
 
-In the [Codat Portal](https://app.codat.io), navigate to **Companies** and select the company you want to analyze. In the side menu, click **Lending > Reports**. 
+In the [Codat Portal](https://app.codat.io), navigate to **Companies** and select the company you want to analyze. In the side menu, click **Lending > Reports**.
 
-In the list of reports, find _Credit Model_ and click **Generate report**. Once the report is ready to download, it will appear underneath the report name. Click **Download** to save the report to your machine. 
+In the list of reports, find _Credit Model_ and click **Generate report**. Once the report is ready to download, it will appear underneath the report name. Click **Download** to save the report to your machine.
 
 The Credit Model feature must be enabled before you can access the _Credit Model_ report in the Portal. Speak to your Account Manager to enable it.
 
@@ -131,7 +134,7 @@ Follow the respective guides to set up and enable accounting integrations that w
 See how to [enable data types](/core-concepts/data-type-settings#override-the-default-sync-settings) and ensure the following data types have been switched on:
 
 | **Accounting**                  | **Banking**                                 |
-|---------------------------------|---------------------------------------------|
+| ------------------------------- | ------------------------------------------- |
 | Company `company`               | Banking transactions `banking-transactions` |
 | Profit and loss `profitAndLoss` | Banking accounts `banking-accounts`         |
 | Balance sheet `balanceSheet`    |                                             |
diff --git a/docs/payables/get-started.md b/docs/payables/get-started.md
index cd9ccc8ca..b616bb9d4 100644
--- a/docs/payables/get-started.md
+++ b/docs/payables/get-started.md
@@ -111,7 +111,7 @@ yarn add @codat/sync-for-payables
 import { CodatSyncPayables } from "@codat/sync-for-payables";
 
 const payablesClient = new CodatSyncPayables({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 ```
 
diff --git a/docs/using-the-api/authentication.md b/docs/using-the-api/authentication.md
index 3a3e145b2..9c30da6f2 100644
--- a/docs/using-the-api/authentication.md
+++ b/docs/using-the-api/authentication.md
@@ -10,7 +10,7 @@ API keys are tokens used to control access to the API. Codat expects the API key
 Authorization: Basic YOUR_ENCODED_API_KEY // Replace *YOUR_ENCODED_API_KEY* with your API key, Base64 encoded
 ```
 
-When using API keys in your application, you can either store the raw API key and encode it yourself, or just store the pre-encoded authroization header we expose.
+When using API keys in your application, you can either store the raw API key and encode it yourself, or just store the pre-encoded authorization header we expose.
 
 ## Managing keys
 
diff --git a/docs/using-the-api/paging.md b/docs/using-the-api/paging.md
index 8f6bd9cfd..be6494786 100644
--- a/docs/using-the-api/paging.md
+++ b/docs/using-the-api/paging.md
@@ -95,15 +95,17 @@ if res:
 import { CodatPlatform } from "@codat/platform";
 
 const codatPlatform = new CodatPlatform({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 
-codatPlatform.companies.list({
-  "page" : 5,
-  "pageSize" : 20,
-}).then((res) => {
+codatPlatform.companies
+  .list({
+    page: 5,
+    pageSize: 20,
+  })
+  .then((res) => {
     // handle response
-});
+  });
 ```
 
 </TabItem>
diff --git a/docs/using-the-api/querying.md b/docs/using-the-api/querying.md
index 05b6331e9..202084212 100644
--- a/docs/using-the-api/querying.md
+++ b/docs/using-the-api/querying.md
@@ -103,15 +103,17 @@ var res = await codatLending.AccountsReceivable.Invoices.ListAsync(new ListAccou
 import { CodatLending } from "@codat/lending";
 
 const codatLending = new CodatLending({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 
-codatLending.accountsReceivable.invoices.list({
-  companyId: "{companyId}",
-  query: "amountDue>0&&totalAmount<1000",
-}).then((res) => {
+codatLending.accountsReceivable.invoices
+  .list({
+    companyId: "{companyId}",
+    query: "amountDue>0&&totalAmount<1000",
+  })
+  .then((res) => {
     // handle response
-});
+  });
 ```
 
 </TabItem>
@@ -222,15 +224,17 @@ var res = await codatLending.AccountsReceivable.Invoices.ListAsync(new ListAccou
 import { CodatLending } from "@codat/lending";
 
 const codatLending = new CodatLending({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 
-codatLending.accountsReceivable.invoices.list({
-  companyId: "{companyId}",
-  query: "currency=GBP",
-}).then((res) => {
-  // handle response
-});
+codatLending.accountsReceivable.invoices
+  .list({
+    companyId: "{companyId}",
+    query: "currency=GBP",
+  })
+  .then((res) => {
+    // handle response
+  });
 ```
 
 </TabItem>
@@ -340,15 +344,17 @@ var res = await codatLending.AccountsReceivable.Invoices.ListAsync(new ListAccou
 import { CodatLending } from "@codat/lending";
 
 const codatLending = new CodatLending({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 
-codatLending.accountsReceivable.invoices.list({
-  companyId: "{companyId}",
-  query: "customerRef.id=61",
-}).then((res) => {
+codatLending.accountsReceivable.invoices
+  .list({
+    companyId: "{companyId}",
+    query: "customerRef.id=61",
+  })
+  .then((res) => {
     // handle response
-});
+  });
 ```
 
 </TabItem>
@@ -458,15 +464,17 @@ var res = await codatLending.AccountsReceivable.Invoices.ListAsync(new ListAccou
 import { CodatLending } from "@codat/lending";
 
 const codatLending = new CodatLending({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 
-codatLending.accountsReceivable.invoices.list({
-  companyId: "{companyId}",
-  query: "amountDue>0&&totalAmount<1000",
-}).then((res) => {
+codatLending.accountsReceivable.invoices
+  .list({
+    companyId: "{companyId}",
+    query: "amountDue>0&&totalAmount<1000",
+  })
+  .then((res) => {
     // handle response
-});
+  });
 ```
 
 </TabItem>
@@ -578,15 +586,17 @@ var res = await codatLending.AccountsReceivable.Invoices.ListAsync(new ListAccou
 import { CodatLending } from "@codat/lending";
 
 const codatLending = new CodatLending({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 
-codatLending.accountsReceivable.invoices.list({
-  companyId: "bae71d36-ff47-420a-b4a6-f8c9ddf41140",
-  query: "dueDate>2021-01-28",
-}).then((res) => {
+codatLending.accountsReceivable.invoices
+  .list({
+    companyId: "bae71d36-ff47-420a-b4a6-f8c9ddf41140",
+    query: "dueDate>2021-01-28",
+  })
+  .then((res) => {
     // handle response
-});
+  });
 ```
 
 </TabItem>
@@ -698,15 +708,17 @@ var res = await codatLending.AccountsReceivable.Invoices.ListAsync(new ListAccou
 import { CodatLending } from "@codat/lending";
 
 const codatLending = new CodatLending({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 
-codatLending.accountsReceivable.invoices.list({
-  companyId: "{companyId}",
-  query: "metadata.isDeleted!=true",
-}).then((res) => {
+codatLending.accountsReceivable.invoices
+  .list({
+    companyId: "{companyId}",
+    query: "metadata.isDeleted!=true",
+  })
+  .then((res) => {
     // handle response
-});
+  });
 ```
 
 </TabItem>
@@ -819,14 +831,16 @@ GET /companies?query=dataConnections.status=PendingAuth
 import { CodatPlatform } from "@codat/platform";
 
 const codatPlatform = new CodatPlatform({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 
-codatPlatform.companies.list({
-  query: "dataConnections.status=PendingAuth",
-}).then((res) => {
+codatPlatform.companies
+  .list({
+    query: "dataConnections.status=PendingAuth",
+  })
+  .then((res) => {
     // handle response
-});
+  });
 ```
 
 </TabItem>
@@ -895,13 +909,14 @@ func main() {
 </Tabs>
 
 ### Companies with no connections
-  
+
 Query: `dataConnections.status!=PendingAuth&&dataConnections.status!=Linked&&dataConnections.status!=Deauthorized&&dataConnections.status!=Unlinked`
 
 :::Note
+
 - The page size value is obligatory for querying.
 - The response will exclude companies that had connections but they were deleted.
-:::
+  :::
 
 <Tabs>
 
@@ -924,6 +939,7 @@ var res = await sdk.Companies.ListAsync(new ListCompaniesRequest() {
 
 // handle response
 ```
+
 </TabItem>
 
 <TabItem value="http" label="HTTP">
@@ -931,6 +947,7 @@ var res = await sdk.Companies.ListAsync(new ListCompaniesRequest() {
 ```http
 GET /companies?query=dataConnections.status=PendingAuth
 ```
+
 </TabItem>
 
 <TabItem value="nodejs" label="TypeScript">
@@ -939,15 +956,19 @@ GET /companies?query=dataConnections.status=PendingAuth
 import { CodatPlatform } from "@codat/platform";
 
 const codatPlatform = new CodatPlatform({
-    authHeader: "Basic BASE_64_ENCODED(API_KEY)",
+  authHeader: "Basic BASE_64_ENCODED(API_KEY)",
 });
 
-codatPlatform.companies.list({
-  query: "dataConnections.status!=PendingAuth&&dataConnections.status!=Linked&&dataConnections.status!=Deauthorized&&dataConnections.status!=Unlinked",
-}).then((res) => {
-  // handle response
-});
+codatPlatform.companies
+  .list({
+    query:
+      "dataConnections.status!=PendingAuth&&dataConnections.status!=Linked&&dataConnections.status!=Deauthorized&&dataConnections.status!=Unlinked",
+  })
+  .then((res) => {
+    // handle response
+  });
 ```
+
 </TabItem>
 
 <TabItem value="python" label="Python">
@@ -972,6 +993,7 @@ if res:
     # handle response
     pass
 ```
+
 </TabItem>
 
 <TabItem value="go" label="Go">
@@ -1007,6 +1029,7 @@ func main() {
     }
 }
 ```
+
 </TabItem>
 
 </Tabs>
diff --git a/docs/using-the-api/testing.md b/docs/using-the-api/testing.md
index 1bc7423d4..b51aeb1b5 100644
--- a/docs/using-the-api/testing.md
+++ b/docs/using-the-api/testing.md
@@ -4,7 +4,7 @@ sidebar_label: "Test your solution"
 description: "Review our suggestions, best practices, and strategies for testing your Codat build"
 ---
 
-Testing is a key component of any software development process, both during the implementation and after go-live if changes are made to the solution. Here is what Codat recommentd for testing your Codat build.
+Testing is a key component of any software development process, both during the implementation and after go-live if changes are made to the solution. Here is what Codat recommends for testing your Codat build.
 
 ## Using a test instance
 
diff --git a/docs/using-the-api/webhooks/create-consumer.md b/docs/using-the-api/webhooks/create-consumer.md
index 119f1e108..864ec286a 100644
--- a/docs/using-the-api/webhooks/create-consumer.md
+++ b/docs/using-the-api/webhooks/create-consumer.md
@@ -74,11 +74,16 @@ A message will be delivered every time any of the company’s tags match the tag
 
 ### Endpoint rate limits
 
-If your application can only handle a limited number of requests in a given time period, set a rate limit on the consumer endpoint to protect it from overloading. The rate limit is defined as a maximum number of messages per second to send to that endpoint. 
+If your application can only handle a limited number of requests in a given time period, set a rate limit on the consumer endpoint to protect it from overloading. The rate limit is defined as a maximum number of messages per second to send to that endpoint.
 
 After the limit is reached, the frequency of requests will be reduced not to exceed it. The actual rate of messages can sometimes be slightly above the enforced rate limit.
 
-<img width="740" height="446" alt="webhookratelimits" src="https://github.com/user-attachments/assets/6afec3df-eae3-4815-90e0-ee17bc1ee9d7" />
+<img
+  width="740"
+  height="446"
+  alt="webhookratelimits"
+  src="https://github.com/user-attachments/assets/6afec3df-eae3-4815-90e0-ee17bc1ee9d7"
+/>
 
 ## View webhook consumers
 
@@ -127,7 +132,7 @@ Follow the steps below to configure mTLS for a webhook consumer in Codat:
 2. Select the webhook consumer you want to configure mTLS for.
 3. In the detailed endpoint view, click **Advanced**, then **Configure mTLS**.
    ![A fragment of the webhook UI that directs the user to the mTLS configuration page](/img/use-the-api/webhook-advanced-mTLS.png)
-4. In the displayed text box, enter your **PEM-enconded private key** and the **X.509 certificate**, separating them by a blank line.
+4. In the displayed text box, enter your **PEM-encoded private key** and the **X.509 certificate**, separating them by a blank line.
    ![A fragment of the webhook UI that allows you to configure mTLS on your webhook consumers](/img/use-the-api/webhook-mTLS-configuration.png)
 5. Click **Save** to apply the configuration.
 
diff --git a/docs/using-the-api/webhooks/event-types.md b/docs/using-the-api/webhooks/event-types.md
index c9cf38d12..4a5bba309 100644
--- a/docs/using-the-api/webhooks/event-types.md
+++ b/docs/using-the-api/webhooks/event-types.md
@@ -43,8 +43,8 @@ See our migration guide to [switch to new event types](/using-the-api/webhooks/m
 | Expenses       | [`expenses.sync.unsuccessful`](/sync-for-expenses-api#/webhooks/expenses.sync.unsuccessful/post)                                         | Called when an expense sync fails to complete successfully, resulting in at least one error or warning.                         |
 | Lending        | [`report.categorizedBankStatement.generate.successful`](/lending-api#/webhooks/report.categorizedBankStatement.generate.successful/post) | Called when a [categorized bank statement](/lending/features/bank-statements-overview) is successfully generated for a company. |
 | Lending        | [`AccountCategoriesUpdated`](/lending-api#/webhooks/Account-categories-updated/post)                                                     | Called when Codat AI had [categorized accounts](/lending/features/financial-statements-overview) for a company.                 |
-| Lending        | [`reports.creditModel.generate.successful`](/lending-api#/webhooks/reports.creditModel.generate.successful/post)                                                     | Called when the [Credit Model report](/lending/premium-products/credit-model-overview) is successfully generated for a company.                 |
-| Lending        | [`reports.creditModel.generate.unsuccessful`](/lending-api#/webhooks/reports.creditModel.generate.unsuccessful/post)                                                     | Called when the [Credit Model report](/lending/premium-products/credit-model-overview) fails to generate for a company.                 |
+| Lending        | [`reports.creditModel.generate.successful`](/lending-api#/webhooks/reports.creditModel.generate.successful/post)                         | Called when the [Credit Model report](/lending/premium-products/credit-model-overview) is successfully generated for a company. |
+| Lending        | [`reports.creditModel.generate.unsuccessful`](/lending-api#/webhooks/reports.creditModel.generate.unsuccessful/post)                     | Called when the [Credit Model report](/lending/premium-products/credit-model-overview) fails to generate for a company.         |
 | Spend Insights | [`reports.spendAnalysis.generate.successful`](/spend-insights-api#/webhooks/reports.spendAnalysis.generate.successful/post)              | Called when a spend analysis report is successfully generated.                                                                  |
 | Spend Insights | [`reports.spendAnalysis.generate.unsuccessful`](/spend-insights-api#/webhooks/reports.spendAnalysis.generate.unsuccessful/post)          | Called when a spend analysis report has failed to be generated for a company.                                                   |
 
diff --git a/docs/using-the-api/webhooks/troubleshooting.md b/docs/using-the-api/webhooks/troubleshooting.md
index f58e24cff..af2607667 100644
--- a/docs/using-the-api/webhooks/troubleshooting.md
+++ b/docs/using-the-api/webhooks/troubleshooting.md
@@ -29,10 +29,10 @@ A webhook consumer endpoint which is disabled after the 5 min retry, but then re
 
 ## Message Status
 
-- "Success" indicates that there was at least one attempt for that message that succeeded against it's endpoint. 
+- "Success" indicates that there was at least one attempt for that message that succeeded against it's endpoint.
 - "Failure" indicates that all attempts were exhausted, and none of them succeeded.
 - "Attempting" indicates that at least one attempt has been sent and there are further attempts scheduled as part of the retry policy.
-- "Sending" indicates that the process of sending the webhook has begun but there have been no delivery attempts yet. 
+- "Sending" indicates that the process of sending the webhook has begun but there have been no delivery attempts yet.
 
 ## Recover failed and missed messages
 
@@ -41,7 +41,7 @@ Our webhooks service can recover two types of messages:
 - **Failed messages** occur when the message wasn't delivered even after all attempts to deliver the message have been exhausted. You can **recover** such messages.
 - **Missed messages** occur when the endpoint has been disabled, the endpoint didn't exist at the time of sending the message (but created afterward), or the endpoint initially configured to listen to other event types and has been updated to include additional ones. You can **replay** such messages.
 
-For each message to recover, we will attempt to send a new message, irrespetive of whether or not there are further attempts scheduled as part of the retry policy.
+For each message to recover, we will attempt to send a new message, irrespective of whether or not there are further attempts scheduled as part of the retry policy.
 
 If you want to replay or recover one or more messages in case of your app's downtime or incorrect configuration, you can do so in the [Codat Portal](https://app.codat.io/monitor/events).
 
@@ -67,11 +67,11 @@ Then, click the triple-dot menu on the right and choose one of the applicable op
 
 For more granular date control, you can scroll to the endpoint's message attempts, click the triple-dot options menu of a specific message, and choose **Replay > Replay all failed messages since this time**.
 
-During the recovery of mutiple messages, all messages will be sent at once with some jitter applied in order to prevent overloading the webhook consumer endpoint. If your system has rate-limiting in place, the number of messages to recover may be an important consideration to avoid further failures. Please reach out to Codat Support if unsure.
+During the recovery of multiple messages, all messages will be sent at once with some jitter applied in order to prevent overloading the webhook consumer endpoint. If your system has rate-limiting in place, the number of messages to recover may be an important consideration to avoid further failures. Please reach out to Codat Support if unsure.
 
 ### Idempotency
 
-Whilst the Codat system's webhook functionality aims for exactly once delivery of a message, due to the fact messages can be resent, this isn't always possible to guarantee. If idempotency is important for your system, we reccomend making use of the HTTP request's webhook-id header, which functions as an idempotency key for a given message, (i.e remains constant across all attempts to deliver that message), and can therefore be used by your system to ensure messages are not reprocessed.
+Whilst the Codat system's webhook functionality aims for exactly once delivery of a message, due to the fact messages can be resent, this isn't always possible to guarantee. If idempotency is important for your system, we recommend making use of the HTTP request's webhook-id header, which functions as an idempotency key for a given message, (i.e remains constant across all attempts to deliver that message), and can therefore be used by your system to ensure messages are not reprocessed.
 
 ## Endpoint failures
 
diff --git a/sidebars/lending.js b/sidebars/lending.js
index b3d484f5b..d1c880855 100644
--- a/sidebars/lending.js
+++ b/sidebars/lending.js
@@ -40,7 +40,7 @@ module.exports = [
   "lending/features/accounts-payable-overview",
   "lending/features/company-info-overview",
   "lending/features/excel-download-overview",
-{
+  {
     type: "link",
     href: "/lending/premium-products/credit-model-overview",
     label: "Credit model",