diff --git a/.gitignore b/.gitignore
index f4a6b95..493de37 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,3 +24,6 @@ dist-ssr
 *.sw?
 
 tsconfig.vitest-temp.json
+
+docs/.vitepress/cache
+docs/.vitepress/dist
\ No newline at end of file
diff --git a/README.md b/README.md
index b686f4e..2dfc38d 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,79 @@
-# query
-A typescript library for state management in Vue components
+# @kitbag/query
+
+A type-safe, composable query system designed specifically for Vue.js applications. Built for Vue 3's Composition API with intelligent caching, tag-based invalidation, and full TypeScript support.
+
+[![NPM Version][npm-badge]][npm-url]
+[![Netlify Status][netlify-badge]][netlify-url]
+[![Discord chat][discord-badge]][discord-url]
+[![Open in StackBlitz][stackblitz-badge]][stackblitz-url]
+
+<img src="https://kitbag.dev/kitbag-logo.svg" width="20%" />
+
+## Getting Started
+
+Get Started with our [documentation](https://kitbag-query.netlify.app/)
+
+## Features
+
+- **Type Safety First** - Fully typed queries, mutations, and data transformations
+- **Vue 3 Native** - Built for Composition API with reactive composables
+- **Intelligent Caching** - Smart caching with tag-based invalidation system
+- **Error Handling** - Built-in loading states, error handling, and retry logic
+- **Optimistic Updates** - Seamless mutations with automatic rollback on failure
+- **Composable Architecture** - Reusable functions that feel natural in Vue
+
+## Quick Start
+
+### Installation
+
+```bash
+# bun
+bun add @kitbag/query
+# yarn
+yarn add @kitbag/query
+# npm
+npm install @kitbag/query
+```
+
+### Creating a query
+
+Simply pass the function (`searchCats`) and a getter for the arguments to that function (`() => ['Maine Coon']`).
+
+```ts
+import { useQuery } from '@kitbag/query'
+
+function searchCats(breed?: string) {
+  ...
+}
+
+const catsQuery = useQuery(searchCats, () => ['Maine Coon'])
+```
+
+That's it! Now you have access to several useful properties on the query for tracking loading state, error state, and of course the response from `searchCats` when it's resolved.
+
+### Using a query
+
+```vue
+<template>
+  <div v-if="catsQuery.loading">
+    Loading...
+  </div>
+  
+  <div v-else-if="catsQuery.errored">
+    Error: {{ catsQuery.error }}
+  </div>
+  
+  <div v-for="cat in catsQuery.data ?? []" :key="cat.id">
+    <h1>{{ cat.name }}</h1>
+  </div>
+</template>
+```
+
+[npm-badge]: https://img.shields.io/npm/v/@kitbag/query.svg
+[npm-url]: https://www.npmjs.org/package/@kitbag/query
+[netlify-badge]: https://api.netlify.com/api/v1/badges/c12f79b8-49f9-4529-bc23-f8ffca8919a3/deploy-status
+[netlify-url]: https://app.netlify.com/sites/kitbag-query/deploys
+[stackblitz-badge]: https://developer.stackblitz.com/img/open_in_stackblitz_small.svg
+[stackblitz-url]: https://stackblitz.com/~/github.com/kitbagjs/query-preview
+[discord-badge]: https://img.shields.io/discord/1079625926024900739?logo=discord&label=Discord
+[discord-url]: https://discord.gg/zw7dpcc5HV
\ No newline at end of file
diff --git a/docs/.vitepress/config.ts b/docs/.vitepress/config.ts
new file mode 100644
index 0000000..d775075
--- /dev/null
+++ b/docs/.vitepress/config.ts
@@ -0,0 +1,99 @@
+import { defineConfig } from 'vitepress'
+
+// https://vitepress.dev/reference/site-config
+export default defineConfig({
+  title: "Kitbag Query | Type safe query for Vue.js",
+  description: "Type safe query for Vue.js",
+  head: [['link', { rel: 'icon', href: '/favicon.ico' }]],
+  themeConfig: {
+    logo: '/kitbag-logo-circle.svg',
+    siteTitle: 'Kitbag Query',
+
+    editLink: {
+      pattern: 'https://github.com/kitbagjs/query/edit/main/docs/:path',
+      text: 'Suggest changes to this page',
+    },
+    
+    nav: [
+      { text: 'Guide', link: '/introduction' },
+      { text: 'API', link: '/api/index' }
+    ],
+
+    search: {
+      provider: 'local'
+    },
+
+    sidebar: {
+      '/api/': [
+        {
+          text: 'API Reference',
+          items: [
+            { text: 'Overview', link: '/api/index' },
+          ]
+        }
+      ],
+      '/': [
+        {
+          text: 'Getting Started',
+          items: [
+            {
+              text: 'Introduction',
+              link: '/introduction',
+            },
+            {
+              text: 'Quick Start',
+              link: '/quick-start',
+            },
+          ],
+        },
+        {
+          text: 'Core Concepts',
+          items: [
+            { text: 'Queries', link: '/core-concepts/queries' },
+            { text: 'Tags & Invalidation', link: '/core-concepts/tags-invalidation' },
+            { text: 'Mutations', link: '/core-concepts/mutations' },
+            { text: 'Query Client', link: '/core-concepts/query-client' },
+            { text: 'Caching', link: '/core-concepts/caching' },
+          ],
+        },
+        {
+          text: 'Advanced Concepts',
+          items: [
+            { text: 'Error Handling', link: '/advanced-concepts/error-handling' },
+            { text: 'Loading States', link: '/advanced-concepts/loading-states' },
+            { text: 'Background Updates', link: '/advanced-concepts/background-updates' },
+            { text: 'Optimistic Updates', link: '/advanced-concepts/optimistic-updates' },
+            { text: 'Using syntax', link: '/advanced-concepts/using-queries' },
+          ],
+        },
+        { text: 'Migrating from Tanstack', link: '/compare-to-tanstack' },
+      ]
+    },
+
+    socialLinks: [
+      {
+        icon: {
+          svg: `<svg fill="#000000" height="800px" width="800px" version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" 
+        viewBox="0 0 330.242 330.242" xml:space="preserve">
+     <path d="M324.442,129.811l-41.321-33.677V42.275c0-6.065-4.935-11-11-11h-26c-6.065,0-11,4.935-11,11v14.737l-55.213-44.999
+       c-3.994-3.254-9.258-5.047-14.822-5.047c-5.542,0-10.781,1.782-14.753,5.019L5.8,129.81c-6.567,5.351-6.173,10.012-5.354,12.314
+       c0.817,2.297,3.448,6.151,11.884,6.151h19.791v154.947c0,11.058,8.972,20.053,20,20.053h62.5c10.935,0,19.5-8.809,19.5-20.053
+       v-63.541c0-5.446,5.005-10.405,10.5-10.405h42c5.238,0,9.5,4.668,9.5,10.405v63.541c0,10.87,9.388,20.053,20.5,20.053h61.5
+       c11.028,0,20-8.996,20-20.053V148.275h19.791c8.436,0,11.066-3.854,11.884-6.151C330.615,139.822,331.009,135.161,324.442,129.811z"
+       />
+     </svg>`
+        },
+        link: 'https://kitbag.dev',
+        ariaLabel: 'Kitbag Home'
+      },
+      { icon: 'github', link: 'https://github.com/kitbagjs/query' },
+      { icon: 'discord', link: 'https://discord.gg/zw7dpcc5HV' },
+      { icon: 'npm', link: 'https://www.npmjs.com/package/@kitbag/query' },
+    ]
+  },
+  markdown: {
+    image: {
+      lazyLoading: true
+    }
+  }
+})
\ No newline at end of file
diff --git a/docs/.vitepress/theme/index.js b/docs/.vitepress/theme/index.js
new file mode 100644
index 0000000..23eb585
--- /dev/null
+++ b/docs/.vitepress/theme/index.js
@@ -0,0 +1,4 @@
+import DefaultTheme from 'vitepress/theme'
+import './styles/vars.css'
+
+export default DefaultTheme
\ No newline at end of file
diff --git a/docs/.vitepress/theme/styles/vars.css b/docs/.vitepress/theme/styles/vars.css
new file mode 100644
index 0000000..e9eb43d
--- /dev/null
+++ b/docs/.vitepress/theme/styles/vars.css
@@ -0,0 +1,39 @@
+:root {
+  --kitbag-teal-300: rgba(94, 234, 212, 1);
+  --kitbag-teal-500: rgba(20, 184, 166, 1);
+  --kitbag-amber-500: rgba(245, 158, 11, 1);
+  --kitbag-teal-500-75: rgba(20, 184, 166, 0.75);
+
+  --vp-button-brand-bg: var(--kitbag-teal-500-75);
+  --vp-c-brand-1: var(--kitbag-teal-500);
+  --vp-c-brand-2: var(--kitbag-amber-500);
+
+  --vp-home-hero-name-color: transparent;
+  --vp-home-hero-name-background: -webkit-linear-gradient(
+    120deg,
+    var(--kitbag-teal-300) 30%,
+    var(--kitbag-amber-500)
+  );
+
+  --vp-home-hero-image-background-image: linear-gradient(
+    -45deg,
+    var(--kitbag-teal-500) 50%,
+    var(--kitbag-amber-500) 50%
+  );
+  --vp-home-hero-image-filter: blur(40px);
+}
+
+a.alt.stackblitz {
+  display: flex;
+  align-items: center;
+  color: rgb(19, 137, 253);
+  gap: 0.2rem;
+}
+
+a.alt.stackblitz::after {
+  display: block;
+  height: 14px;
+  width: 14px;
+  content: '';
+  background-image: url('/stackblitz.svg');
+}
\ No newline at end of file
diff --git a/docs/advanced-concepts/background-updates.md b/docs/advanced-concepts/background-updates.md
new file mode 100644
index 0000000..83d6518
--- /dev/null
+++ b/docs/advanced-concepts/background-updates.md
@@ -0,0 +1,765 @@
+# Background Updates
+
+<!-- Background updates allow your application to keep data fresh without interrupting the user experience. Kitbag query provides several mechanisms for updating data in the background.
+
+## Automatic Background Updates
+
+### Stale Time Configuration
+
+Control when queries automatically refetch in the background:
+
+```ts
+const userQuery = query('user', fetchUser, {
+  // Data is fresh for 5 minutes
+  staleTime: 5 * 60 * 1000,
+  
+  // After 5 minutes, queries will refetch in background when:
+  // - Component remounts
+  // - Window regains focus
+  // - Network reconnects
+})
+```
+
+### Cache Time vs Stale Time
+
+```ts
+const query = query('data', fetchData, {
+  staleTime: 2 * 60 * 1000,  // Fresh for 2 minutes
+  cacheTime: 10 * 60 * 1000, // Stay in cache for 10 minutes
+})
+
+// Timeline:
+// 0-2min: Data is fresh, no background updates
+// 2-10min: Data is stale, will update in background
+// 10min+: Data is removed from cache
+```
+
+## Focus-Based Updates
+
+Queries automatically refetch when the window regains focus:
+
+```vue
+<script setup lang="ts">
+// This will refetch when user returns to the tab
+const user = useQuery(userQuery, { 
+  params: [userId],
+  staleTime: 30 * 1000 // 30 seconds
+})
+
+// Disable focus refetching for specific queries
+const staticData = useQuery(configQuery, {
+  params: [],
+  refetchOnWindowFocus: false
+})
+</script>
+```
+
+### Controlling Focus Behavior
+
+```ts
+// Global configuration
+const { query, useQuery } = createQueryClient({
+  defaultQueryOptions: {
+    refetchOnWindowFocus: false, // Disable globally
+    staleTime: 5 * 60 * 1000
+  }
+})
+
+// Per-query override
+const liveData = useQuery(liveDataQuery, {
+  params: [],
+  refetchOnWindowFocus: true, // Enable for this query
+  staleTime: 0 // Always refetch
+})
+```
+
+## Network-Based Updates
+
+Queries refetch when network connection is restored:
+
+```vue
+<script setup lang="ts">
+import { useOnline } from '@vueuse/core'
+
+const isOnline = useOnline()
+
+const user = useQuery(userQuery, {
+  params: [userId],
+  // Refetch when coming back online
+  refetchOnReconnect: true
+})
+
+// Show connection status
+watch(isOnline, (online) => {
+  if (online) {
+    showToast('Connection restored - updating data', 'info')
+  } else {
+    showToast('You are offline', 'warning')
+  }
+})
+</script>
+
+<template>
+  <div>
+    <div v-if="!isOnline" class="offline-banner">
+      You are currently offline
+    </div>
+    
+    <div v-if="user.executing && user.data" class="sync-indicator">
+      Syncing data...
+    </div>
+    
+    <UserProfile v-if="user.data" :user="user.data" />
+  </div>
+</template>
+```
+
+## Manual Background Updates
+
+### Programmatic Refetch
+
+Trigger background updates manually:
+
+```vue
+<template>
+  <div>
+    <button 
+      @click="refreshData" 
+      :disabled="user.executing"
+      class="refresh-btn"
+    >
+      <RefreshIcon :class="{ 'spinning': user.executing }" />
+      Refresh
+    </button>
+    
+    <UserProfile v-if="user.data" :user="user.data" />
+  </div>
+</template>
+
+<script setup lang="ts">
+const user = useQuery(userQuery, { params: [userId] })
+
+async function refreshData() {
+  try {
+    await user.execute()
+    showToast('Data refreshed', 'success')
+  } catch (error) {
+    showToast('Failed to refresh data', 'error')
+  }
+}
+</script>
+```
+
+### Query Client Methods
+
+Use the query client to trigger updates:
+
+```vue
+<script setup lang="ts">
+import { useQueryClient } from '@kitbag/query'
+
+const queryClient = useQueryClient()
+
+// Invalidate specific query
+function invalidateUser() {
+  queryClient.invalidateQueries(userQuery, userId)
+}
+
+// Invalidate multiple queries
+function invalidateUserData() {
+  queryClient.invalidateQueries(userQuery)
+  queryClient.invalidateQueries(userPostsQuery)
+  queryClient.invalidateQueries(userSettingsQuery)
+}
+
+// Refetch all stale queries
+function refreshAllStale() {
+  queryClient.refetchQueries({ stale: true })
+}
+
+// Refetch active queries
+function refreshActive() {
+  queryClient.refetchQueries({ active: true })
+}
+</script>
+```
+
+## Polling and Intervals
+
+### Basic Polling
+
+Set up automatic polling for live data:
+
+```vue
+<script setup lang="ts">
+import { onMounted, onUnmounted } from 'vue'
+
+const liveStats = useQuery(liveStatsQuery, { params: [] })
+
+let pollInterval: number
+
+onMounted(() => {
+  // Poll every 30 seconds
+  pollInterval = setInterval(() => {
+    liveStats.execute()
+  }, 30000)
+})
+
+onUnmounted(() => {
+  clearInterval(pollInterval)
+})
+</script>
+
+<template>
+  <div>
+    <div class="live-indicator">
+      <div class="pulse"></div>
+      Live Data
+    </div>
+    
+    <StatsDisplay v-if="liveStats.data" :stats="liveStats.data" />
+  </div>
+</template>
+```
+
+### Smart Polling
+
+Only poll when the component is visible and the user is active:
+
+```vue
+<script setup lang="ts">
+import { useIntersectionObserver, useIdle } from '@vueuse/core'
+
+const containerRef = ref<HTMLElement>()
+const { stop: stopObserver } = useIntersectionObserver(
+  containerRef,
+  ([{ isIntersecting }]) => {
+    isVisible.value = isIntersecting
+  }
+)
+
+const { idle } = useIdle(5 * 60 * 1000) // 5 minutes
+const isVisible = ref(false)
+
+const shouldPoll = computed(() => 
+  isVisible.value && !idle.value && !document.hidden
+)
+
+const liveData = useQuery(liveDataQuery, { params: [] })
+
+let pollInterval: number
+
+watchEffect(() => {
+  clearInterval(pollInterval)
+  
+  if (shouldPoll.value) {
+    pollInterval = setInterval(() => {
+      liveData.execute()
+    }, 10000) // Poll every 10 seconds
+  }
+})
+
+onUnmounted(() => {
+  clearInterval(pollInterval)
+  stopObserver()
+})
+</script>
+
+<template>
+  <div ref="containerRef">
+    <div v-if="shouldPoll" class="polling-indicator">
+      Updating live data...
+    </div>
+    
+    <LiveDashboard v-if="liveData.data" :data="liveData.data" />
+  </div>
+</template>
+```
+
+### Conditional Polling
+
+Poll based on data state:
+
+```vue
+<script setup lang="ts">
+const jobStatus = useQuery(jobStatusQuery, { params: [jobId] })
+
+// Poll while job is running
+watchEffect(() => {
+  if (jobStatus.data.value?.status === 'running') {
+    const interval = setInterval(() => {
+      jobStatus.execute()
+    }, 2000)
+    
+    // Clean up when status changes
+    watch(() => jobStatus.data.value?.status, (status) => {
+      if (status !== 'running') {
+        clearInterval(interval)
+      }
+    })
+  }
+})
+</script>
+
+<template>
+  <div>
+    <div v-if="jobStatus.data?.status === 'running'" class="job-running">
+      <LoadingSpinner size="small" />
+      Job is running... ({{ jobStatus.data.progress }}%)
+    </div>
+    
+    <div v-else-if="jobStatus.data?.status === 'completed'" class="job-complete">
+      Job completed successfully!
+    </div>
+  </div>
+</template>
+```
+
+## WebSocket Integration
+
+Combine background updates with real-time updates:
+
+```vue
+<script setup lang="ts">
+import { useWebSocket } from '@vueuse/core'
+
+const user = useQuery(userQuery, { params: [userId] })
+
+// WebSocket for real-time updates
+const { data: wsData, open, close } = useWebSocket(
+  `ws://localhost:8080/users/${userId}`,
+  {
+    onMessage: (ws, event) => {
+      const update = JSON.parse(event.data)
+      
+      if (update.type === 'user_updated') {
+        // Update the cache immediately
+        queryClient.setQueryData(userQuery, userId, update.data)
+      }
+    }
+  }
+)
+
+onMounted(() => open())
+onUnmounted(() => close())
+
+// Still use background updates as fallback
+const refreshUser = () => {
+  user.execute()
+}
+</script>
+
+<template>
+  <div>
+    <div class="connection-status">
+      <div v-if="wsData" class="connected">🟢 Live</div>
+      <div v-else class="disconnected">🔴 Offline</div>
+    </div>
+    
+    <UserProfile v-if="user.data" :user="user.data" />
+  </div>
+</template>
+```
+
+## Background Update Strategies
+
+### Optimistic Background Updates
+
+Update the UI immediately, then sync in the background:
+
+```vue
+<script setup lang="ts">
+const posts = useQuery(postsQuery, { params: [] })
+
+// Optimistically add new post
+async function addPostOptimistically(newPost) {
+  // Update UI immediately
+  const optimisticPost = { ...newPost, id: Date.now(), pending: true }
+  
+  queryClient.setQueryData(postsQuery, [], (oldPosts) => [
+    optimisticPost,
+    ...oldPosts
+  ])
+  
+  try {
+    // Create post on server
+    const createdPost = await createPost(newPost)
+    
+    // Replace optimistic post with real data
+    queryClient.setQueryData(postsQuery, [], (oldPosts) =>
+      oldPosts.map(post => 
+        post.id === optimisticPost.id ? createdPost : post
+      )
+    )
+  } catch (error) {
+    // Remove optimistic post on error
+    queryClient.setQueryData(postsQuery, [], (oldPosts) =>
+      oldPosts.filter(post => post.id !== optimisticPost.id)
+    )
+    
+    showToast('Failed to create post', 'error')
+  }
+}
+</script>
+```
+
+### Background Sync Queue
+
+Queue mutations to sync in the background:
+
+```ts
+// composables/useBackgroundSync.ts
+import { ref } from 'vue'
+
+interface SyncItem {
+  id: string
+  mutation: () => Promise<any>
+  retries: number
+}
+
+const syncQueue = ref<SyncItem[]>([])
+const isProcessing = ref(false)
+
+export function useBackgroundSync() {
+  async function addToQueue(id: string, mutation: () => Promise<any>) {
+    syncQueue.value.push({ id, mutation, retries: 0 })
+    processQueue()
+  }
+  
+  async function processQueue() {
+    if (isProcessing.value || syncQueue.value.length === 0) return
+    
+    isProcessing.value = true
+    
+    while (syncQueue.value.length > 0) {
+      const item = syncQueue.value[0]
+      
+      try {
+        await item.mutation()
+        syncQueue.value.shift() // Remove successful item
+      } catch (error) {
+        item.retries++
+        
+        if (item.retries >= 3) {
+          syncQueue.value.shift() // Remove failed item
+          console.error('Background sync failed permanently:', error)
+        } else {
+          // Move to end of queue for retry
+          syncQueue.value.push(syncQueue.value.shift()!)
+        }
+      }
+    }
+    
+    isProcessing.value = false
+  }
+  
+  return {
+    addToQueue,
+    syncQueue: readonly(syncQueue),
+    isProcessing: readonly(isProcessing)
+  }
+}
+```
+
+### Smart Background Refresh
+
+Refresh data based on user behavior:
+
+```vue
+<script setup lang="ts">
+import { useIdle, usePageLeave } from '@vueuse/core'
+
+const { idle } = useIdle(2 * 60 * 1000) // 2 minutes
+const user = useQuery(userQuery, { params: [userId] })
+
+// Refresh when user becomes active again
+watch(idle, (isIdle) => {
+  if (!isIdle && user.data.value) {
+    // Check if data is stale before refreshing
+    const lastFetch = user.dataUpdatedAt?.value
+    const now = Date.now()
+    
+    if (lastFetch && now - lastFetch > 60000) { // 1 minute
+      user.execute()
+    }
+  }
+})
+
+// Refresh when user returns to page
+usePageLeave(() => {
+  // User left the page
+}, () => {
+  // User returned to page
+  if (user.data.value) {
+    user.execute()
+  }
+})
+</script>
+```
+
+## Background Update UI
+
+### Subtle Update Indicators
+
+Show non-intrusive indicators for background updates:
+
+```vue
+<template>
+  <div class="content-container">
+    // Subtle refresh indicator
+    <div 
+      v-if="user.executing && user.data" 
+      class="refresh-indicator"
+    >
+      <div class="refresh-bar"></div>
+    </div>
+    
+    // Main content
+    <UserProfile v-if="user.data" :user="user.data" />
+    
+    // Toast notification for successful updates
+    <Teleport to="body">
+      <Toast 
+        v-if="showUpdateToast"
+        message="Profile updated"
+        type="success"
+        @close="showUpdateToast = false"
+      />
+    </Teleport>
+  </div>
+</template>
+
+<script setup lang="ts">
+let lastDataTimestamp = 0
+
+const user = useQuery(userQuery, {
+  params: [userId],
+  onSuccess: (data) => {
+    const currentTimestamp = Date.now()
+    
+    // Show toast if this is a background update
+    if (lastDataTimestamp > 0 && currentTimestamp - lastDataTimestamp > 5000) {
+      showUpdateToast.value = true
+      setTimeout(() => {
+        showUpdateToast.value = false
+      }, 3000)
+    }
+    
+    lastDataTimestamp = currentTimestamp
+  }
+})
+
+const showUpdateToast = ref(false)
+</script>
+
+<style scoped>
+.refresh-indicator {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  z-index: 1000;
+}
+
+.refresh-bar {
+  height: 2px;
+  background: linear-gradient(90deg, #3b82f6, #06b6d4);
+  animation: refresh-pulse 2s ease-in-out infinite;
+}
+
+@keyframes refresh-pulse {
+  0%, 100% { opacity: 0.6; }
+  50% { opacity: 1; }
+}
+</style>
+```
+
+### Update Notifications
+
+Notify users of important background updates:
+
+```vue
+<script setup lang="ts">
+const notifications = useQuery(notificationsQuery, { params: [] })
+
+// Check for new notifications periodically
+let notificationInterval: number
+
+onMounted(() => {
+  notificationInterval = setInterval(() => {
+    notifications.execute()
+  }, 60000) // Check every minute
+})
+
+onUnmounted(() => {
+  clearInterval(notificationInterval)
+})
+
+// Show notification when new data arrives
+watch(() => notifications.data.value, (newNotifications, oldNotifications) => {
+  if (oldNotifications && newNotifications) {
+    const newCount = newNotifications.length - oldNotifications.length
+    
+    if (newCount > 0) {
+      showToast(
+        `${newCount} new notification${newCount > 1 ? 's' : ''}`,
+        'info'
+      )
+      
+      // Update document title
+      document.title = `(${newCount}) App Name`
+    }
+  }
+})
+</script>
+```
+
+## Performance Considerations
+
+### Debounced Background Updates
+
+Prevent excessive background updates:
+
+```ts
+import { debounce } from 'lodash-es'
+
+const debouncedRefresh = debounce(() => {
+  user.execute()
+}, 1000)
+
+// Multiple triggers will only result in one update
+window.addEventListener('focus', debouncedRefresh)
+window.addEventListener('online', debouncedRefresh)
+```
+
+### Batched Updates
+
+Batch multiple background updates:
+
+```ts
+// composables/useBatchedUpdates.ts
+const pendingUpdates = ref(new Set<string>())
+let updateTimeout: number
+
+export function useBatchedUpdates() {
+  function scheduleUpdate(queryKey: string) {
+    pendingUpdates.value.add(queryKey)
+    
+    clearTimeout(updateTimeout)
+    updateTimeout = setTimeout(() => {
+      // Execute all pending updates
+      pendingUpdates.value.forEach(key => {
+        queryClient.invalidateQueries(key)
+      })
+      
+      pendingUpdates.value.clear()
+    }, 100) // Batch updates within 100ms
+  }
+  
+  return { scheduleUpdate }
+}
+```
+
+## Best Practices
+
+### 1. Use Appropriate Stale Times
+
+```ts
+// ✅ Good - Match stale time to data characteristics
+const userProfile = query('user-profile', fetchUser, {
+  staleTime: 10 * 60 * 1000 // User profiles don't change often
+})
+
+const livePrice = query('stock-price', fetchPrice, {
+  staleTime: 1000 // Stock prices change frequently
+})
+```
+
+### 2. Be Mindful of Battery and Data Usage
+
+```ts
+// ✅ Reduce polling frequency when on mobile/low battery
+const isLowBattery = ref(false)
+
+navigator.getBattery?.().then(battery => {
+  isLowBattery.value = battery.level < 0.2
+  battery.addEventListener('levelchange', () => {
+    isLowBattery.value = battery.level < 0.2
+  })
+})
+
+const pollInterval = computed(() => 
+  isLowBattery.value ? 60000 : 10000
+)
+```
+
+### 3. Handle Background Update Errors Gracefully
+
+```ts
+const user = useQuery(userQuery, {
+  params: [userId],
+  onError: (error, { isBackground }) => {
+    if (isBackground) {
+      // Don't show intrusive errors for background updates
+      console.warn('Background update failed:', error)
+    } else {
+      // Show error for foreground requests
+      showToast('Failed to load user', 'error')
+    }
+  }
+})
+```
+
+### 4. Provide User Control
+
+```vue
+<template>
+  <div>
+    <div class="settings">
+      <label>
+        <input 
+          v-model="enableBackgroundUpdates" 
+          type="checkbox"
+        />
+        Enable automatic updates
+      </label>
+    </div>
+    
+    <UserProfile :user="user.data" />
+  </div>
+</template>
+
+<script setup lang="ts">
+const enableBackgroundUpdates = ref(true)
+
+const user = useQuery(userQuery, {
+  params: [userId],
+  refetchOnWindowFocus: enableBackgroundUpdates,
+  refetchOnReconnect: enableBackgroundUpdates
+})
+</script>
+```
+
+### 5. Monitor Background Update Performance
+
+```ts
+const user = useQuery(userQuery, {
+  params: [userId],
+  onSuccess: (data, { duration, isBackground }) => {
+    if (isBackground) {
+      // Track background update performance
+      analytics.track('background_update', {
+        query: 'user',
+        duration,
+        cached: duration < 100
+      })
+    }
+  }
+})
+```
+
+## Next Steps
+
+- [Optimistic Updates](/advanced-concepts/optimistic-updates) - Improving perceived performance
+- [Caching](/core-concepts/caching) - Understanding cache behavior
+- [Error Handling](/advanced-concepts/error-handling) - Handling background update errors -->
\ No newline at end of file
diff --git a/docs/advanced-concepts/error-handling.md b/docs/advanced-concepts/error-handling.md
new file mode 100644
index 0000000..18f91b8
--- /dev/null
+++ b/docs/advanced-concepts/error-handling.md
@@ -0,0 +1,664 @@
+# Error Handling
+
+<!-- Effective error handling is crucial for building robust applications. Kitbag query provides multiple layers of error handling for both queries and mutations.
+
+## Basic Error Handling
+
+### Query Errors
+
+```vue
+<template>
+  <div>
+    <div v-if="user.executing">Loading...</div>
+    <div v-else-if="user.error" class="error">
+      <h3>Failed to load user</h3>
+      <p>{{ user.error.message }}</p>
+      <button @click="user.execute()">Retry</button>
+    </div>
+    <div v-else-if="user.data">
+      // User data
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+const user = useQuery(userQuery, {
+  params: [userId],
+  onError: (error) => {
+    console.error('User query failed:', error)
+  }
+})
+</script>
+```
+
+### Mutation Errors
+
+```vue
+<template>
+  <form @submit.prevent="handleSubmit">
+    <input v-model="userData.name" />
+    <input v-model="userData.email" />
+    
+    <button type="submit" :disabled="createUser.executing">
+      Create User
+    </button>
+    
+    <div v-if="createUser.error" class="error">
+      {{ createUser.error.message }}
+    </div>
+  </form>
+</template>
+
+<script setup lang="ts">
+const createUser = useMutation(createUserMutation, {
+  onError: ({ error, payload }) => {
+    console.error('Failed to create user:', error)
+    showErrorToast('Failed to create user')
+  }
+})
+</script>
+```
+
+## Error Types
+
+### Network Errors
+
+Handle network connectivity issues:
+
+```ts
+const userQuery = query('user', async (id: number) => {
+  try {
+    const response = await fetch(`/api/users/${id}`)
+    return response.json()
+  } catch (error) {
+    // Network error
+    if (!navigator.onLine) {
+      throw new Error('You appear to be offline. Please check your connection.')
+    }
+    
+    // Timeout or other network issue
+    throw new Error('Network error occurred. Please try again.')
+  }
+})
+```
+
+### HTTP Errors
+
+Handle different HTTP status codes:
+
+```ts
+const userQuery = query('user', async (id: number) => {
+  const response = await fetch(`/api/users/${id}`)
+  
+  if (!response.ok) {
+    switch (response.status) {
+      case 404:
+        throw new Error('User not found')
+      case 403:
+        throw new Error('Access denied')
+      case 500:
+        throw new Error('Server error. Please try again later.')
+      default:
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+    }
+  }
+  
+  return response.json()
+})
+```
+
+### Validation Errors
+
+Handle validation errors from the API:
+
+```ts
+const createUserMutation = mutation(async (userData: CreateUserData) => {
+  const response = await fetch('/api/users', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(userData)
+  })
+  
+  if (!response.ok) {
+    const errorData = await response.json()
+    
+    if (response.status === 422) {
+      // Validation error
+      const error = new Error('Validation failed')
+      error.status = 422
+      error.data = errorData
+      throw error
+    }
+    
+    throw new Error(errorData.message || 'Failed to create user')
+  }
+  
+  return response.json()
+})
+```
+
+## Error Boundaries
+
+### Global Error Handling
+
+Set up global error handling for all queries and mutations:
+
+```ts
+// queryClient.ts
+import { createQueryClient } from '@kitbag/query'
+
+export const { query, useQuery, mutation, useMutation } = createQueryClient({
+  defaultQueryOptions: {
+    onError: (error) => {
+      // Log all query errors
+      console.error('Query error:', error)
+      
+      // Handle specific error types globally
+      if (error.status === 401) {
+        // Redirect to login
+        router.push('/login')
+      } else if (error.status >= 500) {
+        // Show generic server error message
+        showToast('Server error. Please try again later.', 'error')
+      }
+    }
+  },
+  
+  defaultMutationOptions: {
+    onError: ({ error }) => {
+      console.error('Mutation error:', error)
+      
+      // Global mutation error handling
+      if (error.status === 401) {
+        router.push('/login')
+      }
+    }
+  }
+})
+```
+
+### Component Error Boundaries
+
+Create reusable error boundary components:
+
+```vue
+// ErrorBoundary.vue
+<template>
+  <div class="error-boundary">
+    <div v-if="hasError" class="error-container">
+      <h2>Something went wrong</h2>
+      <p>{{ errorMessage }}</p>
+      <button @click="retry">Try Again</button>
+      <button @click="reset">Reset</button>
+    </div>
+    <slot v-else />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, provide, onErrorCaptured } from 'vue'
+
+const hasError = ref(false)
+const errorMessage = ref('')
+
+const retry = ref(() => {})
+const reset = () => {
+  hasError.value = false
+  errorMessage.value = ''
+}
+
+// Provide error boundary functions to children
+provide('errorBoundary', {
+  captureError: (error: Error, retryFn?: () => void) => {
+    hasError.value = true
+    errorMessage.value = error.message
+    retry.value = retryFn || reset
+  }
+})
+
+onErrorCaptured((error) => {
+  hasError.value = true
+  errorMessage.value = error.message
+  return false // Prevent error from propagating
+})
+</script>
+```
+
+Usage:
+
+```vue
+<template>
+  <ErrorBoundary>
+    <UserProfile :user-id="userId" />
+  </ErrorBoundary>
+</template>
+```
+
+## Retry Logic
+
+### Automatic Retries
+
+Configure automatic retries for transient errors:
+
+```ts
+const userQuery = query('user', fetchUser, {
+  retry: 3, // Retry up to 3 times
+  retryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 30000) // Exponential backoff
+})
+
+// Custom retry logic
+const importantQuery = query('important', fetchImportantData, {
+  retry: (failureCount, error) => {
+    // Don't retry on client errors (4xx)
+    if (error.status >= 400 && error.status < 500) {
+      return false
+    }
+    
+    // Retry up to 5 times for server errors
+    return failureCount < 5
+  }
+})
+```
+
+### Manual Retries
+
+Provide manual retry functionality:
+
+```vue
+<template>
+  <div>
+    <div v-if="user.error" class="error">
+      <p>{{ user.error.message }}</p>
+      <button @click="retry" :disabled="retrying">
+        {{ retrying ? 'Retrying...' : 'Retry' }}
+      </button>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+const retrying = ref(false)
+
+const user = useQuery(userQuery, { params: [userId] })
+
+async function retry() {
+  retrying.value = true
+  try {
+    await user.execute()
+  } finally {
+    retrying.value = false
+  }
+}
+</script>
+```
+
+## Error Recovery
+
+### Fallback Data
+
+Provide fallback data when queries fail:
+
+```vue
+<script setup lang="ts">
+const user = useQuery(userQuery, {
+  params: [userId],
+  placeholder: {
+    id: userId,
+    name: 'Unknown User',
+    email: 'unknown@example.com'
+  },
+  onError: (error) => {
+    // Keep placeholder data on error
+    console.warn('Using fallback user data due to error:', error)
+  }
+})
+
+// Always have data available
+const displayUser = computed(() => user.data.value || user.placeholder)
+</script>
+```
+
+### Partial Data Recovery
+
+Handle scenarios where some data loads successfully:
+
+```vue
+<script setup lang="ts">
+const userProfile = useQuery(userProfileQuery, { params: [userId] })
+const userPosts = useQuery(userPostsQuery, { params: [userId] })
+const userSettings = useQuery(userSettingsQuery, { params: [userId] })
+
+// Show what we can, even if some queries fail
+const canShowProfile = computed(() => !userProfile.error)
+const canShowPosts = computed(() => !userPosts.error)
+const canShowSettings = computed(() => !userSettings.error)
+</script>
+
+<template>
+  <div>
+    <div v-if="canShowProfile">
+      // User profile section
+    </div>
+    <div v-else class="error">
+      Failed to load profile
+    </div>
+    
+    <div v-if="canShowPosts">
+      // User posts section
+    </div>
+    <div v-else class="error">
+      Failed to load posts
+    </div>
+  </div>
+</template>
+```
+
+## User Experience
+
+### Error Messages
+
+Provide user-friendly error messages:
+
+```ts
+function getErrorMessage(error: any): string {
+  // Network errors
+  if (!navigator.onLine) {
+    return 'You appear to be offline. Please check your connection.'
+  }
+  
+  // HTTP status codes
+  switch (error.status) {
+    case 400:
+      return 'Invalid request. Please check your input.'
+    case 401:
+      return 'Please log in to continue.'
+    case 403:
+      return 'You do not have permission to access this resource.'
+    case 404:
+      return 'The requested resource was not found.'
+    case 429:
+      return 'Too many requests. Please wait a moment and try again.'
+    case 500:
+      return 'Server error. Please try again later.'
+    default:
+      return error.message || 'An unexpected error occurred.'
+  }
+}
+
+const user = useQuery(userQuery, {
+  params: [userId],
+  onError: (error) => {
+    const message = getErrorMessage(error)
+    showToast(message, 'error')
+  }
+})
+```
+
+### Loading and Error States
+
+Provide clear feedback during error recovery:
+
+```vue
+<template>
+  <div>
+    // Loading state
+    <div v-if="user.executing && !user.data" class="loading">
+      Loading user profile...
+    </div>
+    
+    // Error state with retry
+    <div v-else-if="user.error" class="error">
+      <h3>Unable to load profile</h3>
+      <p>{{ getErrorMessage(user.error) }}</p>
+      
+      <div class="error-actions">
+        <button @click="user.execute()" :disabled="user.executing">
+          {{ user.executing ? 'Retrying...' : 'Try Again' }}
+        </button>
+        <button @click="goBack">Go Back</button>
+      </div>
+    </div>
+    
+    // Success state
+    <div v-else-if="user.data">
+      // Profile content
+    </div>
+  </div>
+</template>
+```
+
+### Offline Support
+
+Handle offline scenarios gracefully:
+
+```vue
+<script setup lang="ts">
+import { useOnline } from '@vueuse/core'
+
+const isOnline = useOnline()
+
+const user = useQuery(userQuery, {
+  params: [userId],
+  enabled: isOnline, // Only execute when online
+  onError: (error) => {
+    if (!isOnline.value) {
+      showToast('You are offline. Data will sync when connection is restored.', 'info')
+    }
+  }
+})
+
+// Retry when coming back online
+watch(isOnline, (online) => {
+  if (online && user.error.value) {
+    user.execute()
+  }
+})
+</script>
+
+<template>
+  <div>
+    <div v-if="!isOnline" class="offline-banner">
+      You are currently offline
+    </div>
+    
+    // Rest of component
+  </div>
+</template>
+```
+
+## Error Monitoring
+
+### Logging and Analytics
+
+Set up error monitoring:
+
+```ts
+// errorTracking.ts
+interface ErrorContext {
+  userId?: string
+  operation: string
+  params?: any
+  timestamp: Date
+}
+
+function trackError(error: Error, context: ErrorContext) {
+  // Send to error tracking service
+  if (window.Sentry) {
+    window.Sentry.captureException(error, {
+      tags: {
+        operation: context.operation
+      },
+      user: {
+        id: context.userId
+      },
+      extra: {
+        params: context.params,
+        timestamp: context.timestamp
+      }
+    })
+  }
+  
+  // Send to analytics
+  if (window.gtag) {
+    window.gtag('event', 'exception', {
+      description: error.message,
+      fatal: false
+    })
+  }
+}
+
+// Use in queries
+const user = useQuery(userQuery, {
+  params: [userId],
+  onError: (error) => {
+    trackError(error, {
+      userId: currentUser.id,
+      operation: 'fetchUser',
+      params: [userId],
+      timestamp: new Date()
+    })
+  }
+})
+```
+
+### Error Reporting
+
+Create an error reporting component:
+
+```vue
+// ErrorReporter.vue
+<template>
+  <div class="error-reporter">
+    <h3>Something went wrong</h3>
+    <p>{{ error.message }}</p>
+    
+    <details>
+      <summary>Technical Details</summary>
+      <pre>{{ errorDetails }}</pre>
+    </details>
+    
+    <div class="actions">
+      <button @click="retry">Try Again</button>
+      <button @click="reportError">Report Issue</button>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+interface Props {
+  error: Error
+  context?: any
+  onRetry?: () => void
+}
+
+const props = defineProps<Props>()
+
+const errorDetails = computed(() => ({
+  message: props.error.message,
+  stack: props.error.stack,
+  context: props.context,
+  timestamp: new Date().toISOString(),
+  userAgent: navigator.userAgent,
+  url: window.location.href
+}))
+
+function retry() {
+  props.onRetry?.()
+}
+
+function reportError() {
+  // Send error report
+  fetch('/api/error-reports', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(errorDetails.value)
+  })
+  
+  showToast('Error reported. Thank you!', 'success')
+}
+</script>
+```
+
+## Best Practices
+
+### 1. Provide Meaningful Error Messages
+
+```ts
+// ✅ Good - User-friendly messages
+const getErrorMessage = (error) => {
+  if (error.status === 404) return 'User not found'
+  if (error.status === 403) return 'Access denied'
+  return 'Something went wrong. Please try again.'
+}
+
+// ❌ Bad - Technical error messages
+const error = 'HTTP 500: Internal Server Error'
+```
+
+### 2. Handle Errors at the Right Level
+
+```ts
+// ✅ Handle specific errors locally
+const user = useQuery(userQuery, {
+  onError: (error) => {
+    if (error.status === 404) {
+      router.push('/users')
+    }
+  }
+})
+
+// ✅ Handle common errors globally
+const queryClient = createQueryClient({
+  defaultQueryOptions: {
+    onError: (error) => {
+      if (error.status === 401) {
+        logout()
+      }
+    }
+  }
+})
+```
+
+### 3. Provide Recovery Options
+
+```vue
+// ✅ Always provide a way to recover
+<div v-if="error" class="error">
+  <p>{{ error.message }}</p>
+  <button @click="retry">Try Again</button>
+  <button @click="goBack">Go Back</button>
+</div>
+```
+
+### 4. Use Appropriate Retry Logic
+
+```ts
+// ✅ Retry transient errors only
+const query = query('data', fetcher, {
+  retry: (count, error) => {
+    // Don't retry client errors
+    if (error.status >= 400 && error.status < 500) {
+      return false
+    }
+    // Retry server errors up to 3 times
+    return count < 3
+  }
+})
+```
+
+### 5. Monitor and Track Errors
+
+```ts
+// ✅ Track errors for monitoring
+const user = useQuery(userQuery, {
+  onError: (error) => {
+    trackError(error, { operation: 'fetchUser', userId })
+  }
+})
+```
+
+## Next Steps
+
+- [Loading States](/advanced-concepts/loading-states) - Managing loading UX
+- [Background Updates](/advanced-concepts/background-updates) - Handling background data refresh
+- [Optimistic Updates](/advanced-concepts/optimistic-updates) - Improving perceived performance -->
\ No newline at end of file
diff --git a/docs/advanced-concepts/loading-states.md b/docs/advanced-concepts/loading-states.md
new file mode 100644
index 0000000..f555c74
--- /dev/null
+++ b/docs/advanced-concepts/loading-states.md
@@ -0,0 +1,757 @@
+# Loading States
+
+<!-- Managing loading states effectively is crucial for good user experience. Kitbag query provides granular loading state management for both queries and mutations.
+
+## Query Loading States
+
+### Basic Loading States
+
+```vue
+<template>
+  <div>
+    // Initial loading
+    <div v-if="user.executing && !user.data">
+      <LoadingSpinner />
+      <p>Loading user profile...</p>
+    </div>
+    
+    // Background refresh
+    <div v-else-if="user.executing && user.data">
+      <UserProfile :user="user.data" />
+      <div class="refresh-indicator">Updating...</div>
+    </div>
+    
+    // Loaded
+    <div v-else-if="user.data">
+      <UserProfile :user="user.data" />
+    </div>
+    
+    // Error
+    <div v-else-if="user.error">
+      <ErrorMessage :error="user.error" />
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+const user = useQuery(userQuery, { params: [userId] })
+</script>
+```
+
+### Loading State Properties
+
+```ts
+interface QueryResult<TData> {
+  executing: Ref<boolean>  // Currently fetching data
+  executed: Ref<boolean>   // Has been executed at least once
+  data: Ref<TData>         // Current data
+  error: Ref<unknown>      // Current error
+}
+```
+
+### Computed Loading States
+
+Create computed properties for different loading scenarios:
+
+```vue
+<script setup lang="ts">
+const user = useQuery(userQuery, { params: [userId] })
+
+// Different loading states
+const isInitialLoading = computed(() => 
+  user.executing.value && !user.executed.value
+)
+
+const isRefreshing = computed(() => 
+  user.executing.value && user.executed.value && user.data.value
+)
+
+const isReloading = computed(() => 
+  user.executing.value && user.executed.value && !user.data.value
+)
+
+const isEmpty = computed(() => 
+  !user.executing.value && !user.data.value && !user.error.value
+)
+</script>
+
+<template>
+  <div>
+    // Initial load
+    <div v-if="isInitialLoading" class="initial-loading">
+      <SkeletonLoader />
+    </div>
+    
+    // Background refresh
+    <div v-else-if="isRefreshing">
+      <UserProfile :user="user.data" />
+      <div class="refresh-bar">Updating...</div>
+    </div>
+    
+    // Reloading after error
+    <div v-else-if="isReloading" class="reloading">
+      <LoadingSpinner />
+      <p>Retrying...</p>
+    </div>
+    
+    // Content loaded
+    <div v-else-if="user.data">
+      <UserProfile :user="user.data" />
+    </div>
+  </div>
+</template>
+```
+
+## Mutation Loading States
+
+### Basic Mutation Loading
+
+```vue
+<template>
+  <form @submit.prevent="handleSubmit">
+    <input v-model="userData.name" placeholder="Name" />
+    <input v-model="userData.email" placeholder="Email" />
+    
+    <button 
+      type="submit" 
+      :disabled="createUser.executing"
+      :class="{ 'loading': createUser.executing }"
+    >
+      <LoadingSpinner v-if="createUser.executing" size="small" />
+      {{ createUser.executing ? 'Creating...' : 'Create User' }}
+    </button>
+    
+    // Success state
+    <div v-if="createUser.data && !createUser.executing" class="success">
+      User created successfully!
+    </div>
+    
+    // Error state
+    <div v-if="createUser.error" class="error">
+      {{ createUser.error.message }}
+    </div>
+  </form>
+</template>
+
+<script setup lang="ts">
+const userData = reactive({ name: '', email: '' })
+const createUser = useMutation(createUserMutation)
+
+async function handleSubmit() {
+  try {
+    await createUser.mutate(userData)
+    // Reset form on success
+    userData.name = ''
+    userData.email = ''
+  } catch (error) {
+    // Error is already available in createUser.error
+  }
+}
+</script>
+```
+
+### Multiple Mutation States
+
+Handle multiple mutations with different loading states:
+
+```vue
+<template>
+  <div>
+    <button 
+      @click="handleCreate" 
+      :disabled="isAnyLoading"
+      class="btn-primary"
+    >
+      <LoadingSpinner v-if="createUser.executing" size="small" />
+      Create
+    </button>
+    
+    <button 
+      @click="handleUpdate" 
+      :disabled="isAnyLoading"
+      class="btn-secondary"
+    >
+      <LoadingSpinner v-if="updateUser.executing" size="small" />
+      Update
+    </button>
+    
+    <button 
+      @click="handleDelete" 
+      :disabled="isAnyLoading"
+      class="btn-danger"
+    >
+      <LoadingSpinner v-if="deleteUser.executing" size="small" />
+      Delete
+    </button>
+    
+    // Global loading indicator
+    <div v-if="isAnyLoading" class="global-loading">
+      Processing...
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+const createUser = useMutation(createUserMutation)
+const updateUser = useMutation(updateUserMutation)
+const deleteUser = useMutation(deleteUserMutation)
+
+const isAnyLoading = computed(() => 
+  createUser.executing.value || 
+  updateUser.executing.value || 
+  deleteUser.executing.value
+)
+</script>
+```
+
+## Loading UI Components
+
+### Skeleton Loaders
+
+Create skeleton loaders for better perceived performance:
+
+```vue
+// SkeletonLoader.vue
+<template>
+  <div class="skeleton-loader">
+    <div class="skeleton-header">
+      <div class="skeleton-avatar"></div>
+      <div class="skeleton-text">
+        <div class="skeleton-line short"></div>
+        <div class="skeleton-line medium"></div>
+      </div>
+    </div>
+    <div class="skeleton-content">
+      <div class="skeleton-line long"></div>
+      <div class="skeleton-line medium"></div>
+      <div class="skeleton-line short"></div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.skeleton-loader {
+  animation: pulse 1.5s ease-in-out infinite;
+}
+
+.skeleton-line {
+  height: 16px;
+  background: #e2e8f0;
+  border-radius: 4px;
+  margin-bottom: 8px;
+}
+
+.skeleton-line.short { width: 60%; }
+.skeleton-line.medium { width: 80%; }
+.skeleton-line.long { width: 100%; }
+
+.skeleton-avatar {
+  width: 48px;
+  height: 48px;
+  background: #e2e8f0;
+  border-radius: 50%;
+}
+
+@keyframes pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.5; }
+}
+</style>
+```
+
+### Loading Spinner Component
+
+```vue
+// LoadingSpinner.vue
+<template>
+  <div :class="['spinner', `spinner-${size}`]">
+    <div class="spinner-circle"></div>
+  </div>
+</template>
+
+<script setup lang="ts">
+interface Props {
+  size?: 'small' | 'medium' | 'large'
+}
+
+withDefaults(defineProps<Props>(), {
+  size: 'medium'
+})
+</script>
+
+<style scoped>
+.spinner {
+  display: inline-block;
+}
+
+.spinner-circle {
+  border: 2px solid #f3f3f3;
+  border-top: 2px solid #3498db;
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+}
+
+.spinner-small .spinner-circle {
+  width: 16px;
+  height: 16px;
+}
+
+.spinner-medium .spinner-circle {
+  width: 32px;
+  height: 32px;
+}
+
+.spinner-large .spinner-circle {
+  width: 48px;
+  height: 48px;
+}
+
+@keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+</style>
+```
+
+### Progressive Loading
+
+Show content progressively as it loads:
+
+```vue
+<template>
+  <div class="progressive-loader">
+    // Always show basic structure
+    <div class="user-card">
+      <div class="user-avatar">
+        <img 
+          v-if="user.data?.avatar" 
+          :src="user.data.avatar" 
+          :alt="user.data?.name"
+        />
+        <div v-else class="avatar-placeholder">
+          {{ user.data?.name?.[0] || '?' }}
+        </div>
+      </div>
+      
+      <div class="user-info">
+        <h2 v-if="user.data?.name">{{ user.data.name }}</h2>
+        <div v-else class="skeleton-line short"></div>
+        
+        <p v-if="user.data?.email">{{ user.data.email }}</p>
+        <div v-else class="skeleton-line medium"></div>
+      </div>
+      
+      // Additional data loads separately
+      <div class="user-stats">
+        <div v-if="userStats.data">
+          <span>Posts: {{ userStats.data.posts }}</span>
+          <span>Followers: {{ userStats.data.followers }}</span>
+        </div>
+        <div v-else-if="userStats.executing">
+          <LoadingSpinner size="small" />
+          Loading stats...
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+const user = useQuery(userQuery, { params: [userId] })
+const userStats = useQuery(userStatsQuery, { 
+  params: computed(() => user.data.value ? [user.data.value.id] : null)
+})
+</script>
+```
+
+## Advanced Loading Patterns
+
+### Suspense-like Loading
+
+Create a suspense-like component for loading states:
+
+```vue
+// QuerySuspense.vue
+<template>
+  <div>
+    <slot v-if="!isLoading" />
+    <div v-else class="suspense-fallback">
+      <slot name="fallback">
+        <LoadingSpinner />
+        <p>Loading...</p>
+      </slot>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+interface Props {
+  queries: Array<{ executing: Ref<boolean>, data: Ref<any> }>
+}
+
+const props = defineProps<Props>()
+
+const isLoading = computed(() => 
+  props.queries.some(query => 
+    query.executing.value && !query.data.value
+  )
+)
+</script>
+```
+
+Usage:
+
+```vue
+<template>
+  <QuerySuspense :queries="[user, posts, settings]">
+    <template #fallback>
+      <SkeletonLoader />
+    </template>
+    
+    // This renders only when all queries have data
+    <UserDashboard 
+      :user="user.data" 
+      :posts="posts.data" 
+      :settings="settings.data" 
+    />
+  </QuerySuspense>
+</template>
+```
+
+### Staggered Loading
+
+Show content in stages:
+
+```vue
+<template>
+  <div class="staggered-content">
+    // Stage 1: Always show immediately
+    <div class="stage-1">
+      <h1>User Dashboard</h1>
+    </div>
+    
+    // Stage 2: Show when user data loads
+    <div v-if="user.data" class="stage-2">
+      <UserProfile :user="user.data" />
+    </div>
+    
+    // Stage 3: Show when additional data loads
+    <div v-if="user.data && posts.data" class="stage-3">
+      <UserPosts :posts="posts.data" />
+    </div>
+    
+    // Stage 4: Show when everything loads
+    <div v-if="user.data && posts.data && stats.data" class="stage-4">
+      <UserStats :stats="stats.data" />
+    </div>
+    
+    // Loading indicators for pending stages
+    <div v-if="!user.data" class="loading-stage">
+      <SkeletonLoader />
+    </div>
+    <div v-else-if="!posts.data" class="loading-stage">
+      <LoadingSpinner size="small" /> Loading posts...
+    </div>
+    <div v-else-if="!stats.data" class="loading-stage">
+      <LoadingSpinner size="small" /> Loading statistics...
+    </div>
+  </div>
+</template>
+```
+
+### Conditional Loading States
+
+Show different loading states based on context:
+
+```vue
+<script setup lang="ts">
+const searchTerm = ref('')
+const searchResults = useQuery(searchQuery, {
+  params: computed(() => searchTerm.value ? [searchTerm.value] : null)
+})
+
+const loadingState = computed(() => {
+  if (!searchTerm.value) return 'empty'
+  if (searchResults.executing.value && !searchResults.data.value) return 'searching'
+  if (searchResults.executing.value && searchResults.data.value) return 'refreshing'
+  if (searchResults.data.value?.length === 0) return 'no-results'
+  if (searchResults.data.value) return 'results'
+  if (searchResults.error.value) return 'error'
+  return 'idle'
+})
+</script>
+
+<template>
+  <div>
+    <input v-model="searchTerm" placeholder="Search users..." />
+    
+    <div class="search-results">
+      // Empty state
+      <div v-if="loadingState === 'empty'" class="empty-state">
+        <SearchIcon />
+        <p>Enter a search term to get started</p>
+      </div>
+      
+      // Searching
+      <div v-else-if="loadingState === 'searching'" class="searching">
+        <LoadingSpinner />
+        <p>Searching...</p>
+      </div>
+      
+      // Refreshing results
+      <div v-else-if="loadingState === 'refreshing'">
+        <SearchResults :results="searchResults.data" />
+        <div class="refresh-indicator">Updating results...</div>
+      </div>
+      
+      // No results
+      <div v-else-if="loadingState === 'no-results'" class="no-results">
+        <p>No results found for "{{ searchTerm }}"</p>
+      </div>
+      
+      // Results
+      <div v-else-if="loadingState === 'results'">
+        <SearchResults :results="searchResults.data" />
+      </div>
+      
+      // Error
+      <div v-else-if="loadingState === 'error'" class="error">
+        <p>Search failed: {{ searchResults.error.message }}</p>
+      </div>
+    </div>
+  </div>
+</template>
+```
+
+## Loading State Management
+
+### Global Loading State
+
+Track global loading across the app:
+
+```ts
+// composables/useGlobalLoading.ts
+import { ref, computed } from 'vue'
+
+const activeRequests = ref(new Set<string>())
+
+export function useGlobalLoading() {
+  const isLoading = computed(() => activeRequests.value.size > 0)
+  
+  function startLoading(id: string) {
+    activeRequests.value.add(id)
+  }
+  
+  function stopLoading(id: string) {
+    activeRequests.value.delete(id)
+  }
+  
+  return {
+    isLoading,
+    startLoading,
+    stopLoading
+  }
+}
+
+// Use in queries
+const { startLoading, stopLoading } = useGlobalLoading()
+
+const user = useQuery(userQuery, {
+  params: [userId],
+  onExecute: () => startLoading('user'),
+  onSuccess: () => stopLoading('user'),
+  onError: () => stopLoading('user')
+})
+```
+
+### Loading State Persistence
+
+Maintain loading states across route changes:
+
+```ts
+// composables/usePersistedLoading.ts
+import { ref } from 'vue'
+
+const loadingStates = ref(new Map<string, boolean>())
+
+export function usePersistedLoading(key: string) {
+  const isLoading = computed({
+    get: () => loadingStates.value.get(key) || false,
+    set: (value) => {
+      if (value) {
+        loadingStates.value.set(key, true)
+      } else {
+        loadingStates.value.delete(key)
+      }
+    }
+  })
+  
+  return { isLoading }
+}
+```
+
+## Best Practices
+
+### 1. Show Immediate Feedback
+
+```vue
+// ✅ Good - Immediate loading state
+<button @click="handleSubmit" :disabled="loading">
+  <LoadingSpinner v-if="loading" size="small" />
+  {{ loading ? 'Saving...' : 'Save' }}
+</button>
+
+// ❌ Bad - No loading feedback
+<button @click="handleSubmit">Save</button>
+```
+
+### 2. Use Appropriate Loading Indicators
+
+```vue
+// ✅ Skeleton for initial loads
+<SkeletonLoader v-if="!user.data && user.executing" />
+
+// ✅ Subtle indicator for background updates
+<div v-if="user.executing && user.data" class="refresh-indicator">
+  Updating...
+</div>
+
+// ✅ Spinner for explicit actions
+<LoadingSpinner v-if="mutation.executing" />
+```
+
+### 3. Prevent Multiple Submissions
+
+```vue
+// ✅ Disable buttons during loading
+<button 
+  @click="handleSubmit"
+  :disabled="createUser.executing"
+>
+  Submit
+</button>
+```
+
+### 4. Show Progress When Possible
+
+```vue
+// ✅ Show upload progress
+<div v-if="uploadFile.executing" class="upload-progress">
+  <div class="progress-bar">
+    <div 
+      class="progress-fill" 
+      :style="{ width: `${uploadProgress}%` }"
+    ></div>
+  </div>
+  <span>{{ uploadProgress }}% uploaded</span>
+</div>
+```
+
+### 5. Handle Loading State Cleanup
+
+```vue
+<script setup lang="ts">
+const query = useQuery(userQuery, { params: [userId] })
+
+// Clean up loading states on unmount
+onUnmounted(() => {
+  if (query.executing.value) {
+    query.dispose()
+  }
+})
+</script>
+```
+
+## Accessibility
+
+### Loading State Announcements
+
+```vue
+<template>
+  <div>
+    // Screen reader announcements
+    <div 
+      v-if="user.executing" 
+      aria-live="polite" 
+      aria-busy="true"
+      class="sr-only"
+    >
+      Loading user profile
+    </div>
+    
+    <div 
+      v-if="user.data && !user.executing"
+      aria-live="polite"
+      class="sr-only"
+    >
+      User profile loaded
+    </div>
+    
+    // Visual loading indicator
+    <LoadingSpinner 
+      v-if="user.executing"
+      aria-label="Loading user profile"
+    />
+    
+    // Content
+    <div v-if="user.data" role="main">
+      <UserProfile :user="user.data" />
+    </div>
+  </div>
+</template>
+```
+
+### Focus Management
+
+```vue
+<script setup lang="ts">
+const loadingRef = ref<HTMLElement>()
+const contentRef = ref<HTMLElement>()
+
+const user = useQuery(userQuery, {
+  params: [userId],
+  onSuccess: () => {
+    // Focus content when loaded
+    nextTick(() => {
+      contentRef.value?.focus()
+    })
+  }
+})
+
+// Focus loading indicator when loading starts
+watch(() => user.executing.value, (executing) => {
+  if (executing) {
+    nextTick(() => {
+      loadingRef.value?.focus()
+    })
+  }
+})
+</script>
+
+<template>
+  <div>
+    <div 
+      v-if="user.executing"
+      ref="loadingRef"
+      tabindex="-1"
+      aria-live="polite"
+    >
+      <LoadingSpinner /> Loading...
+    </div>
+    
+    <div 
+      v-else-if="user.data"
+      ref="contentRef"
+      tabindex="-1"
+    >
+      <UserProfile :user="user.data" />
+    </div>
+  </div>
+</template>
+```
+
+## Next Steps
+
+- [Background Updates](/advanced-concepts/background-updates) - Managing background data refresh
+- [Error Handling](/advanced-concepts/error-handling) - Handling loading errors
+- [Optimistic Updates](/advanced-concepts/optimistic-updates) - Improving perceived performance -->
\ No newline at end of file
diff --git a/docs/advanced-concepts/optimistic-updates.md b/docs/advanced-concepts/optimistic-updates.md
new file mode 100644
index 0000000..1165061
--- /dev/null
+++ b/docs/advanced-concepts/optimistic-updates.md
@@ -0,0 +1,832 @@
+# Optimistic Updates
+<!-- 
+Optimistic updates improve perceived performance by updating the UI immediately before the server confirms the change. This makes your application feel faster and more responsive.
+
+## Basic Optimistic Updates
+
+### Simple Optimistic Mutation
+
+```vue
+<template>
+  <div>
+    <button 
+      @click="handleLike" 
+      :disabled="likePost.executing"
+      :class="{ 'liked': post.isLiked }"
+    >
+      <HeartIcon :filled="post.isLiked" />
+      {{ post.likes }}
+    </button>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useQueryClient } from '@kitbag/query'
+
+const queryClient = useQueryClient()
+const props = defineProps<{ postId: string }>()
+
+const post = useQuery(postQuery, { params: [props.postId] })
+
+const likePost = useMutation(likePostMutation, {
+  onExecute: ({ payload }) => {
+    const [postId] = payload
+    
+    // Optimistically update the UI
+    queryClient.setQueryData(postQuery, postId, (oldPost) => ({
+      ...oldPost,
+      likes: oldPost.likes + (oldPost.isLiked ? -1 : 1),
+      isLiked: !oldPost.isLiked
+    }))
+  },
+  
+  onError: ({ payload, error }) => {
+    const [postId] = payload
+    
+    // Revert optimistic update on error
+    queryClient.setQueryData(postQuery, postId, (oldPost) => ({
+      ...oldPost,
+      likes: oldPost.likes + (oldPost.isLiked ? -1 : 1),
+      isLiked: !oldPost.isLiked
+    }))
+    
+    showToast('Failed to update like', 'error')
+  },
+  
+  onSuccess: ({ data, payload }) => {
+    const [postId] = payload
+    
+    // Update with server response (may have slight differences)
+    queryClient.setQueryData(postQuery, postId, data)
+  }
+})
+
+async function handleLike() {
+  await likePost.mutate(props.postId)
+}
+</script>
+```
+
+### List Updates
+
+Optimistically update items in lists:
+
+```vue
+<template>
+  <div>
+    <form @submit.prevent="handleAddTodo">
+      <input v-model="newTodoText" placeholder="Add todo..." />
+      <button type="submit">Add</button>
+    </form>
+    
+    <div class="todos">
+      <div 
+        v-for="todo in todos.data" 
+        :key="todo.id"
+        :class="{ 'pending': todo.pending }"
+      >
+        <input 
+          type="checkbox" 
+          :checked="todo.completed"
+          @change="toggleTodo(todo)"
+        />
+        <span>{{ todo.text }}</span>
+        
+        <button 
+          @click="deleteTodo(todo)"
+          :disabled="todo.pending"
+        >
+          Delete
+        </button>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+const newTodoText = ref('')
+const todos = useQuery(todosQuery, { params: [] })
+
+const addTodo = useMutation(addTodoMutation, {
+  onExecute: ({ payload }) => {
+    const [todoData] = payload
+    const optimisticTodo = {
+      id: `temp-${Date.now()}`,
+      ...todoData,
+      pending: true // Mark as pending
+    }
+    
+    // Add to list optimistically
+    queryClient.setQueryData(todosQuery, [], (oldTodos) => [
+      optimisticTodo,
+      ...oldTodos
+    ])
+  },
+  
+  onSuccess: ({ data, payload }) => {
+    const [todoData] = payload
+    
+    // Replace optimistic todo with real data
+    queryClient.setQueryData(todosQuery, [], (oldTodos) =>
+      oldTodos.map(todo => 
+        todo.text === todoData.text && todo.pending 
+          ? { ...data, pending: false }
+          : todo
+      )
+    )
+  },
+  
+  onError: ({ payload }) => {
+    const [todoData] = payload
+    
+    // Remove optimistic todo on error
+    queryClient.setQueryData(todosQuery, [], (oldTodos) =>
+      oldTodos.filter(todo => 
+        !(todo.text === todoData.text && todo.pending)
+      )
+    )
+  }
+})
+
+const toggleTodo = useMutation(toggleTodoMutation, {
+  onExecute: ({ payload }) => {
+    const [todoId] = payload
+    
+    // Toggle completion status optimistically
+    queryClient.setQueryData(todosQuery, [], (oldTodos) =>
+      oldTodos.map(todo => 
+        todo.id === todoId 
+          ? { ...todo, completed: !todo.completed, pending: true }
+          : todo
+      )
+    )
+  },
+  
+  onSettled: ({ payload }) => {
+    const [todoId] = payload
+    
+    // Remove pending state
+    queryClient.setQueryData(todosQuery, [], (oldTodos) =>
+      oldTodos.map(todo => 
+        todo.id === todoId 
+          ? { ...todo, pending: false }
+          : todo
+      )
+    )
+  }
+})
+
+async function handleAddTodo() {
+  if (!newTodoText.value.trim()) return
+  
+  await addTodo.mutate({ text: newTodoText.value, completed: false })
+  newTodoText.value = ''
+}
+</script>
+```
+
+## Advanced Optimistic Patterns
+
+### Rollback on Error
+
+Store previous state for accurate rollbacks:
+
+```vue
+<script setup lang="ts">
+const updateUser = useMutation(updateUserMutation, {
+  onExecute: ({ payload }) => {
+    const [userId, userData] = payload
+    
+    // Store previous state for rollback
+    const previousData = queryClient.getQueryData(userQuery, userId)
+    
+    // Store in mutation context for later use
+    updateUser.context = { previousData, userId }
+    
+    // Apply optimistic update
+    queryClient.setQueryData(userQuery, userId, (oldUser) => ({
+      ...oldUser,
+      ...userData
+    }))
+  },
+  
+  onError: ({ context }) => {
+    // Rollback to previous state
+    if (context?.previousData) {
+      queryClient.setQueryData(
+        userQuery, 
+        context.userId, 
+        context.previousData
+      )
+    }
+  },
+  
+  onSuccess: ({ data, context }) => {
+    // Update with server response
+    queryClient.setQueryData(userQuery, context.userId, data)
+  }
+})
+</script>
+```
+
+### Complex State Updates
+
+Handle complex state changes with multiple related queries:
+
+```vue
+<script setup lang="ts">
+const moveTaskToColumn = useMutation(moveTaskMutation, {
+  onExecute: ({ payload }) => {
+    const [taskId, fromColumnId, toColumnId, position] = payload
+    
+    // Store original state
+    const fromColumn = queryClient.getQueryData(columnQuery, fromColumnId)
+    const toColumn = queryClient.getQueryData(columnQuery, toColumnId)
+    const task = fromColumn?.tasks.find(t => t.id === taskId)
+    
+    if (!task) return
+    
+    // Store for rollback
+    moveTaskToColumn.context = { fromColumn, toColumn, task }
+    
+    // Update source column
+    queryClient.setQueryData(columnQuery, fromColumnId, (oldColumn) => ({
+      ...oldColumn,
+      tasks: oldColumn.tasks.filter(t => t.id !== taskId)
+    }))
+    
+    // Update destination column
+    queryClient.setQueryData(columnQuery, toColumnId, (oldColumn) => {
+      const newTasks = [...oldColumn.tasks]
+      newTasks.splice(position, 0, { ...task, pending: true })
+      return {
+        ...oldColumn,
+        tasks: newTasks
+      }
+    })
+    
+    // Update board summary
+    queryClient.setQueryData(boardQuery, boardId, (oldBoard) => ({
+      ...oldBoard,
+      lastUpdated: new Date().toISOString()
+    }))
+  },
+  
+  onError: ({ context }) => {
+    // Complex rollback
+    if (context) {
+      queryClient.setQueryData(columnQuery, fromColumnId, context.fromColumn)
+      queryClient.setQueryData(columnQuery, toColumnId, context.toColumn)
+      
+      // Revert board changes
+      queryClient.invalidateQueries(boardQuery, boardId)
+    }
+  },
+  
+  onSuccess: ({ data }) => {
+    // Refresh affected queries with server data
+    queryClient.invalidateQueries(columnQuery)
+    queryClient.invalidateQueries(boardQuery)
+  }
+})
+</script>
+```
+
+### Optimistic Updates with Validation
+
+Validate optimistic updates before applying:
+
+```vue
+<script setup lang="ts">
+function canApplyOptimisticUpdate(currentData, update) {
+  // Don't apply if data is stale
+  if (Date.now() - currentData.lastUpdated > 60000) {
+    return false
+  }
+  
+  // Don't apply if there are conflicting pending updates
+  if (currentData.pendingUpdates?.length > 0) {
+    return false
+  }
+  
+  // Custom validation logic
+  if (update.amount && update.amount > currentData.balance) {
+    return false
+  }
+  
+  return true
+}
+
+const updateBalance = useMutation(updateBalanceMutation, {
+  onExecute: ({ payload }) => {
+    const [accountId, amount] = payload
+    const currentData = queryClient.getQueryData(accountQuery, accountId)
+    
+    if (!canApplyOptimisticUpdate(currentData, { amount })) {
+      // Skip optimistic update, wait for server response
+      return
+    }
+    
+    queryClient.setQueryData(accountQuery, accountId, (oldAccount) => ({
+      ...oldAccount,
+      balance: oldAccount.balance + amount,
+      pendingUpdates: [...(oldAccount.pendingUpdates || []), amount]
+    }))
+  }
+})
+</script>
+```
+
+## Optimistic Update Strategies
+
+### Immediate Updates
+
+Apply changes instantly for the best perceived performance:
+
+```vue
+<script setup lang="ts">
+// Good for: Likes, favorites, simple toggles
+const toggleFavorite = useMutation(toggleFavoriteMutation, {
+  onExecute: ({ payload }) => {
+    const [itemId] = payload
+    
+    // Update immediately - no delay
+    queryClient.setQueryData(itemQuery, itemId, (oldItem) => ({
+      ...oldItem,
+      isFavorite: !oldItem.isFavorite,
+      favoriteCount: oldItem.favoriteCount + (oldItem.isFavorite ? -1 : 1)
+    }))
+  }
+})
+</script>
+```
+
+### Delayed Rollback
+
+Show success immediately, rollback only if needed:
+
+```vue
+<script setup lang="ts">
+const sendMessage = useMutation(sendMessageMutation, {
+  onExecute: ({ payload }) => {
+    const [messageData] = payload
+    const optimisticMessage = {
+      id: `temp-${Date.now()}`,
+      ...messageData,
+      status: 'sending',
+      timestamp: new Date().toISOString()
+    }
+    
+    // Add message immediately
+    queryClient.setQueryData(messagesQuery, [], (oldMessages) => [
+      ...oldMessages,
+      optimisticMessage
+    ])
+  },
+  
+  onSuccess: ({ data, payload }) => {
+    const [messageData] = payload
+    
+    // Replace with real message
+    queryClient.setQueryData(messagesQuery, [], (oldMessages) =>
+      oldMessages.map(msg => 
+        msg.text === messageData.text && msg.status === 'sending'
+          ? { ...data, status: 'sent' }
+          : msg
+      )
+    )
+  },
+  
+  onError: ({ payload }) => {
+    const [messageData] = payload
+    
+    // Mark as failed instead of removing
+    queryClient.setQueryData(messagesQuery, [], (oldMessages) =>
+      oldMessages.map(msg => 
+        msg.text === messageData.text && msg.status === 'sending'
+          ? { ...msg, status: 'failed' }
+          : msg
+      )
+    )
+  }
+})
+</script>
+```
+
+### Conditional Optimistic Updates
+
+Only apply optimistic updates in certain conditions:
+
+```vue
+<script setup lang="ts">
+const updateInventory = useMutation(updateInventoryMutation, {
+  onExecute: ({ payload }) => {
+    const [itemId, quantity] = payload
+    const currentItem = queryClient.getQueryData(itemQuery, itemId)
+    
+    // Only optimistic update for small changes
+    if (Math.abs(quantity) <= 5) {
+      queryClient.setQueryData(itemQuery, itemId, (oldItem) => ({
+        ...oldItem,
+        stock: oldItem.stock + quantity,
+        optimistic: true
+      }))
+    }
+    // For large changes, wait for server confirmation
+  },
+  
+  onSuccess: ({ data }) => {
+    // Always update with server data
+    queryClient.setQueryData(itemQuery, data.id, {
+      ...data,
+      optimistic: false
+    })
+  }
+})
+</script>
+```
+
+## Error Handling and Recovery
+
+### Graceful Error Recovery
+
+Handle optimistic update failures elegantly:
+
+```vue
+<template>
+  <div>
+    <div v-for="comment in comments.data" :key="comment.id">
+      <div :class="{ 'failed': comment.status === 'failed' }">
+        {{ comment.text }}
+        
+        <div v-if="comment.status === 'failed'" class="retry-actions">
+          <span>Failed to post</span>
+          <button @click="retryComment(comment)">Retry</button>
+          <button @click="discardComment(comment)">Discard</button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+const addComment = useMutation(addCommentMutation, {
+  onExecute: ({ payload }) => {
+    const [commentData] = payload
+    const optimisticComment = {
+      id: `temp-${Date.now()}`,
+      ...commentData,
+      status: 'pending',
+      timestamp: new Date().toISOString()
+    }
+    
+    queryClient.setQueryData(commentsQuery, [], (oldComments) => [
+      ...oldComments,
+      optimisticComment
+    ])
+  },
+  
+  onError: ({ payload }) => {
+    const [commentData] = payload
+    
+    // Mark as failed for user action
+    queryClient.setQueryData(commentsQuery, [], (oldComments) =>
+      oldComments.map(comment => 
+        comment.text === commentData.text && comment.status === 'pending'
+          ? { ...comment, status: 'failed' }
+          : comment
+      )
+    )
+  }
+})
+
+function retryComment(comment) {
+  // Reset status and retry
+  queryClient.setQueryData(commentsQuery, [], (oldComments) =>
+    oldComments.map(c => 
+      c.id === comment.id 
+        ? { ...c, status: 'pending' }
+        : c
+    )
+  )
+  
+  addComment.mutate({ text: comment.text })
+}
+
+function discardComment(comment) {
+  // Remove failed comment
+  queryClient.setQueryData(commentsQuery, [], (oldComments) =>
+    oldComments.filter(c => c.id !== comment.id)
+  )
+}
+</script>
+```
+
+### Conflict Resolution
+
+Handle conflicts when optimistic updates clash with server state:
+
+```vue
+<script setup lang="ts">
+const updateDocument = useMutation(updateDocumentMutation, {
+  onExecute: ({ payload }) => {
+    const [docId, changes] = payload
+    const currentDoc = queryClient.getQueryData(documentQuery, docId)
+    
+    // Store version for conflict detection
+    updateDocument.context = { 
+      version: currentDoc.version,
+      originalChanges: changes 
+    }
+    
+    // Apply optimistic changes
+    queryClient.setQueryData(documentQuery, docId, (oldDoc) => ({
+      ...oldDoc,
+      ...changes,
+      version: oldDoc.version + 1,
+      lastModified: new Date().toISOString()
+    }))
+  },
+  
+  onError: ({ error, context, payload }) => {
+    const [docId] = payload
+    
+    if (error.status === 409) { // Conflict
+      // Get latest version from server
+      queryClient.invalidateQueries(documentQuery, docId)
+      
+      // Show conflict resolution UI
+      showConflictDialog({
+        localChanges: context.originalChanges,
+        serverVersion: error.data.latestVersion
+      })
+    } else {
+      // Regular error - rollback
+      queryClient.invalidateQueries(documentQuery, docId)
+    }
+  }
+})
+</script>
+```
+
+## UI Feedback for Optimistic Updates
+
+### Visual Indicators
+
+Show users when changes are pending:
+
+```vue
+<template>
+  <div class="task-item">
+    <div 
+      :class="{ 
+        'completed': task.completed,
+        'pending': task.pending,
+        'failed': task.status === 'failed'
+      }"
+    >
+      <input 
+        type="checkbox" 
+        :checked="task.completed"
+        @change="toggleTask"
+        :disabled="task.pending"
+      />
+      
+      <span class="task-text">{{ task.title }}</span>
+      
+      // Status indicators
+      <div class="status-indicators">
+        <LoadingSpinner v-if="task.pending" size="small" />
+        <CheckIcon v-else-if="task.completed" class="success" />
+        <ErrorIcon v-else-if="task.status === 'failed'" class="error" />
+      </div>
+      
+      // Retry option for failed updates
+      <button 
+        v-if="task.status === 'failed'"
+        @click="retryTask"
+        class="retry-btn"
+      >
+        Retry
+      </button>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.pending {
+  opacity: 0.7;
+  background: #f3f4f6;
+}
+
+.failed {
+  background: #fef2f2;
+  border-left: 3px solid #ef4444;
+}
+
+.status-indicators {
+  margin-left: auto;
+}
+</style>
+```
+
+### Undo Functionality
+
+Provide undo options for optimistic updates:
+
+```vue
+<template>
+  <div>
+    // Action buttons
+    <button @click="deleteItem">Delete Item</button>
+    
+    // Undo toast
+    <Teleport to="body">
+      <div v-if="showUndoToast" class="undo-toast">
+        <span>Item deleted</span>
+        <button @click="undoDelete">Undo</button>
+        <button @click="confirmDelete">✕</button>
+      </div>
+    </Teleport>
+  </div>
+</template>
+
+<script setup lang="ts">
+let undoTimeout: number
+const showUndoToast = ref(false)
+let pendingDeletion = null
+
+const deleteItem = useMutation(deleteItemMutation, {
+  onExecute: ({ payload }) => {
+    const [itemId] = payload
+    const itemToDelete = queryClient.getQueryData(itemQuery, itemId)
+    
+    // Store for undo
+    pendingDeletion = { itemId, item: itemToDelete }
+    
+    // Remove from UI
+    queryClient.setQueryData(itemsQuery, [], (oldItems) =>
+      oldItems.filter(item => item.id !== itemId)
+    )
+    
+    // Show undo option
+    showUndoToast.value = true
+    undoTimeout = setTimeout(() => {
+      confirmDelete()
+    }, 5000) // Auto-confirm after 5 seconds
+  }
+})
+
+function undoDelete() {
+  if (pendingDeletion) {
+    // Restore item
+    queryClient.setQueryData(itemsQuery, [], (oldItems) => [
+      ...oldItems,
+      pendingDeletion.item
+    ])
+    
+    // Cancel the mutation
+    deleteItem.abort()
+    
+    pendingDeletion = null
+    showUndoToast.value = false
+    clearTimeout(undoTimeout)
+  }
+}
+
+function confirmDelete() {
+  showUndoToast.value = false
+  pendingDeletion = null
+  clearTimeout(undoTimeout)
+  // Mutation continues to server
+}
+</script>
+```
+
+## Best Practices
+
+### 1. Use for User-Initiated Actions
+
+```ts
+// ✅ Good - User actions that should feel instant
+const likePost = useMutation(likePostMutation, {
+  onExecute: optimisticallyToggleLike
+})
+
+const addComment = useMutation(addCommentMutation, {
+  onExecute: optimisticallyAddComment
+})
+
+// ❌ Avoid - Background/automatic updates
+const syncData = useMutation(syncDataMutation) // No optimistic update
+```
+
+### 2. Keep Optimistic Updates Simple
+
+```ts
+// ✅ Good - Simple state changes
+const toggleComplete = useMutation(toggleCompleteMutation, {
+  onExecute: ({ payload }) => {
+    const [taskId] = payload
+    queryClient.setQueryData(taskQuery, taskId, (old) => ({
+      ...old,
+      completed: !old.completed
+    }))
+  }
+})
+
+// ❌ Complex - Avoid complex calculations in optimistic updates
+const updateComplexState = useMutation(updateStateMutation, {
+  onExecute: ({ payload }) => {
+    // Avoid complex logic here
+  }
+})
+```
+
+### 3. Provide Clear Visual Feedback
+
+```vue
+// ✅ Show pending state
+<div :class="{ 'pending': item.pending }">
+  {{ item.title }}
+  <LoadingSpinner v-if="item.pending" size="small" />
+</div>
+
+// ❌ No indication of pending state
+<div>{{ item.title }}</div>
+```
+
+### 4. Handle Errors Gracefully
+
+```ts
+// ✅ Provide recovery options
+const mutation = useMutation(mutateFn, {
+  onError: ({ payload }) => {
+    // Rollback optimistic update
+    rollbackOptimisticUpdate(payload)
+    
+    // Provide retry option
+    showRetryOption()
+  }
+})
+```
+
+### 5. Consider Network Conditions
+
+```ts
+// ✅ Adapt to network conditions
+const isSlowConnection = useSlowConnection()
+
+const updateData = useMutation(updateDataMutation, {
+  onExecute: ({ payload }) => {
+    // Only optimistic update on fast connections
+    if (!isSlowConnection.value) {
+      applyOptimisticUpdate(payload)
+    }
+  }
+})
+```
+
+## Testing Optimistic Updates
+
+### Simulate Network Delays
+
+```ts
+// Test helper for simulating network conditions
+function simulateNetworkDelay(ms = 2000) {
+  const originalFetch = window.fetch
+  
+  window.fetch = async (...args) => {
+    await new Promise(resolve => setTimeout(resolve, ms))
+    return originalFetch(...args)
+  }
+  
+  return () => {
+    window.fetch = originalFetch
+  }
+}
+
+// In your tests
+test('optimistic updates work correctly', async () => {
+  const cleanup = simulateNetworkDelay(3000)
+  
+  // Test optimistic update behavior
+  await userEvent.click(likeButton)
+  
+  // Should show optimistic state immediately
+  expect(screen.getByText('1 like')).toBeInTheDocument()
+  
+  // Wait for server response
+  await waitFor(() => {
+    expect(screen.getByText('1 like')).toBeInTheDocument()
+  })
+  
+  cleanup()
+})
+```
+
+## Next Steps
+
+- [Error Handling](/advanced-concepts/error-handling) - Handling optimistic update failures
+- [Background Updates](/advanced-concepts/background-updates) - Combining with background sync
+- [Tags & Invalidation](/core-concepts/tags-invalidation) - Managing cache updates -->
\ No newline at end of file
diff --git a/docs/advanced-concepts/using-queries.md b/docs/advanced-concepts/using-queries.md
new file mode 100644
index 0000000..f76394f
--- /dev/null
+++ b/docs/advanced-concepts/using-queries.md
@@ -0,0 +1,11 @@
+# Using syntax
+
+Take advantage of Typescripts [using syntax](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management) to automatically dispose of your query when the function is finished executing.
+
+```ts
+function search(): void {
+  using catsQuery = await query(searchCats, ['American Shorthair'])
+
+  return catsQuery.data
+}
+```
diff --git a/docs/api/index.md b/docs/api/index.md
new file mode 100644
index 0000000..5932792
--- /dev/null
+++ b/docs/api/index.md
@@ -0,0 +1 @@
+# API
diff --git a/docs/compare-to-tanstack.md b/docs/compare-to-tanstack.md
new file mode 100644
index 0000000..11941a9
--- /dev/null
+++ b/docs/compare-to-tanstack.md
@@ -0,0 +1,3 @@
+# Migrating from Tanstack
+
+- no keys, caches function + arguments by default
diff --git a/docs/core-concepts/caching.md b/docs/core-concepts/caching.md
new file mode 100644
index 0000000..c406b1e
--- /dev/null
+++ b/docs/core-concepts/caching.md
@@ -0,0 +1,438 @@
+# Caching
+
+Unlike other query libraries, Kitbag queries take both the function and the arguments separately. This enables our queries to cache results to the same function with the same arguments for future queries. By default, if many queries are created for the same function and arguments combination - the function only actually gets executed a single time.
+
+<!-- Kitbag query provides intelligent caching to minimize network requests while keeping your data fresh. Understanding how caching works will help you build more efficient applications.
+
+## Cache Lifecycle
+
+Every query goes through several cache states:
+
+```
+Fresh → Stale → Inactive → Garbage Collected
+```
+
+### Fresh Data
+Data is considered "fresh" for the duration of `staleTime`. Fresh data won't trigger refetches.
+
+```ts
+const query = query('data', fetcher, {
+  staleTime: 5 * 60 * 1000 // Fresh for 5 minutes
+})
+```
+
+### Stale Data
+After `staleTime` expires, data becomes "stale" but is still served from cache. Stale data triggers background refetches when accessed.
+
+### Inactive Data
+Data becomes inactive when no components are actively using it. Inactive data remains in cache for `cacheTime`.
+
+### Garbage Collection
+After `cacheTime` expires, unused data is removed from memory.
+
+## Cache Configuration
+
+### Stale Time
+
+Controls how long data is considered fresh:
+
+```ts
+// Always fresh - never refetch automatically
+const staticQuery = query('config', fetchConfig, {
+  staleTime: Infinity
+})
+
+// Fresh for 1 minute
+const userQuery = query('user', fetchUser, {
+  staleTime: 60 * 1000
+})
+
+// Always stale - always refetch in background
+const liveQuery = query('live-data', fetchLiveData, {
+  staleTime: 0
+})
+```
+
+### Cache Time
+
+Controls how long inactive data stays in memory:
+
+```ts
+// Remove from memory after 2 minutes of no use
+const temporaryQuery = query('temp', fetcher, {
+  cacheTime: 2 * 60 * 1000
+})
+
+// Keep in memory for 1 hour after last use
+const persistentQuery = query('persistent', fetcher, {
+  cacheTime: 60 * 60 * 1000
+})
+
+// Never remove from memory
+const permanentQuery = query('permanent', fetcher, {
+  cacheTime: Infinity
+})
+```
+
+## Cache Strategies
+
+### Immediate Freshness
+
+For data that changes frequently:
+
+```ts
+const liveDataQuery = query('live-data', fetchLiveData, {
+  staleTime: 0,           // Always stale
+  cacheTime: 30 * 1000    // Keep for 30 seconds
+})
+```
+
+### Long-Term Caching
+
+For static or rarely-changing data:
+
+```ts
+const configQuery = query('config', fetchConfig, {
+  staleTime: 60 * 60 * 1000,    // Fresh for 1 hour
+  cacheTime: 24 * 60 * 60 * 1000 // Keep for 24 hours
+})
+```
+
+### Balanced Caching
+
+For typical application data:
+
+```ts
+const userQuery = query('user', fetchUser, {
+  staleTime: 5 * 60 * 1000,     // Fresh for 5 minutes
+  cacheTime: 30 * 60 * 1000     // Keep for 30 minutes
+})
+```
+
+## Cache Keys and Parameters
+
+Queries with different parameters create separate cache entries:
+
+```ts
+const userQuery = query('user', fetchUser)
+
+// These create separate cache entries:
+useQuery(userQuery, { params: [1] })  // Cache key: ['user', 1]
+useQuery(userQuery, { params: [2] })  // Cache key: ['user', 2]
+useQuery(userQuery, { params: [3] })  // Cache key: ['user', 3]
+```
+
+### Complex Parameters
+
+Objects and arrays in parameters are serialized for cache keys:
+
+```ts
+const searchQuery = query('search', fetchSearch)
+
+// Different cache entries:
+useQuery(searchQuery, { params: [{ term: 'vue', page: 1 }] })
+useQuery(searchQuery, { params: [{ term: 'vue', page: 2 }] })
+useQuery(searchQuery, { params: [{ term: 'react', page: 1 }] })
+```
+
+## Manual Cache Management
+
+### Setting Cache Data
+
+Directly set cache data:
+
+```ts
+// Set data for a specific query
+queryClient.setQueryData(userQuery, [userId], userData)
+
+// Set data with expiration
+queryClient.setQueryData(userQuery, [userId], userData, {
+  staleTime: 10 * 60 * 1000 // Fresh for 10 minutes
+})
+```
+
+### Getting Cache Data
+
+Retrieve data from cache:
+
+```ts
+// Get cached data (may be undefined)
+const cachedUser = queryClient.getQueryData(userQuery, [userId])
+
+// Get with fallback
+const user = queryClient.getQueryData(userQuery, [userId]) ?? defaultUser
+```
+
+### Removing Cache Data
+
+Remove specific cache entries:
+
+```ts
+// Remove specific query data
+queryClient.removeQuery(userQuery, [userId])
+
+// Remove all data for a query type
+queryClient.removeQueries(userQuery)
+
+// Remove all cache data
+queryClient.clear()
+```
+
+## Background Updates
+
+### Automatic Background Refetching
+
+Stale queries automatically refetch in the background:
+
+```ts
+const userQuery = query('user', fetchUser, {
+  staleTime: 2 * 60 * 1000 // Stale after 2 minutes
+})
+
+// First access - fetches from network
+const user1 = useQuery(userQuery, { params: [1] })
+
+// After 3 minutes - serves from cache, refetches in background
+const user1Again = useQuery(userQuery, { params: [1] })
+```
+
+### Manual Background Updates
+
+Trigger background updates manually:
+
+```ts
+// Refetch specific query in background
+queryClient.refetchQueries(userQuery, [userId])
+
+// Refetch all queries with a tag
+queryClient.refetchQueries(userTag)
+
+// Force refetch (ignore stale time)
+queryClient.refetchQueries(userQuery, [userId], { 
+  force: true 
+})
+```
+
+## Cache Persistence
+
+### Browser Storage
+
+Persist cache across browser sessions:
+
+```ts
+const { query, useQuery } = createQueryClient({
+  persistence: {
+    // Use localStorage for persistence
+    storage: 'local',
+    
+    // Persist for 24 hours
+    maxAge: 24 * 60 * 60 * 1000,
+    
+    // Only persist specific queries
+    shouldPersist: (queryKey) => {
+      return queryKey[0] === 'user-preferences' || 
+             queryKey[0] === 'app-config'
+    }
+  }
+})
+```
+
+### Custom Storage
+
+Use custom storage implementation:
+
+```ts
+const { query, useQuery } = createQueryClient({
+  persistence: {
+    storage: {
+      getItem: (key) => myStorage.get(key),
+      setItem: (key, value) => myStorage.set(key, value),
+      removeItem: (key) => myStorage.delete(key)
+    }
+  }
+})
+```
+
+## Cache Optimization Patterns
+
+### Prefetching
+
+Load data before it's needed:
+
+```ts
+// Prefetch user data when hovering over link
+const prefetchUser = (userId: number) => {
+  queryClient.prefetchQuery(userQuery, [userId])
+}
+
+// In component
+<router-link 
+  :to="`/user/${userId}`"
+  @mouseenter="prefetchUser(userId)"
+>
+  View Profile
+</router-link>
+```
+
+### Cache Warming
+
+Pre-populate cache with known data:
+
+```ts
+// When creating a user, add to users list cache
+const createUserMutation = query.mutation(createUser, {
+  onSuccess: (newUser) => {
+    // Update the users list cache
+    queryClient.setQueryData(usersQuery, (oldUsers) => {
+      return [...(oldUsers || []), newUser]
+    })
+  }
+})
+```
+
+### Optimistic Updates
+
+Update cache immediately, rollback on error:
+
+```ts
+const updateUserMutation = query.mutation(updateUser, {
+  onMutate: async (variables) => {
+    // Cancel outgoing queries
+    await queryClient.cancelQueries(userQuery, [variables.id])
+    
+    // Snapshot current data
+    const previousUser = queryClient.getQueryData(userQuery, [variables.id])
+    
+    // Optimistically update
+    queryClient.setQueryData(userQuery, [variables.id], {
+      ...previousUser,
+      ...variables
+    })
+    
+    return { previousUser }
+  },
+  
+  onError: (error, variables, context) => {
+    // Rollback on error
+    queryClient.setQueryData(
+      userQuery, 
+      [variables.id], 
+      context?.previousUser
+    )
+  }
+})
+```
+
+## Cache Debugging
+
+### Development Tools
+
+Enable detailed cache logging:
+
+```ts
+const { query, useQuery } = createQueryClient({
+  devtools: process.env.NODE_ENV === 'development',
+  logger: {
+    log: console.log,
+    warn: console.warn,
+    error: console.error
+  }
+})
+```
+
+### Cache Inspection
+
+Inspect cache state in development:
+
+```ts
+// Get all cached queries
+const allQueries = queryClient.getQueriesData()
+
+// Get cache statistics  
+const cacheStats = queryClient.getCacheStats()
+
+// Log cache state
+console.table(queryClient.getQueryCache())
+```
+
+## Best Practices
+
+### 1. Match Cache Times to Data Patterns
+
+```ts
+// Static data - long cache times
+const configQuery = query('config', fetchConfig, {
+  staleTime: 60 * 60 * 1000,     // 1 hour
+  cacheTime: 24 * 60 * 60 * 1000  // 24 hours
+})
+
+// User data - moderate cache times
+const userQuery = query('user', fetchUser, {
+  staleTime: 5 * 60 * 1000,      // 5 minutes
+  cacheTime: 30 * 60 * 1000      // 30 minutes
+})
+
+// Live data - short cache times
+const liveQuery = query('live', fetchLive, {
+  staleTime: 10 * 1000,          // 10 seconds
+  cacheTime: 60 * 1000           // 1 minute
+})
+```
+
+### 2. Use Global Defaults
+
+Set sensible defaults for most queries:
+
+```ts
+const { query, useQuery } = createQueryClient({
+  defaultStaleTime: 2 * 60 * 1000,    // 2 minutes
+  defaultCacheTime: 10 * 60 * 1000,   // 10 minutes
+  defaultRetryCount: 3
+})
+```
+
+### 3. Consider Memory Usage
+
+Monitor cache size in production:
+
+```ts
+// Limit cache size
+const { query, useQuery } = createQueryClient({
+  maxQueries: 1000,  // Maximum number of cached queries
+  maxCacheSize: 50 * 1024 * 1024 // 50MB cache limit
+})
+```
+
+### 4. Test Cache Behavior
+
+Test your cache configuration:
+
+```ts
+// Test stale data behavior
+test('serves stale data while refetching', async () => {
+  const query = createQuery('test', () => Promise.resolve('data'), {
+    staleTime: 1000
+  })
+  
+  const { result } = renderHook(() => useQuery(query))
+  
+  // Initial fetch
+  await waitFor(() => expect(result.current.data).toBe('data'))
+  
+  // Wait for stale time
+  await sleep(1500)
+  
+  // Should serve stale data immediately
+  const { result: result2 } = renderHook(() => useQuery(query))
+  expect(result2.current.data).toBe('data')
+  expect(result2.current.isStale).toBe(true)
+})
+```
+
+## Next Steps
+
+Learn about advanced caching strategies:
+
+- [Background Updates](/advanced-concepts/background-updates) - Advanced update patterns
+- [Optimistic Updates](/advanced-concepts/optimistic-updates) - Immediate feedback strategies
+- [Loading States](/advanced-concepts/loading-states) - Managing cache and loading states -->
\ No newline at end of file
diff --git a/docs/core-concepts/mutations.md b/docs/core-concepts/mutations.md
new file mode 100644
index 0000000..2a8507a
--- /dev/null
+++ b/docs/core-concepts/mutations.md
@@ -0,0 +1,401 @@
+# Mutations
+
+<!-- Mutations handle data modifications in Kitbag query. They provide a structured way to update server state while managing loading states, errors, and cache invalidation.
+
+## Basic Mutation
+
+Create a mutation using the query client:
+
+```ts
+import { createQueryClient } from '@kitbag/query'
+
+const { query } = createQueryClient()
+
+const createUserMutation = query.mutation(async (userData: CreateUserData) => {
+  const response = await fetch('/api/users', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(userData)
+  })
+  
+  if (!response.ok) throw new Error('Failed to create user')
+  return response.json()
+})
+```
+
+## Using Mutations in Components
+
+Use mutations in your Vue components:
+
+```vue
+<template>
+  <form @submit.prevent="handleSubmit">
+    <input v-model="form.name" placeholder="Name" required />
+    <input v-model="form.email" placeholder="Email" required />
+    
+    <button type="submit" :disabled="createUser.pending">
+      {{ createUser.pending ? 'Creating...' : 'Create User' }}
+    </button>
+    
+    <div v-if="createUser.error" class="error">
+      {{ createUser.error.message }}
+    </div>
+  </form>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue'
+import { createUserMutation } from '../queries/users'
+
+const form = ref({
+  name: '',
+  email: ''
+})
+
+const createUser = createUserMutation()
+
+const handleSubmit = async () => {
+  try {
+    const newUser = await createUser.mutate(form.value)
+    console.log('User created:', newUser)
+    // Reset form or redirect
+    form.value = { name: '', email: '' }
+  } catch (error) {
+    // Error handling is automatic, but you can add custom logic here
+    console.error('Failed to create user:', error)
+  }
+}
+</script>
+```
+
+## Mutation State
+
+Mutations provide reactive state for tracking the operation:
+
+```ts
+const createUser = createUserMutation()
+
+// Reactive state properties:
+createUser.pending    // boolean - Is the mutation running?
+createUser.error      // Error | null - Any error that occurred
+createUser.data       // T | undefined - The result data
+createUser.mutate     // Function to trigger the mutation
+createUser.reset      // Function to reset state
+```
+
+## Mutation Options
+
+Configure mutations with options:
+
+```ts
+const updateUserMutation = query.mutation(
+  async (userData: UpdateUserData) => {
+    // Mutation logic
+  },
+  {
+    // Retry failed mutations
+    retry: 2,
+    
+    // Custom retry delay
+    retryDelay: (attempt) => attempt * 1000,
+    
+    // Tags to invalidate on success
+    invalidateTags: [userTag, profileTag],
+    
+    // Optimistic updates
+    onMutate: async (variables) => {
+      // Cancel outgoing queries
+      await queryClient.cancelQueries(userQuery)
+      
+      // Snapshot current value
+      const previousUser = queryClient.getQueryData(userQuery, variables.id)
+      
+      // Optimistically update
+      queryClient.setQueryData(userQuery, variables.id, {
+        ...previousUser,
+        ...variables
+      })
+      
+      return { previousUser }
+    },
+    
+    // Rollback on error
+    onError: (error, variables, context) => {
+      queryClient.setQueryData(userQuery, variables.id, context?.previousUser)
+    },
+    
+    // Always run after mutation
+    onSettled: () => {
+      queryClient.invalidateQueries(userQuery)
+    }
+  }
+)
+```
+
+## Cache Invalidation
+
+Mutations can automatically invalidate related queries:
+
+```ts
+import { userTag, profileTag } from '../tags'
+
+const updateUserMutation = query.mutation(
+  async (userData: UpdateUserData) => {
+    const response = await fetch(`/api/users/${userData.id}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(userData)
+    })
+    return response.json()
+  },
+  {
+    // Invalidate all queries with these tags
+    invalidateTags: [userTag, profileTag]
+  }
+)
+```
+
+## Optimistic Updates
+
+Provide instant feedback with optimistic updates:
+
+```ts
+const updateUserMutation = query.mutation(
+  async (userData: UpdateUserData) => {
+    // Actual API call
+    const response = await fetch(`/api/users/${userData.id}`, {
+      method: 'PUT',
+      body: JSON.stringify(userData)
+    })
+    return response.json()
+  },
+  {
+    onMutate: async (variables) => {
+      // Cancel any outgoing refetches
+      await queryClient.cancelQueries(userQuery)
+      
+      // Snapshot the previous value
+      const previousUser = queryClient.getQueryData(userQuery, [variables.id])
+      
+      // Optimistically update to the new value
+      queryClient.setQueryData(userQuery, [variables.id], {
+        ...previousUser,
+        ...variables
+      })
+      
+      // Return context for potential rollback
+      return { previousUser, userId: variables.id }
+    },
+    
+    onError: (error, variables, context) => {
+      // Rollback on error
+      if (context?.previousUser) {
+        queryClient.setQueryData(
+          userQuery, 
+          [context.userId], 
+          context.previousUser
+        )
+      }
+    },
+    
+    onSettled: (data, error, variables) => {
+      // Always refetch to ensure we have the latest data
+      queryClient.invalidateQueries(userQuery, [variables.id])
+    }
+  }
+)
+```
+
+## Multiple Mutations
+
+Handle multiple related mutations:
+
+```ts
+// Create separate mutations for different operations
+const createUserMutation = query.mutation(createUserAPI)
+const updateUserMutation = query.mutation(updateUserAPI)
+const deleteUserMutation = query.mutation(deleteUserAPI)
+
+// Use in component
+const createUser = createUserMutation()
+const updateUser = updateUserMutation()
+const deleteUser = deleteUserMutation()
+
+const handleCreate = () => createUser.mutate(userData)
+const handleUpdate = () => updateUser.mutate(userData)
+const handleDelete = () => deleteUser.mutate(userId)
+```
+
+## Error Handling
+
+Handle different types of errors:
+
+```ts
+const mutation = query.mutation(
+  async (data) => {
+    const response = await fetch('/api/data', {
+      method: 'POST',
+      body: JSON.stringify(data)
+    })
+    
+    if (!response.ok) {
+      // Different error types for different status codes
+      if (response.status === 400) {
+        const errorData = await response.json()
+        throw new ValidationError(errorData.message, errorData.fields)
+      } else if (response.status === 401) {
+        throw new AuthError('Unauthorized')
+      } else {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+      }
+    }
+    
+    return response.json()
+  }
+)
+
+// In component
+const handleSubmit = async () => {
+  try {
+    await mutate(formData)
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      // Handle validation errors
+      setFieldErrors(error.fields)
+    } else if (error instanceof AuthError) {
+      // Redirect to login
+      router.push('/login')
+    } else {
+      // Generic error handling
+      showToast('Something went wrong')
+    }
+  }
+}
+```
+
+## Mutation Patterns
+
+### Form Submission
+
+```ts
+const submitFormMutation = query.mutation(async (formData: FormData) => {
+  const response = await fetch('/api/submit', {
+    method: 'POST',
+    body: formData
+  })
+  return response.json()
+})
+
+// Usage
+const submitForm = submitFormMutation()
+
+const handleSubmit = async (event: Event) => {
+  const formData = new FormData(event.target as HTMLFormElement)
+  await submitForm.mutate(formData)
+}
+```
+
+### Batch Operations
+
+```ts
+const batchUpdateMutation = query.mutation(async (updates: BatchUpdate[]) => {
+  const response = await fetch('/api/batch-update', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ updates })
+  })
+  return response.json()
+})
+```
+
+### File Upload
+
+```ts
+const uploadFileMutation = query.mutation(
+  async (file: File) => {
+    const formData = new FormData()
+    formData.append('file', file)
+    
+    const response = await fetch('/api/upload', {
+      method: 'POST',
+      body: formData
+    })
+    return response.json()
+  },
+  {
+    // Don't retry file uploads
+    retry: false
+  }
+)
+```
+
+## Best Practices
+
+### 1. Use Descriptive Names
+
+Make mutation purposes clear:
+
+```ts
+// ✅ Good
+const createUserMutation = query.mutation(createUser)
+const updateUserProfileMutation = query.mutation(updateProfile)
+const deleteUserAccountMutation = query.mutation(deleteAccount)
+
+// ❌ Bad
+const userMutation1 = query.mutation(doSomething)
+const mutation2 = query.mutation(doSomethingElse)
+```
+
+### 2. Handle Loading States
+
+Always show feedback during mutations:
+
+```vue
+<template>
+  <button 
+    :disabled="isLoading" 
+    @click="handleSave"
+    :class="{ loading: isLoading }"
+  >
+    {{ isLoading ? 'Saving...' : 'Save Changes' }}
+  </button>
+</template>
+
+<script setup lang="ts">
+const saveMutation = saveMutation()
+const isLoading = computed(() => saveMutation.pending)
+</script>
+```
+
+### 3. Invalidate Related Data
+
+Keep your cache fresh by invalidating related queries:
+
+```ts
+const updateUserMutation = query.mutation(updateUser, {
+  invalidateTags: [userTag, profileTag, settingsTag]
+})
+```
+
+### 4. Use Optimistic Updates Carefully
+
+Only use optimistic updates when you're confident about success:
+
+```ts
+// ✅ Good - Simple field update, likely to succeed
+const updateNameMutation = query.mutation(updateName, {
+  onMutate: optimisticallyUpdateName
+})
+
+// ❌ Risky - Complex operation, many failure points
+const complexMutation = query.mutation(complexOperation)
+// Better to just show loading state
+```
+
+## Next Steps
+
+Learn more about managing your cache:
+
+- [Tags & Invalidation](/core-concepts/tags-invalidation) - Organize and invalidate cached data
+- [Caching](/core-concepts/caching) - Understanding cache behavior
+- [useMutation Composable](/composables/useMutation) - Advanced mutation usage -->
\ No newline at end of file
diff --git a/docs/core-concepts/queries.md b/docs/core-concepts/queries.md
new file mode 100644
index 0000000..41b8e0c
--- /dev/null
+++ b/docs/core-concepts/queries.md
@@ -0,0 +1,183 @@
+# Queries
+
+Queries are the foundation of data fetching in Kitbag query. Queries are highly customizable and provide a simple but effective API for accessing the state of your data.
+
+```ts
+import { query } from '@kitbag/query'
+
+function searchCats(breed?: string) {
+  ...
+}
+
+const catsQuery = query(searchCats, ['Maine Coon'])
+```
+
+## Query Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `data` | `T \| undefined` | The resolved data from the query action. Will be `undefined` when the function hasn't yet completed. If the query is awaited, `data` will be `T`. |
+| `error` | `unknown` | Any error that occurred during execution. |
+| `errored` | `boolean` | Whether the query has encountered an error. |
+| `executed` | `boolean` | Whether the query has been executed at least once. |
+| `executing` | `boolean` | Whether the query is currently executing. |
+| `execute` | `() => Promise<T>` | Function to manually trigger the query. |
+| `dispose` | `() => void` | Function to clean up the query and its resources. |
+
+### Execute
+
+The query includes `execute`, which can be called at any point to force the function to be called again.
+
+```ts
+const catsQuery = query(searchCats, ['Ragdoll'])
+
+function refresh(): void {
+  catsQuery.execute()
+}
+```
+
+### Awaiting Queries
+
+When creating a query, you have the option of using `await` which changes the `data` attribute from being `T | undefined` to `T` since we can be sure that your function has executed.
+
+::: warning Error Handling
+Note that if awaiting a query, any errors that occur will be thrown. Consider placing your `await query(...)` inside a try catch block.
+:::
+
+```ts
+const regularQuery = query(searchCats, ['Persian'])
+//     ^? data: Cat[] | undefined
+const awaitedQuery = await query(searchCats, ['Persian'])
+//     ^? data: Cat[]
+```
+
+## Query Options
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `placeholder` | `TPlaceholder` | Default value to show while the query is loading. |
+| `onSuccess` | `(value: T) => void` | Callback function called when the query succeeds. Provides the value `T` returned from the function. |
+| `onError` | `(error: unknown) => void` | Callback function called when the query fails. Provides the error `unknown` thrown by the function. |
+| `interval` | `number` | Time in milliseconds between automatic re-fetches. |
+| `retries` | `number \| Partial<RetryOptions>` | Number of retry attempts or retry configuration. |
+| `tags` | `QueryTags` | Tags for cache invalidation and management. |
+
+### Placeholder
+
+By default a query that hasn't been executed (or hasn't finished executing) will use `undefined` for the `data`. However, this can be overridden with anything you wish.
+
+```ts
+const placeholder: Cat[] = []
+const catsQuery = await query(searchCats, ['Bengal'], { placeholder })
+//     ^? data: Cat[]
+```
+
+### Interval
+
+Automatically re-trigger the function on an interval. Value provided is time in milliseconds.
+
+```ts
+const catsQuery = await query(searchCats, ['Persian'], { interval: 30_000 })
+// automatically calls `searchCats` when query is created, and then again every 30 seconds
+```
+
+### Retries
+
+Automatically re-try the function when an error occurs. By default the query will wait `500` milliseconds between retries.
+
+```ts
+const catsQuery = query(searchCats, ['Siamese'], { retries: 3 })
+// will try to call `searchCats` a total of 3 times, waiting 500 MS between each attempt
+```
+
+Alternatively you can pass in `RetryOptions`, which allows you to specify both a `count` and a `delay`.
+
+```ts
+const retries = { count: 1, delay: 1_000 }
+const catsQuery = query(searchCats, ['Siamese'], { retries: 3 })
+// will retry after 1,000 MS once if initial call fails
+```
+
+### Tags
+
+Tags are used to organize queries and mutations that are related. Tags can be used to access cached values, update cache values, and trigger cache invalidation.
+
+## UseQuery method
+
+The `useQuery` function adds some super useful, vue specific functionality you'd expect from a [composition](https://vuejs.org/guide/extras/composition-api-faq.html).
+
+### Parameters argument is reactive
+
+When parameters for your query function change, the query is automatically updated. 
+
+```ts
+import { useQuery } from '@kitbag/query'
+
+const selectedBreed = ref<string | undefined>()
+
+const catsQuery = useQuery(searchCats, () => [selectedBreed.value])
+```
+
+### Delayed execution
+
+The query is suspended while parameters are `null`, this enables you to create your query even when waiting on required arguments.
+
+```ts
+const selectedBreed = ref<string | undefined>()
+
+const catsQuery = useQuery(searchCats, () => {
+  if (!selectedBreed.value) {
+    return null
+  }
+  
+  return [selectedBreed.value]
+})
+```
+
+You can also setup a query NOT to execute immediately. These queries can only be enabled by calling `execute()` manually.
+
+```ts
+const selectedBreed = ref<string | undefined>()
+
+const catsQuery = useQuery(searchCats, () => [selectedBreed.value], { immediate: false })
+
+// later
+catsQuery.execute()
+```
+
+### Automatic cleanup
+
+When your component is unmounted, any queries are automatically disposed.
+
+## DefineQuery method
+
+The `defineQuery` function adds the ability to pre-configure your queries into query factories. Defined queries abstract out the need to define which `action`, as well as optionally providing a default set of query options.
+
+::: code-group
+
+```ts [services/catApi.ts]
+import { defineQuery } from '@kitbag/query'
+
+export searchCats(breed?: string) { ... }
+
+const { query: catsQuery, useQuery: useCatsQuery } = defineQuery(searchCats)
+
+export { catsQuery, useCatsQuery }
+```
+
+```ts [components/CatFinder.vue]
+import { useCatsQuery } from '@/services/catApi'
+
+const selectedBreed = ref<string | undefined>()
+
+const catsQuery = useCatsQuery(() => [selectedBreed.value])
+```
+
+:::
+
+**Perfect for:**
+
+- **API layers** - Export both raw functions and pre-configured queries
+- **Shared query configuration** - Common settings across related queries  
+- **Component libraries** - Provide ready-to-use composables
+- **Team consistency** - Enforce caching and retry policies
diff --git a/docs/core-concepts/query-client.md b/docs/core-concepts/query-client.md
new file mode 100644
index 0000000..68db38b
--- /dev/null
+++ b/docs/core-concepts/query-client.md
@@ -0,0 +1,236 @@
+# Query Client
+
+<!-- The query client is the central hub of Kitbag query. It manages all your queries, handles caching, and provides the composables you'll use throughout your application.
+
+## Getting Started: Use the Default Client
+
+For most applications, you should start with the default, ready-to-use client:
+
+```ts
+import { query, useQuery } from '@kitbag/query'
+
+// Ready to use - comes pre-configured!
+const userQuery = query('user', fetchUser)
+const user = useQuery(userQuery, { params: [userId] })
+```
+
+> **Recommended Approach**: The default client provides shared caching, unified query management, and enables powerful features like tag-based invalidation across your entire application. This is sufficient for 95% of use cases.
+
+## When to Create Your Own Client
+
+Create a custom query client only when you need:
+
+- **Custom configuration** for your entire app
+- **Multiple isolated contexts** (e.g., different APIs with different caching strategies)  
+- **Mutations and advanced features** like `defineQuery`
+- **Tag-based invalidation** that should work across specific query groups
+
+```ts
+import { createQueryClient } from '@kitbag/query'
+
+// Custom client with configuration
+export const { query, useQuery, defineQuery, mutate } = createQueryClient({
+  defaultStaleTime: 5 * 60 * 1000, // 5 minutes
+  defaultCacheTime: 10 * 60 * 1000, // 10 minutes
+  defaultRetryCount: 3
+})
+```
+
+## Configuration Options
+
+The query client accepts several configuration options:
+
+### Caching Options
+
+- **defaultStaleTime**: How long data is considered fresh (default: 0)
+- **defaultCacheTime**: How long unused data stays in cache (default: 5 minutes)
+
+```ts
+const { query, useQuery } = createQueryClient({
+  defaultStaleTime: 2 * 60 * 1000,    // Data is fresh for 2 minutes
+  defaultCacheTime: 10 * 60 * 1000    // Keep in cache for 10 minutes
+})
+```
+
+### Retry Options
+
+- **defaultRetryCount**: Number of retry attempts on failure (default: 3)
+- **defaultRetryDelay**: Delay between retries (default: exponential backoff)
+
+```ts
+const { query, useQuery } = createQueryClient({
+  defaultRetryCount: 5,
+  defaultRetryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 30000)
+})
+```
+
+## What You Get
+
+The `createQueryClient()` function returns an object with two main properties:
+
+### query
+
+A function for creating query definitions. This is where you define your data fetching logic:
+
+```ts
+const userQuery = query('user', async (id: number) => {
+  const response = await fetch(`/api/users/${id}`)
+  return response.json()
+})
+```
+
+### useQuery
+
+A Vue composable for using queries in your components:
+
+```ts
+const user = useQuery(userQuery, {
+  params: [userId]
+})
+```
+
+## Multiple Query Clients
+
+You can create multiple query clients for different purposes:
+
+```ts
+// Main application data
+export const { query: appQuery, useQuery: useAppQuery } = createQueryClient({
+  defaultStaleTime: 5 * 60 * 1000
+})
+
+// Real-time data with shorter cache times
+export const { query: realtimeQuery, useQuery: useRealtimeQuery } = createQueryClient({
+  defaultStaleTime: 10 * 1000,
+  defaultCacheTime: 30 * 1000
+})
+```
+
+## Default vs Custom vs Multiple Clients
+
+### Default Client (Recommended for Most Apps)
+
+Start here - use the default client that comes pre-configured:
+
+```ts
+// queries/users.ts
+import { query, useQuery } from '@kitbag/query'
+
+export const userQuery = query('user', fetchUser)
+```
+
+```ts  
+// components/UserProfile.vue
+import { useQuery } from '@kitbag/query'
+import { userQuery } from '../queries/users'
+
+const user = useQuery(userQuery, { params: [userId] })
+```
+
+**Benefits:**
+- Zero configuration - works out of the box
+- Shared caching across your entire app
+- Tag-based invalidation works globally
+- Perfect for single-domain applications
+
+### Custom Global Client
+
+Create your own client when you need app-wide configuration or mutations:
+
+```ts
+// queryClient.ts
+import { createQueryClient } from '@kitbag/query'
+
+export const { query, useQuery, defineQuery, mutate } = createQueryClient({
+  defaultStaleTime: 5 * 60 * 1000
+})
+```
+
+**Use when you need:**
+- Custom default settings for your app
+- Mutations and advanced query patterns  
+- `defineQuery` for pre-configured API layers
+- Fine-tuned caching strategies
+
+### Multiple Clients (Advanced)
+
+Create separate clients for different contexts or APIs:
+
+```ts
+// Main app data
+export const { query: appQuery, useQuery: useAppQuery } = createQueryClient({
+  defaultStaleTime: 5 * 60 * 1000
+})
+
+// Real-time data with shorter cache times
+export const { query: realtimeQuery, useQuery: useRealtimeQuery } = createQueryClient({
+  defaultStaleTime: 10 * 1000,
+  defaultCacheTime: 30 * 1000
+})
+```
+
+**Use when you have:**
+- Multiple APIs with different caching needs
+- Isolated data contexts that shouldn't share cache
+- Different authentication or configuration requirements
+
+## Best Practices
+
+### 1. Start with the Default Client
+
+Begin with the default client for simplicity:
+
+```ts
+// ✅ Best - Use the default client for most apps
+import { query, useQuery } from '@kitbag/query'
+
+export const userQuery = query('user', fetchUser)
+```
+
+### 2. Create Custom Client When Needed
+
+Only create your own client when you need specific features:
+
+```ts
+// ✅ Good - Custom client when you need mutations or defineQuery  
+export const { query, useQuery, defineQuery, mutate } = createQueryClient({
+  defaultStaleTime: 5 * 60 * 1000
+})
+```
+
+### 3. Configure Sensible Defaults
+
+When you do create a custom client, set defaults that work for most of your queries:
+
+```ts
+// ✅ Good - Sensible defaults
+const { query, useQuery } = createQueryClient({
+  defaultStaleTime: 2 * 60 * 1000,    // 2 minutes is often good
+  defaultCacheTime: 10 * 60 * 1000,   // Keep cache for 10 minutes
+  defaultRetryCount: 3                 // Retry 3 times on failure
+})
+```
+
+### 4. Override Per Query When Needed
+
+Use query-specific options for special cases:
+
+```ts
+// Real-time data - shorter stale time
+const liveDataQuery = query('live-data', fetcher, {
+  staleTime: 5000 // 5 seconds
+})
+
+// Static data - longer stale time
+const configQuery = query('config', fetcher, {
+  staleTime: 60 * 60 * 1000 // 1 hour
+})
+```
+
+## Next Steps
+
+Now that you understand the query client, learn about:
+
+- [Queries](/core-concepts/queries) - Define your data fetching logic
+- [Mutations](/core-concepts/mutations) - Handle data modifications  
+- [Tags & Invalidation](/core-concepts/tags-invalidation) - Manage cache invalidation -->
\ No newline at end of file
diff --git a/docs/core-concepts/tags-invalidation.md b/docs/core-concepts/tags-invalidation.md
new file mode 100644
index 0000000..2522b9b
--- /dev/null
+++ b/docs/core-concepts/tags-invalidation.md
@@ -0,0 +1,402 @@
+# Tags & Invalidation
+
+<!-- Tags provide a powerful way to organize and invalidate cached queries in Kitbag query. They allow you to group related queries and efficiently update your cache when data changes.
+
+## Creating Tags
+
+Use the `tag` function to create query tags:
+
+```ts
+import { tag } from '@kitbag/query'
+
+// Create tags for different data types
+const userTag = tag('user')
+const postTag = tag('post')
+const commentTag = tag('comment')
+const profileTag = tag('profile')
+```
+
+Tags should represent logical groupings of your data:
+
+```ts
+// Domain-based tags
+const userTag = tag('user')
+const orderTag = tag('order')
+const productTag = tag('product')
+
+// Feature-based tags
+const dashboardTag = tag('dashboard')
+const settingsTag = tag('settings')
+const reportsTag = tag('reports')
+```
+
+## Tagging Queries
+
+Add tags to your queries to group them logically:
+
+```ts
+const userQuery = query('user', fetchUser, {
+  tags: [userTag, profileTag]
+})
+
+const userPostsQuery = query('user-posts', fetchUserPosts, {
+  tags: [userTag, postTag]
+})
+
+const postCommentsQuery = query('post-comments', fetchPostComments, {
+  tags: [postTag, commentTag]
+})
+```
+
+## Cache Invalidation
+
+Invalidate all queries with specific tags:
+
+```ts
+import { createQueryClient } from '@kitbag/query'
+
+const { queryClient } = createQueryClient()
+
+// Invalidate all user-related queries
+queryClient.invalidate(userTag)
+
+// Invalidate multiple tags at once
+queryClient.invalidate([userTag, profileTag])
+```
+
+### Automatic Invalidation in Mutations
+
+Set up automatic invalidation when mutations succeed:
+
+```ts
+const updateUserMutation = query.mutation(
+  async (userData: UpdateUserData) => {
+    const response = await fetch(`/api/users/${userData.id}`, {
+      method: 'PUT',
+      body: JSON.stringify(userData)
+    })
+    return response.json()
+  },
+  {
+    // Automatically invalidate these tags on success
+    invalidateTags: [userTag, profileTag]
+  }
+)
+```
+
+## Tag Strategies
+
+### Hierarchical Tags
+
+Organize tags in a hierarchy for fine-grained control:
+
+```ts
+// General to specific
+const dataTag = tag('data')
+const userDataTag = tag('user-data')
+const userProfileDataTag = tag('user-profile-data')
+
+const userProfileQuery = query('user-profile', fetchUserProfile, {
+  tags: [dataTag, userDataTag, userProfileDataTag]
+})
+
+// Invalidating dataTag invalidates everything
+// Invalidating userDataTag invalidates all user-related data
+// Invalidating userProfileDataTag invalidates only profile data
+```
+
+### Entity-Based Tags
+
+Tag queries by the entities they involve:
+
+```ts
+const userTag = tag('user')
+const postTag = tag('post')
+
+// Queries involving users
+const userQuery = query('user', fetchUser, { tags: [userTag] })
+const usersListQuery = query('users-list', fetchUsers, { tags: [userTag] })
+
+// Queries involving both users and posts
+const userPostsQuery = query('user-posts', fetchUserPosts, { 
+  tags: [userTag, postTag] 
+})
+
+// When a user is updated, all user-related queries are invalidated
+// When a post is created, all post-related queries are invalidated
+```
+
+### Feature-Based Tags
+
+Group queries by application features:
+
+```ts
+const dashboardTag = tag('dashboard')
+const analyticsTag = tag('analytics')
+const settingsTag = tag('settings')
+
+const dashboardDataQuery = query('dashboard-data', fetchDashboardData, {
+  tags: [dashboardTag]
+})
+
+const userAnalyticsQuery = query('user-analytics', fetchUserAnalytics, {
+  tags: [dashboardTag, analyticsTag]
+})
+
+// Refresh entire dashboard
+queryClient.invalidate(dashboardTag)
+```
+
+## Advanced Invalidation Patterns
+
+### Conditional Invalidation
+
+Invalidate queries based on conditions:
+
+```ts
+const updateUserMutation = query.mutation(
+  async (userData: UpdateUserData) => {
+    const response = await fetch(`/api/users/${userData.id}`, {
+      method: 'PUT',
+      body: JSON.stringify(userData)
+    })
+    return response.json()
+  },
+  {
+    onSuccess: (data, variables) => {
+      // Always invalidate user data
+      queryClient.invalidate(userTag)
+      
+      // Conditionally invalidate based on what changed
+      if (variables.profilePicture) {
+        queryClient.invalidate(profileTag)
+      }
+      
+      if (variables.email) {
+        queryClient.invalidate(authTag)
+      }
+    }
+  }
+)
+```
+
+### Partial Invalidation
+
+Invalidate specific query instances:
+
+```ts
+// Invalidate user query for specific ID
+queryClient.invalidate(userQuery, [userId])
+
+// Invalidate all queries with userTag but only for specific parameters
+queryClient.invalidate(userTag, (query) => {
+  return query.params?.[0] === specificUserId
+})
+```
+
+### Background Invalidation
+
+Invalidate without showing loading states:
+
+```ts
+// Silently refetch data in the background
+queryClient.invalidate(userTag, { refetchType: 'background' })
+
+// Only invalidate, don't refetch
+queryClient.invalidate(userTag, { refetchType: 'none' })
+```
+
+## Tag Organization Patterns
+
+### By Domain Model
+
+Organize tags around your domain models:
+
+```ts
+// E-commerce example
+const userTag = tag('user')
+const productTag = tag('product')
+const orderTag = tag('order')
+const cartTag = tag('cart')
+const wishlistTag = tag('wishlist')
+
+// CMS example
+const pageTag = tag('page')
+const postTag = tag('post')
+const categoryTag = tag('category')
+const authorTag = tag('author')
+const mediaTag = tag('media')
+```
+
+### By Data Relationships
+
+Tag queries based on data relationships:
+
+```ts
+const userTag = tag('user')
+const userRelationsTag = tag('user-relations')
+
+const userQuery = query('user', fetchUser, { 
+  tags: [userTag] 
+})
+
+const userFriendsQuery = query('user-friends', fetchUserFriends, { 
+  tags: [userTag, userRelationsTag] 
+})
+
+const userGroupsQuery = query('user-groups', fetchUserGroups, { 
+  tags: [userTag, userRelationsTag] 
+})
+
+// Update user profile - only invalidate direct user data
+userMutation.mutate(userData, {
+  invalidateTags: [userTag]
+})
+
+// Update friend relationship - invalidate user relations
+addFriendMutation.mutate(friendData, {
+  invalidateTags: [userRelationsTag]
+})
+```
+
+### By Access Patterns
+
+Group by how data is accessed:
+
+```ts
+const listTag = tag('list')       // List views
+const detailTag = tag('detail')   // Detail views
+const searchTag = tag('search')   // Search results
+
+const usersListQuery = query('users-list', fetchUsers, {
+  tags: [userTag, listTag]
+})
+
+const userDetailQuery = query('user-detail', fetchUserDetail, {
+  tags: [userTag, detailTag]
+})
+
+const userSearchQuery = query('user-search', searchUsers, {
+  tags: [userTag, searchTag]
+})
+```
+
+## Best Practices
+
+### 1. Use Descriptive Tag Names
+
+Make tag purposes clear:
+
+```ts
+// ✅ Good
+const userProfileTag = tag('user-profile')
+const dashboardMetricsTag = tag('dashboard-metrics')
+const orderHistoryTag = tag('order-history')
+
+// ❌ Bad
+const tag1 = tag('data1')
+const tag2 = tag('stuff')
+const tag3 = tag('things')
+```
+
+### 2. Don't Over-Tag
+
+Use tags strategically, not on every query:
+
+```ts
+// ✅ Good - Strategic tagging
+const userQuery = query('user', fetchUser, { tags: [userTag] })
+const staticConfigQuery = query('config', fetchConfig) // No tags needed
+
+// ❌ Bad - Over-tagging
+const timestampQuery = query('timestamp', () => Date.now(), { 
+  tags: [timeTag, utilityTag, helperTag] // Unnecessary
+})
+```
+
+### 3. Create a Tag System
+
+Establish consistent tag naming and organization:
+
+```ts
+// tags/index.ts
+export const tags = {
+  // Entities
+  user: tag('user'),
+  post: tag('post'),
+  comment: tag('comment'),
+  
+  // Features  
+  dashboard: tag('dashboard'),
+  settings: tag('settings'),
+  reports: tag('reports'),
+  
+  // Data types
+  list: tag('list'),
+  detail: tag('detail'),
+  search: tag('search')
+}
+```
+
+### 4. Document Tag Relationships
+
+Document how your tags relate to each other:
+
+```ts
+/**
+ * Tag Relationships:
+ * 
+ * userTag: All user-related queries
+ *   - userProfileTag: User profile data
+ *   - userSettingsTag: User settings
+ *   - userActivityTag: User activity/history
+ * 
+ * postTag: All post-related queries
+ *   - postListTag: Post lists/feeds
+ *   - postDetailTag: Individual post details
+ *   - postMetricsTag: Post analytics
+ */
+```
+
+## Performance Considerations
+
+### Tag Granularity
+
+Balance between too broad and too specific:
+
+```ts
+// Too broad - invalidates too much
+const dataTag = tag('data') // Everything uses this
+
+// Too specific - hard to manage
+const userPage1Tag = tag('user-page-1')
+const userPage2Tag = tag('user-page-2')
+// ... hundreds of specific tags
+
+// Just right - meaningful groupings
+const userTag = tag('user')
+const userListTag = tag('user-list')
+const userProfileTag = tag('user-profile')
+```
+
+### Invalidation Frequency
+
+Consider how often you need to invalidate:
+
+```ts
+// High-frequency updates - specific tags
+const liveDataTag = tag('live-data')
+const notificationsTag = tag('notifications')
+
+// Low-frequency updates - broader tags
+const configTag = tag('config')
+const staticContentTag = tag('static-content')
+```
+
+## Next Steps
+
+Learn more about cache management:
+
+- [Caching](/core-concepts/caching) - Understanding cache behavior
+- [useQuery Composable](/composables/useQuery) - Using tags with queries
+- [Advanced Concepts](/advanced-concepts/error-handling) - Advanced cache strategies -->
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000..9a2f3ef
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,37 @@
+---
+layout: home
+hero:
+  name: "Kitbag Query"
+  text: "Type safe query for Vue.js"
+  tagline: "Powerful, composable data fetching with full TypeScript support"
+  image:
+    src: /kitbag-logo.svg
+    alt: Kitbag Query
+  actions:
+    - theme: brand
+      text: Get Started
+      link: /introduction
+    - theme: alt
+      text: View on GitHub
+      link: https://github.com/kitbagjs/query
+
+features:
+  - icon: 🛡️
+    title: Type Safe
+    details: Full TypeScript support with automatic type inference for queries, mutations, and data.
+  - icon: 🎯
+    title: Composable
+    details: Built for Vue's Composition API with reactive composables that integrate seamlessly.
+  - icon: ⚡
+    title: Smart Caching
+    details: Intelligent caching with tag-based invalidation and automatic background updates.
+  - icon: 🔄
+    title: Mutations
+    details: Built-in support for data modifications with optimistic updates and error handling.
+  - icon: 📦
+    title: Lightweight
+    details: Minimal bundle size with tree-shaking support. Only pay for what you use.
+  - icon: 🎨
+    title: Developer Experience
+    details: Excellent DevTools integration and comprehensive error messages.
+---
\ No newline at end of file
diff --git a/docs/introduction.md b/docs/introduction.md
new file mode 100644
index 0000000..3bfe683
--- /dev/null
+++ b/docs/introduction.md
@@ -0,0 +1,35 @@
+# Introduction
+
+Kitbag query is a type-safe, composable query system designed specifically for Vue.js applications. It provides a powerful yet simple way to fetch, cache, synchronize, and update state with full TypeScript support.
+
+## What is Kitbag query?
+
+kitbag query is a data fetching library that helps you:
+
+- **Fetch data** with automatic loading and error states
+- **Cache responses** intelligently to minimize network requests
+- **Invalidate data** precisely using a tag-based system
+- **Handle mutations** with built-in optimistic updates
+- **Maintain type safety** throughout your entire data layer
+
+## Why Kitbag query?
+
+### Built for Vue 3
+
+Designed from the ground up for Vue's Composition API, providing reactive composables that feel natural in Vue applications.
+
+### Type Safety First
+
+Every query, mutation, and data transformation is fully typed, giving you confidence in your data layer and excellent IDE support.
+
+### Intelligent Caching
+
+Smart caching strategies with tag-based invalidation mean your app stays fast while keeping data fresh when it matters.
+
+### Composable Architecture
+
+Built on composable functions that can be easily combined and reused across your application.
+
+## Getting Started
+
+Ready to start using Kitbag query in your Vue application? Head over to our [Quick Start](/quick-start) guide to get up and running in minutes.
diff --git a/docs/public/favicon.ico b/docs/public/favicon.ico
new file mode 100644
index 0000000..1dcbf37
Binary files /dev/null and b/docs/public/favicon.ico differ
diff --git a/docs/public/kitbag-logo-circle.svg b/docs/public/kitbag-logo-circle.svg
new file mode 100644
index 0000000..803b04f
--- /dev/null
+++ b/docs/public/kitbag-logo-circle.svg
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="100%" height="100%" viewBox="0 0 599 594" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:1.5;">
+    <g id="background" transform="matrix(1,0,0,1,-173,-103)">
+        <circle cx="470.048" cy="414.292" r="268.492" style="fill:white;"/>
+    </g>
+    <g id="cat" transform="matrix(1.17103,0,0,1.17103,-251.644,-166.841)">
+        <g transform="matrix(0.85395,-0,-0,0.85395,214.891,142.474)">
+            <use xlink:href="#_Image1" x="2" y="1" width="596px" height="591px"/>
+        </g>
+    </g>
+    <defs>
+        <image id="_Image1" width="596px" height="591px" xlink:href="data:image/png;base64,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"/>
+    </defs>
+</svg>
diff --git a/docs/public/kitbag-logo.svg b/docs/public/kitbag-logo.svg
new file mode 100644
index 0000000..f56ef56
--- /dev/null
+++ b/docs/public/kitbag-logo.svg
@@ -0,0 +1,304 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="100%" height="100%" viewBox="0 0 770 968" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:1.5;">
+    <g id="Artboard1" transform="matrix(1,0,0,1,-141.499,-30.9749)">
+        <rect x="141.499" y="30.975" width="769.008" height="967.757" style="fill:none;"/>
+        <g id="pack" transform="matrix(1,0,0,1,169.523,69.3486)">
+            <g id="handle" transform="matrix(1.17103,0,0,1.17103,-196.408,-124.922)">
+                <path id="curve" d="M467.151,142.926C465.236,133.089 468.185,102.882 492.833,91.639C534.229,80.575 577.685,75.878 621.369,88.736C643.493,98.668 658.631,112.962 660.68,135.423L661.531,188.967L619.337,170.119L623.042,146.608C622.416,139.746 616.998,134.226 610.75,131.612C585.71,121.784 554.564,120.803 520.837,123.564C512.62,124.658 511.871,129.899 511.039,132.953L510.672,145.39L467.151,142.926Z" style="fill:rgb(59,122,157);"/>
+                <g transform="matrix(0.961118,0,0,1,20.5939,0)">
+                    <path d="M488.739,136.271C491.374,120.147 487.449,108.844 529.654,103.99" style="fill:none;stroke:rgb(34,65,97);stroke-width:40.92px;"/>
+                </g>
+                <g transform="matrix(1,0,0,1,-13.1017,6.22442)">
+                    <path d="M652.733,170.993C662.726,134.2 653.575,109.527 616.721,102.729" style="fill:none;stroke:rgb(34,65,97);stroke-width:36.72px;"/>
+                </g>
+                <path d="M483.376,110.095C483.334,110.21 483.206,110.268 483.092,110.226C482.977,110.183 482.919,110.056 482.961,109.941C483.962,105.722 488.219,101.543 494.93,97.576C497.253,96.203 499.838,94.909 502.721,93.688C505.241,92.62 507.947,91.63 510.849,90.765C516.921,88.955 523.747,87.634 530.959,86.568C540.635,85.136 551.062,84.354 561.535,84.232C570.144,84.132 578.798,84.444 587.092,85.405C592.945,86.083 598.621,87.037 603.966,88.366C611.476,90.233 618.302,92.723 624.171,95.743C631.409,99.468 637.065,103.967 640.627,109.266C640.703,109.362 640.688,109.501 640.593,109.578C640.498,109.654 640.358,109.639 640.282,109.544C636.815,105.936 632.092,103.163 626.436,100.877C619.638,98.128 611.541,96.383 602.645,95.104C597.425,94.353 591.963,93.757 586.337,93.338C578.302,92.739 569.965,92.459 561.657,92.606C551.53,92.785 541.464,93.557 532.079,94.742C525.149,95.618 518.618,96.803 512.671,98.021C509.867,98.596 507.202,99.119 504.683,99.707C501.832,100.374 499.215,101.014 496.811,101.779C489.99,103.947 485.214,106.564 483.376,110.095Z" style="fill:white;"/>
+                <path id="curve1" serif:id="curve" d="M467.151,142.926C465.236,133.089 468.185,102.882 492.833,91.639C534.229,80.575 577.685,75.878 621.369,88.736C643.493,98.668 658.631,112.962 660.68,135.423L661.531,188.967L619.337,170.119L623.042,146.608C622.416,139.746 616.998,134.226 610.75,131.612C585.71,121.784 554.564,120.803 520.837,123.564C512.62,124.658 511.871,129.899 511.039,132.953L510.672,145.39L467.151,142.926Z" style="fill:none;stroke:black;stroke-width:7.69px;stroke-linecap:butt;"/>
+            </g>
+            <g id="back" transform="matrix(1.17103,0,0,1.17103,-196.408,-124.922)">
+                <path d="M259.218,523.011L244.941,361.586L329.651,233.867L500.385,205.136L614.779,248.736L670.654,340.021L656.481,463.479L613.637,531.477L594.966,605.152L468.663,569.969L347.591,525.208L259.218,523.011Z" style="stroke:black;stroke-width:4.27px;stroke-linecap:butt;"/>
+                <path d="M206.409,548.74L265.205,531.105L257.389,447.224L262.364,357.694L293.185,305.985L352.266,255.307L428.353,221.6L503.227,221.6L563.242,248.178L608.303,289.871L637.873,343.046L643.353,408.537L628.563,464.053L603.428,493.206L583.108,540.017L578.426,573.939L538.144,560.973L460.805,532.736L385.185,519.807L302.981,518.79L287.142,530.01L375.719,552.758L457.058,584.807L501.225,620.755L523.941,668.266L540.522,728.584L547.179,775.152L551.05,816.557L544.164,848.624L525.031,870.506L517.907,883.041L585.486,888.063L666.71,881.992L709.365,865.393L747.178,825.349L766.393,765.499L762.577,690.423L756.515,375.283L743.627,292.148L691.909,213.481L610.236,175.128L528.138,152.279L420.152,151.381L338.191,173.506L281.374,208.822L241.573,271.1L221.83,325.65L209.836,403.433L202.862,485.751L206.409,548.74Z" style="fill:rgb(61,127,157);"/>
+                <g transform="matrix(1,0,0,1,1.7305,5.15928)">
+                    <path d="" style="fill:white;"/>
+                </g>
+                <path d="M639.117,688.84C701.038,658.556 737.635,603.394 760.529,541.904L766.182,757.261L742.271,836.867L693.677,869.393L636.976,886.039L573.802,887.749L621.536,857.244L642.608,806.307L639.117,688.84Z" style="fill:rgb(34,65,97);"/>
+                <path d="M694.941,343.413L684.617,355.259C679.455,360.301 664.962,377.476 668.298,386.751C671.37,404.274 657.883,421.523 656.139,439.045C654.262,452.937 646.792,458.281 642.135,469.811C636.967,482.609 616.362,509.525 608.097,519.691C580.526,547.208 587.009,599.369 609.511,596.05C625.041,593.759 588,615.031 587.236,626.836L581.109,694.207C585.448,762.969 587.759,815.694 572.916,826.746L542.344,844.088L511.09,882.343L528.1,885.527L604.825,871.535L635.477,833.881L646.436,775.816L640.63,721.351L636.932,624.242L652.144,541.883L685.049,499.237L693.32,473.899L706.355,422.284L701.344,364.671L694.941,343.413Z" style="fill:rgb(34,65,97);"/>
+                <path d="M205.217,546.131C201.518,497.658 202.019,448.849 207.02,400.487C209.252,378.903 212.601,354.25 218.343,333.257C223.081,315.934 232.36,294.905 239.925,278.7C246.472,264.676 255.883,245.563 265.244,233.098C284.332,207.682 307.077,187.626 335.046,174.161C360.65,161.834 394.711,154.227 423.264,151.464C462.197,147.698 497.699,148.375 534.692,155.021C589.754,164.914 650.798,177.237 693.156,217.126C768.14,287.739 758.637,405.034 762.776,497.909C763.872,522.487 763.797,570.304 763.878,594.938C764.002,632.339 767.078,669.736 766.313,707.13C765.275,757.824 764.644,819.926 720.637,854.514C709.27,863.448 696.224,869.697 682.641,874.399C669.687,878.884 652.921,882.46 639.336,884.148C597.873,889.297 555.903,888.113 514.276,886.573" style="fill:none;stroke:black;stroke-width:16.23px;stroke-linecap:butt;"/>
+                <path d="M468.628,886.146C498.839,889.336 510.923,888.731 541.11,885.857C555.836,884.455 569.85,881.851 583.958,877.34C593.561,874.27 602.481,869.731 610.507,863.622C633.868,845.837 645.694,815.89 645.479,787C645.282,760.587 643.014,760.853 641.567,734.452C640.164,708.848 638.577,683.232 638.378,657.591C638.063,617.065 650.805,553.834 671.694,524.335C695.505,490.712 708.16,429.329 706.256,410.823C704.561,394.358 703.452,347.562 694.356,317.08C687.555,294.291 676.619,271.702 659.452,254.863C642.43,238.166 622.074,225.79 600.963,215.021C537.7,182.751 441.154,166.355 371.517,187.22C328.223,200.193 279.254,224.013 250.878,256.941" style="fill:none;stroke:black;stroke-width:16.23px;stroke-linecap:butt;"/>
+                <path d="M565.177,573.59L581.367,572.523C581.367,572.523 583.939,601.645 585.937,631.594C586.566,641.007 587.174,650.5 587.487,659.199C587.637,663.373 587.851,667.355 587.675,671.061C587.547,673.762 587.218,676.189 586.845,678.537C586.549,680.4 586.199,681.949 585.806,683.553C585.318,685.544 584.878,687.023 584.373,688.595C582.676,693.877 581.643,696.196 581.643,696.196L581.124,696.23C581.124,696.23 579.796,694.067 577.42,689.053C576.714,687.561 576.084,686.152 575.338,684.242C574.738,682.704 574.188,681.214 573.651,679.406C572.973,677.127 572.328,674.765 571.847,672.103C571.187,668.453 570.877,664.477 570.478,660.319C569.648,651.654 569.006,642.164 568.394,632.749C566.448,602.797 565.177,573.59 565.177,573.59Z"/>
+                <g transform="matrix(1,0,0,1,-5.48787,1.86525)">
+                    <path d="M684.469,574.204L762.2,541.476C782.272,545.108 791.153,555.036 793.259,568.776L793.202,621.502C795.362,637.011 788.948,649.403 776.679,659.665L699.096,697.203C673.674,707.207 663.384,697.237 660.315,677.732L654.776,617.755C658.046,600.739 666.458,585.662 684.469,574.204Z" style="fill:rgb(34,65,97);"/>
+                </g>
+                <g transform="matrix(1,0,0,1,-0.412616,-3.31882)">
+                    <path d="M668.034,615.125C668.002,615.243 667.881,615.314 667.763,615.282C667.645,615.251 667.574,615.13 667.606,615.012C667.915,611.468 668.542,607.965 670.593,603.838C671.299,602.417 672.206,601.023 673.307,599.506C674.562,597.777 676.073,596.018 677.981,594.17C678.671,593.5 679.425,592.85 680.239,592.194C683.453,589.6 687.543,587.006 692.533,584.132C692.67,584.057 692.812,583.99 692.957,583.931C692.957,583.931 703.984,579.318 716.275,574.42C721.515,572.332 726.975,570.171 731.924,568.332C735.02,567.181 737.907,566.157 740.41,565.325C745.583,563.605 749.03,562.646 749.03,562.646C749.149,562.598 749.272,562.558 749.397,562.526C753.716,561.905 757.816,561.981 761.683,563.486C765.061,564.8 768.182,567.031 771.031,570.635C771.118,570.721 771.119,570.861 771.033,570.948C770.947,571.035 770.806,571.035 770.72,570.949C767.394,568.368 764.149,567.063 760.864,566.574C757.463,566.068 754.137,566.653 750.739,567.885L751.107,567.765C751.107,567.765 747.967,569.48 743.059,571.852C740.685,573 737.9,574.277 734.878,575.61C730.047,577.74 724.626,579.995 719.413,582.15C708.012,586.863 697.572,590.987 696.209,591.524C691.586,593.923 687.882,596.268 684.729,598.316C682.788,599.577 681.059,600.676 679.536,601.792C678.776,602.349 678.056,602.837 677.382,603.363C672.14,607.453 669.812,611.161 668.034,615.125Z" style="fill:white;"/>
+                </g>
+                <g transform="matrix(1,0,0,1,-5.48787,1.86525)">
+                    <path d="M684.469,574.204L762.2,541.476C782.272,545.108 791.153,555.036 793.259,568.776L793.202,621.502C795.362,637.011 788.948,649.403 776.679,659.665L699.096,697.203C673.674,707.207 663.384,697.237 660.315,677.732L654.776,617.755C658.046,600.739 666.458,585.662 684.469,574.204Z" style="fill:none;stroke:black;stroke-width:17.08px;"/>
+                </g>
+                <g transform="matrix(1,0,0,1,-9.88147,-97.2102)">
+                    <ellipse cx="710.712" cy="756.058" rx="9.179" ry="9.884"/>
+                </g>
+                <g transform="matrix(1,0,0,1,39.7109,-120.135)">
+                    <ellipse cx="710.712" cy="756.058" rx="9.179" ry="9.884"/>
+                </g>
+                <path d="M179.666,594.87C168.401,594.188 160.34,588.366 156.731,578.65C155.452,547.252 154.67,515.759 160.844,482.926C161.934,475.186 169.406,469.049 186.882,465.425L204.521,466.42L206.185,544.703C193.384,561.371 185.109,578.102 179.666,594.87Z" style="fill:rgb(34,65,97);"/>
+                <path d="M179.666,594.87C168.401,594.188 160.34,588.366 156.731,578.65C155.452,547.252 154.67,515.759 160.844,482.926C161.934,475.186 169.406,469.049 186.882,465.425L204.521,466.42L206.185,544.703C193.384,561.371 185.109,578.102 179.666,594.87Z" style="fill:none;"/>
+                <clipPath id="_clip1">
+                    <path d="M179.666,594.87C168.401,594.188 160.34,588.366 156.731,578.65C155.452,547.252 154.67,515.759 160.844,482.926C161.934,475.186 169.406,469.049 186.882,465.425L204.521,466.42L206.185,544.703C193.384,561.371 185.109,578.102 179.666,594.87Z"/>
+                </clipPath>
+                <g clip-path="url(#_clip1)">
+                    <path d="M199.396,479.233C199.514,479.266 199.583,479.388 199.55,479.506C199.518,479.623 199.396,479.693 199.278,479.66C197.129,479.85 195.526,480.269 193.646,480.723C192.723,480.946 191.978,481.247 191.108,481.482C190.278,481.706 189.551,482.011 188.761,482.219C186.901,482.708 185.202,483.284 183.658,484.082C181.27,485.317 179.322,487.033 177.915,489.157C176.732,490.943 175.943,492.979 175.51,495.199C175.221,496.675 175.009,498.184 174.973,499.8C174.918,502.262 174.922,504.715 175.539,507.468C175.942,509.266 176.334,510.962 177.061,512.859C177.132,512.958 177.11,513.096 177.011,513.168C176.912,513.239 176.773,513.217 176.702,513.118C174.603,511.375 172.993,509.69 171.569,507.737C169.901,505.449 168.857,503.117 168.163,500.683C167.537,498.484 167.46,496.276 167.61,494.154C167.856,490.648 169.103,487.404 170.891,484.595C173.064,481.182 176.192,478.353 180.103,476.636C182.426,475.617 185.009,474.765 187.814,474.797C189.1,474.812 190.338,474.958 191.656,475.323C192.814,475.644 193.846,475.959 194.991,476.522C196.576,477.301 197.838,478.085 199.396,479.233Z" style="fill:white;"/>
+                </g>
+                <path d="M179.666,594.87C168.401,594.188 160.34,588.366 156.731,578.65C155.452,547.252 154.67,515.759 160.844,482.926C161.934,475.186 169.406,469.049 186.882,465.425L204.521,466.42L206.185,544.703C193.384,561.371 185.109,578.102 179.666,594.87Z" style="fill:none;stroke:black;stroke-width:17.08px;"/>
+            </g>
+            <g id="front" transform="matrix(1.17103,0,0,1.17103,-196.408,-124.922)">
+                <path d="M187.532,762.974C151.394,674.338 168.551,555.226 226.673,541.445C300.132,524.028 345.459,538.732 403.44,556.112C452.211,570.73 481.023,591.386 500.858,622.858C538.157,682.039 553.479,776.381 545.805,833.959C533.474,926.477 352.712,870.425 282.196,858.142C230.771,849.184 203.507,802.155 187.532,762.974Z" style="fill:rgb(63,124,158);"/>
+                <path d="M514.964,709.436L513.37,709.324C512.875,707.117 512.104,705.084 511.114,702.665C510.47,701.093 509.704,699.751 508.976,698.116C507.398,694.568 505.684,691.206 504.042,687.704C503.239,685.991 502.486,684.361 501.809,682.733C501.063,680.939 500.455,679.216 499.835,677.661C496.327,667.301 492.785,656.61 488.019,646.578C485.039,640.304 481.572,634.292 477.199,628.859C473.007,623.643 468.066,619.199 462.754,615.214C454.289,608.863 444.852,603.705 435.589,598.838C420.313,590.777 404.311,584.177 387.917,578.72C371.415,573.227 354.512,568.893 337.505,565.514C330.612,564.135 323.706,562.799 316.781,561.586C312.207,560.786 307.625,560.036 303.029,559.377C281.45,556.241 257.303,554.18 236.478,560.457C227.227,563.246 218.714,567.754 211.361,574.637C208.421,577.389 205.567,580.415 203.019,583.969C201.862,585.454 200.77,586.975 199.792,588.59C198.774,590.272 197.783,591.945 196.933,593.71C193.33,600.687 191.098,605.881 189.211,611.348C187.253,617.022 185.632,622.554 183.755,630.451L182.161,630.335C181.416,621.975 180.962,616.01 181.274,609.811C181.589,603.539 182.824,597.496 184.808,589.205C185.438,586.865 186.216,584.589 187.102,582.325C188.013,579.997 189.145,577.79 190.351,575.609C193.214,570.884 196.411,566.7 199.945,563.042C208.847,553.825 219.711,547.922 231.419,544.175C254.486,536.793 281.431,538.517 305.495,541.757C311.472,542.573 317.431,543.525 323.373,544.571C329.261,545.607 335.132,546.737 340.996,547.889C358.749,551.395 376.404,555.868 393.619,561.619C410.946,567.406 427.825,574.485 443.948,583.058C454.007,588.431 464.239,594.153 473.4,601.161C479.839,606.086 485.759,611.633 490.8,618.061C495.944,624.629 500.078,631.833 503.499,639.406C508.348,650.139 511.806,661.579 515.251,672.655C515.934,675.795 516.923,679.409 517.374,683.364C517.796,687.069 517.955,690.746 517.741,694.547C517.421,700.238 516.559,705.09 514.964,709.436Z" style="fill:white;"/>
+                <path d="M461.176,699.724L460.06,700.867C455.63,698.306 451.498,696.2 447.111,693.621C442.895,691.143 438.879,688.801 434.765,686.205C431.592,684.202 428.501,682.165 425.389,680.082C420.83,677.03 416.348,673.866 411.565,671.115C407.675,668.878 403.655,666.818 399.476,664.97C391.651,661.472 383.643,658.388 375.694,655.57C367.339,652.607 359.046,649.945 351.073,647.458C292.66,628.982 250.157,630.253 224.819,645.619C201.913,659.509 194.951,685.336 203.646,716.331C205.142,721.717 208.984,743.54 216.085,765.276C219.495,775.717 223.628,786.166 228.754,794.528C231.474,798.997 234.708,803.352 238.122,807.62C243.367,814.175 249.055,820.501 254.607,826.252C257.452,828.498 260.309,830.577 263.167,832.585C268.171,836.101 273.067,839.285 278.117,842.148C287.235,847.317 296.187,851.499 305.689,854.601L305.395,856.172C295.017,855.603 284.818,854.089 274.36,851.024C268.333,849.257 262.424,846.946 256.447,844.107C252.648,842.302 248.953,840.17 245.186,837.918C244.841,837.679 244.516,837.41 244.216,837.116C238.967,832.28 233.5,827.095 228.44,821.529C223.224,815.793 218.48,809.649 214.502,803.404C208.601,794.078 203.669,782.437 199.696,770.735C192.231,748.743 188.159,726.603 186.593,721.146C175.215,681.116 185.856,648.153 215.468,630.198C243.749,613.049 291.273,609.883 356.396,630.733C366.144,633.896 376.363,637.31 386.582,641.229C393.255,643.788 399.926,646.56 406.474,649.598C418.133,655.152 429.013,661.712 438.459,670.081C440.717,672.083 442.812,674.198 444.817,676.463C447.839,679.875 450.538,683.292 453.167,687.043C456.118,691.255 458.476,695.312 461.176,699.724Z" style="fill:white;"/>
+                <path d="M187.532,762.974C151.394,674.338 168.551,555.226 226.673,541.445C300.132,524.028 345.459,538.732 403.44,556.112C452.211,570.73 481.023,591.386 500.858,622.858C538.157,682.039 553.479,776.381 545.805,833.959C533.474,926.477 352.712,870.425 282.196,858.142C230.771,849.184 203.507,802.155 187.532,762.974Z" style="fill:none;stroke:black;stroke-width:16.23px;stroke-linecap:butt;"/>
+                <path d="M408.406,632.089C426.48,638.709 439.19,647.061 447.968,657.035C449.705,659.009 451.305,661.02 452.67,663.156C454.783,666.462 456.519,669.796 457.938,673.311C459.364,676.842 460.572,680.261 461.416,683.92C462.677,689.381 463.237,694.53 463.779,700.096L462.263,700.601C459.453,695.989 456.546,691.94 453.415,687.524C450.539,683.465 447.531,679.732 444.101,675.933C442.835,674.53 441.495,673.22 440.164,671.811C437.297,668.775 434.189,665.797 430.581,662.976C423.38,657.345 414.335,652.343 402.48,648.408C402.399,648.38 402.318,648.35 402.238,648.32C375.802,638.394 348.734,630.799 320.954,625.7C294.121,620.774 266.605,618.165 238.213,618.664C227.191,621.882 219.069,625.263 213.004,629.505C210.454,631.289 208.376,633.25 206.397,635.294C205.467,636.253 204.425,636.961 203.487,637.931C201.756,639.72 200.107,641.148 198.429,643.233C196.636,645.462 195.053,647.103 193.272,649.741L191.703,649.439C190.882,645.549 190.496,642.722 190.483,639.201C190.474,636.622 190.998,634.497 191.555,632.12C192.043,630.043 192.852,628.242 193.821,626.372C194.769,624.541 196.095,622.945 197.491,621.366C204.796,613.101 216.649,607.324 234.412,601.708C235.154,601.485 235.922,601.363 236.695,601.344C266.712,600.486 295.859,602.741 324.213,607.943C353.051,613.234 381.046,621.566 408.406,632.089Z"/>
+                <g transform="matrix(1.24716,0,0,1.17275,-78.5132,-106.15)">
+                    <g transform="matrix(0.670169,0.127302,0.110829,0.700233,131.404,206.608)">
+                        <g transform="matrix(64,0,0,64,304.283,811.273)">
+                        </g>
+                        <text x="72.283px" y="811.273px" style="font-family:'Pixeland';font-size:64px;">kitbag.dev</text>
+                    </g>
+                    <g id="patches" transform="matrix(0.179026,0.0218618,0.0199576,0.17845,265.429,569.94)">
+                        <g id="print">
+                            <g transform="matrix(3.01136,-0.120095,0.140961,3.53456,-803.328,-1856.77)">
+                                <path d="M265.703,719.591C266.7,706.407 273.993,699.238 289.553,700.863L372.211,704.204C396.983,705.068 398.873,711.525 397.093,731.281L392.608,798.473C391.702,814.768 377.267,819.3 354.976,816.341L293.179,809.949C268.548,809.932 259.715,799.648 262.342,778.301L265.703,719.591Z" style="fill:white;stroke:black;stroke-width:5.39px;"/>
+                            </g>
+                            <g transform="matrix(0.784376,-0.451927,0.463544,0.804539,-316.082,204.098)">
+                                <ellipse cx="155.889" cy="767.362" rx="39.232" ry="54.945"/>
+                            </g>
+                            <g transform="matrix(0.96435,-0.0951063,0.0959399,0.972802,15.7368,-57.2396)">
+                                <ellipse cx="155.889" cy="767.362" rx="39.232" ry="54.945"/>
+                            </g>
+                            <g transform="matrix(1.00173,0.147124,-0.151827,1.03375,302.798,-139.161)">
+                                <ellipse cx="155.889" cy="767.362" rx="39.232" ry="54.945"/>
+                            </g>
+                            <g transform="matrix(0.839818,0.43581,-0.434275,0.836859,620.23,43.1074)">
+                                <ellipse cx="155.889" cy="767.362" rx="39.232" ry="54.945"/>
+                            </g>
+                            <path d="M183.61,836.808C179.704,846.2 174.851,860.266 173.607,870.449C172.92,876.075 172.607,881.846 173.443,887.451C174.255,892.898 175.92,898.311 178.49,903.181C181.042,908.019 184.571,912.4 188.574,916.129C192.746,920.017 197.565,923.311 202.719,925.754C212.705,930.489 224.781,932.597 235.419,928.788C242.735,926.169 249.534,922.148 256.981,919.931C272.232,915.393 286.094,914.772 301.862,915.578C312.571,916.125 325.524,918.824 335.78,921.829C344.343,924.338 353.648,929.974 363.105,928.405C372.15,926.904 379.764,923.897 387.896,919.776C393.617,916.877 398.233,913.753 402.048,908.469C408.984,898.859 408.524,886.171 407.831,875.028C407.243,865.551 405.202,855.864 401.622,847.051C397.507,836.919 387.078,831.482 379.734,824.247C368.028,812.714 358.364,801.178 349.532,787.296C344.841,779.922 341.39,771.805 336.695,764.433C327.469,749.944 311.255,738.994 293.659,739.033C273.781,739.078 255.135,750.066 243.352,765.68C236.179,775.185 234.876,782.177 227.359,791.469C212.551,809.774 200.357,820.375 183.61,836.808Z"/>
+                        </g>
+                        <g transform="matrix(1.43145,-0.0570871,0.0670055,1.68015,-589.678,-412.64)">
+                            <g id="ts">
+                                <path d="M268.79,723.687C269.788,710.503 284.389,700.321 299.949,701.946L372.211,704.204C396.983,705.068 398.873,711.525 397.093,731.281L387.032,788.001C386.125,804.295 377.72,819.449 355.429,816.49L291.772,815.558C267.141,815.541 257.159,811.418 259.786,790.072L268.79,723.687Z" style="fill:none;"/>
+                                <clipPath id="_clip2">
+                                    <path d="M268.79,723.687C269.788,710.503 284.389,700.321 299.949,701.946L372.211,704.204C396.983,705.068 398.873,711.525 397.093,731.281L387.032,788.001C386.125,804.295 377.72,819.449 355.429,816.49L291.772,815.558C267.141,815.541 257.159,811.418 259.786,790.072L268.79,723.687Z"/>
+                                </clipPath>
+                                <g clip-path="url(#_clip2)">
+                                    <g transform="matrix(0.105259,0.00315174,-0.0159794,0.0895453,274.769,704.083)">
+                                        <use xlink:href="#_Image3" x="0" y="0" width="1200px" height="1200px"/>
+                                    </g>
+                                </g>
+                                <path d="M268.79,723.687C269.788,710.503 284.389,700.321 299.949,701.946L372.211,704.204C396.983,705.068 398.873,711.525 397.093,731.281L387.032,788.001C386.125,804.295 377.72,819.449 355.429,816.49L291.772,815.558C267.141,815.541 257.159,811.418 259.786,790.072L268.79,723.687Z" style="fill:none;stroke:black;stroke-width:11.34px;"/>
+                            </g>
+                        </g>
+                        <g transform="matrix(1.43145,-0.0570871,0.0670055,1.68015,-435.733,-717.606)">
+                            <g id="vue">
+                                <path d="M268.79,723.687C269.788,710.503 284.389,700.321 299.949,701.946L372.211,704.204C396.983,705.068 398.873,711.525 397.093,731.281L387.032,788.001C386.125,804.295 377.72,819.449 355.429,816.49L291.772,815.558C267.141,815.541 257.159,811.418 259.786,790.072L268.79,723.687Z" style="fill:rgb(190,229,212);"/>
+                                <clipPath id="_clip4">
+                                    <path d="M268.79,723.687C269.788,710.503 284.389,700.321 299.949,701.946L372.211,704.204C396.983,705.068 398.873,711.525 397.093,731.281L387.032,788.001C386.125,804.295 377.72,819.449 355.429,816.49L291.772,815.558C267.141,815.541 257.159,811.418 259.786,790.072L268.79,723.687Z"/>
+                                </clipPath>
+                                <g clip-path="url(#_clip4)">
+                                    <g transform="matrix(0.0388634,0.000739814,-0.00604194,0.0338064,284.12,728.094)">
+                                        <use xlink:href="#_Image5" x="0" y="0" width="2400px" height="2072px"/>
+                                    </g>
+                                </g>
+                                <path d="M268.79,723.687C269.788,710.503 284.389,700.321 299.949,701.946L372.211,704.204C396.983,705.068 398.873,711.525 397.093,731.281L387.032,788.001C386.125,804.295 377.72,819.449 355.429,816.49L291.772,815.558C267.141,815.541 257.159,811.418 259.786,790.072L268.79,723.687Z" style="fill:none;stroke:black;stroke-width:11.34px;"/>
+                            </g>
+                        </g>
+                        <g id="vite" transform="matrix(1,2.77556e-17,-1.11022e-16,1,52.5378,39.2042)">
+                            <g transform="matrix(1.43145,-0.0570871,0.0670055,1.68015,-22.4937,-682.517)">
+                                <path d="M268.79,723.687C269.788,710.503 284.389,700.321 299.949,701.946L372.211,704.204C396.983,705.068 398.873,711.525 397.093,731.281L387.032,788.001C386.125,804.295 377.72,819.449 355.429,816.49L291.772,815.558C267.141,815.541 257.159,811.418 259.786,790.072L268.79,723.687Z" style="fill:url(#_Radial6);stroke:black;stroke-width:11.34px;"/>
+                            </g>
+                            <g transform="matrix(0.422153,-0.00275446,-0.047832,0.429068,439.038,512.994)">
+                                <use xlink:href="#_Image7" x="0" y="0" width="300px" height="300px"/>
+                            </g>
+                        </g>
+                    </g>
+                </g>
+            </g>
+        </g>
+        <g transform="matrix(1,0,0,1,141.499,30.9749)">
+            <path d="M157.402,450.729L120.264,468.1C112.545,451.841 108.835,406.371 116.688,363.852C120.233,344.655 123.849,324.727 133.999,311.275C134.995,309.955 135.922,308.9 137.233,307.954C140.989,305.246 143.13,303.673 147.128,301.905L169.871,318.05C169.58,321.492 170.939,323.57 170.586,327.227C170.481,328.306 170.496,329.301 170.156,330.356C169.697,331.78 168.952,333.118 168.349,334.536C160.338,353.362 156.074,377.543 154.543,399.674C153.003,421.934 153.4,442.004 157.402,450.729Z"/>
+        </g>
+        <g transform="matrix(1,0,0,1,141.499,30.9749)">
+            <path d="M147.243,458.185L130.422,460.644C126.371,434.514 122.358,410.451 127.185,373.132C128.3,364.509 129.88,355.17 132.231,344.987C133.113,341.166 133.9,337.169 135.281,333.186C135.668,332.071 136.087,331.004 136.662,329.945C137.28,328.806 137.884,327.916 138.695,326.872C140.037,325.149 140.972,324.053 142.609,322.513C144.537,320.7 145.495,320.181 147.628,318.491C148.738,321.256 149.412,322.292 150.303,325.04C150.98,327.127 151.354,328.511 151.696,330.617C151.897,331.858 151.996,332.923 151.993,334.157C151.991,335.329 151.862,336.451 151.709,337.59C151.35,340.281 150.789,342.867 150.321,345.411C148.591,354.823 147.154,363.409 146.048,371.367C140.817,409.015 143.697,432.49 147.243,458.185Z" style="fill:rgb(249,233,232);"/>
+        </g>
+        <g id="cat" transform="matrix(1.17103,0,0,1.17103,-78.1451,-60.866)">
+            <clipPath id="_clip8">
+                <path d="M257.86,542.12C290.73,568.751 330.378,573.002 370.365,571.565C402.262,567.187 411.381,543.415 395.335,517.246L438.066,521.2C421.65,539.888 420.052,559.961 435.93,581.668C454.845,607.021 477.977,621.38 505.711,623.743C530.218,627.065 547.502,616.867 559.683,596.854L620.77,577.05C619.034,563.682 620.628,547.571 633.719,521.981C651.767,500.381 665.972,478.281 677.272,455.804C690.525,425.61 694.579,392.038 690.984,355.657L743.34,259.15L682.829,142.375L482.878,148.536L281.245,143.309L274.86,354.801L250.195,534.04L257.86,542.12Z"/>
+            </clipPath>
+            <g clip-path="url(#_clip8)">
+                <g id="tail" transform="matrix(1,0,0,1,-55.9753,-202.933)">
+                    <path d="M465.293,678.694C479.852,693.113 495.522,707.136 514.087,716.25C533.785,725.919 555.658,730.479 577.416,732.284C593.018,733.578 609.439,732.239 623.657,725.203C638.072,718.07 649.395,705.73 657.742,692.182C661.548,686.006 664.478,679.267 666.817,672.4C675.634,646.516 671.558,618.707 666.384,592.6C664.359,582.386 659.753,565.099 658.863,554.659C657.799,542.174 659.284,530.872 662.141,518.744C665.579,504.155 669.749,488.982 678.951,476.79C697.748,451.888 738.893,433.508 765.449,457.845C773.592,465.308 775.437,479.036 768.699,486.901C765.653,490.458 759.354,493.699 755.464,496.307C753.569,497.577 750.943,497.083 748.799,497.864C737.38,502.028 726.336,510.515 723.24,522.851C721.931,528.069 720.893,533.424 720.793,538.802C720.163,572.658 733.213,604.772 733.73,638.523C733.855,646.669 730.795,665.293 728.743,673.125C722.744,696.027 715.993,719.189 703.774,739.688C682.017,776.184 641.336,800.309 598.997,802.615C578.663,803.723 558.457,799.02 538.927,794.088C515.453,788.159 492.265,777.419 476.087,758.838C465.819,747.046 457.564,735.488 448.193,723.058C438.084,709.65 436.493,708.355 427.64,693.95C423.95,687.945 421.621,677.486 426.969,671.598C431.31,666.818 440.156,668.406 445.283,670.321C452.056,672.851 458.795,675.522 465.293,678.694Z" style="fill:rgb(239,31,68);"/>
+                    <path d="M507.864,722.703L512.445,737.009L546.026,760.418L613.683,758.601L655.036,737.087L690.009,684.211L701.686,600.222L697.353,576.64L695.084,518.781L713.234,488.21L738.389,472.865L761.681,471.976L770.935,471.976L756.577,454.312L725.237,450.322L698.214,458.648L677.653,480.609L667.005,511.03L661.212,553.888L665.818,582.035L669.27,624.153L667.804,659.131L661.397,690.027L639.042,708.972L595.782,730.583L557.008,731.11L518.273,717.24L507.864,722.703Z" style="fill:white;"/>
+                    <path d="M496.054,730.056L476.434,722.652C491.285,742.923 512.461,759.762 544.152,770.892C577.87,777.509 608.573,775.421 634.935,760.807C654.987,753.424 673.799,737.428 691.141,711.226C700.625,695.63 707.122,673.477 710.692,644.9C711.901,632.221 709.742,611.7 702.301,578.881C694.965,552.414 697.167,536.531 700.096,524.42C701.824,511.728 708.558,498.563 722.087,484.754C732.366,477.59 741.694,473.862 749.934,474.069C753.048,470.279 734.838,484.238 739.903,493.025L769.214,484.629L768.208,465.968L751.466,463.565C743.712,463.143 735.529,464.404 726.745,468.017L715.199,474.832L708.091,481.326C701.102,489.291 696.097,497.457 692.306,505.745C688.074,518.61 684.156,531.703 686.856,549.631C686.969,560.743 689.403,576.679 694.114,600.393C689.794,592.033 685.607,575.606 681.515,553.328C681.451,569.135 684.019,590.988 690.627,622.125C691.947,644.912 690.873,666.577 683.806,685.428C676.827,696.479 671.389,707.759 661.619,717.584C651.731,728.144 639.669,737.59 624.03,745.202C610.955,752.415 589.769,752.789 562.873,754.044C538.978,747.564 520.171,739.533 509.168,725.636L471.038,707.012L496.054,730.056Z" style="fill:rgb(255,172,0);"/>
+                    <path d="M465.293,678.694C479.852,693.113 495.522,707.136 514.087,716.25C533.785,725.919 555.658,730.479 577.416,732.284C593.018,733.578 609.439,732.239 623.657,725.203C638.072,718.07 649.395,705.73 657.742,692.182C661.548,686.006 664.478,679.267 666.817,672.4C675.634,646.516 671.558,618.707 666.384,592.6C664.359,582.386 659.753,565.099 658.863,554.659C657.799,542.174 659.284,530.872 662.141,518.744C665.579,504.155 669.749,488.982 678.951,476.79C697.748,451.888 738.893,433.508 765.449,457.845C773.592,465.308 775.387,480.595 768.65,488.46C765.603,492.016 759.354,493.699 755.464,496.307C753.569,497.577 750.943,497.083 748.799,497.864C737.38,502.028 726.336,510.515 723.24,522.851C721.931,528.069 720.893,533.424 720.793,538.802C720.733,542.011 720.796,545.205 720.96,548.385C722.524,578.761 733.262,607.971 733.73,638.523C733.855,646.669 730.795,665.293 728.743,673.125C722.744,696.027 715.993,719.189 703.774,739.688C682.017,776.184 641.336,800.309 598.997,802.615C578.663,803.723 558.457,799.02 538.927,794.088C515.453,788.159 492.265,777.419 476.087,758.838C465.819,747.046 457.564,735.488 448.193,723.058C438.084,709.65 436.493,708.355 427.64,693.95C423.95,687.945 421.621,677.486 426.969,671.598C431.31,666.818 440.156,668.406 445.283,670.321C452.056,672.851 458.795,675.522 465.293,678.694Z" style="fill:none;stroke:black;stroke-width:16.23px;stroke-linecap:butt;"/>
+                </g>
+                <g id="body">
+                    <path d="M372.34,447.231C356.853,468.924 345.236,505.462 337.118,555.416C368.283,626.356 405.28,672.809 452.49,676.366L601.082,670.554C638.253,574.492 604.771,505.586 567.357,431.335C505.008,484.032 448.054,488.455 372.34,447.231Z" style="fill:rgb(254,168,68);"/>
+                    <path d="M374.566,459.365C372.656,499.697 377.8,530.498 390.498,551.094C402.174,573.81 415.956,587.208 430.826,595.788C455.738,606.036 473.358,605.495 486.99,599.053C507.262,583.096 508.785,567.729 508.875,552.406C506.703,534.487 506.259,516.769 508.592,499.279C510.949,484.019 518.784,475.066 528.626,468.425L466.984,480.811L432.048,477.113L380.545,453.315L374.566,459.365Z" style="fill:white;"/>
+                    <path d="M518.341,469.07C530.628,470.444 545.067,468.349 562.441,461.521C554.621,478.729 535.732,492.546 519.074,497.694C535.64,499.365 551.143,501.288 559.577,504.895C547.978,522.525 532.945,534.224 516.031,542.673C544.34,549.628 565.642,556.47 574.907,563.118C581.01,567.444 582.235,572.007 575.615,576.954C565.081,589.476 549.986,595.094 535.04,600.938C558.636,608.225 574.806,615.645 579.99,623.261C582.595,627.396 574.761,628.948 561.644,629.194C579.221,637.339 586.905,647.396 582.465,659.796L586.418,665.384L606.262,659.521L614.681,615.699L610.686,538.254L579.742,459.708L566.65,435.385L518.341,469.07Z" style="fill:rgb(239,31,68);"/>
+                    <g transform="matrix(1,0,0,1,15.6695,45.9495)">
+                        <path d="M585.252,477.908C570.093,478.083 551.878,484.534 532.135,494.124C557.364,499.71 578.148,502.389 592.593,500.924L585.252,477.908Z"/>
+                    </g>
+                    <g transform="matrix(1,0,0,1,25.4952,117.228)">
+                        <path d="M585.096,475.867C571.767,472.565 552.484,475.994 532.138,480.626C555.571,489.666 576.919,497.261 592.593,500.924L585.096,475.867Z"/>
+                    </g>
+                    <path d="M585.871,480.271C574.739,479.954 554.973,485.922 532.135,494.124C553.439,499.448 573.774,502.198 592.593,500.924L585.871,480.271Z"/>
+                    <path d="M372.34,447.231C356.853,468.924 345.236,505.462 337.118,555.416C368.283,626.356 405.28,672.809 452.49,676.366L601.082,670.554C638.253,574.492 604.771,505.586 567.357,431.335C505.008,484.032 448.054,488.455 372.34,447.231Z" style="fill:none;stroke:black;stroke-width:16.23px;stroke-linecap:butt;"/>
+                </g>
+                <g id="head">
+                    <path d="M332.085,355.81L359.326,332.878L398.465,324.489L420.353,270.119L425.286,214.557L442.663,204.955L476.354,205.511L474.74,232.95L466.117,270.166L476.682,307.335L489.704,330.064L520.039,331.006L545.058,348.835L565.045,373.793L570.22,404.649L554.744,435.741L483.115,456.196L439.942,460.304L377.382,442.337L344.501,398.903L332.085,355.81Z" style="fill:white;"/>
+                    <path d="M333.641,385.769C331.34,374.077 331.252,364.486 335.207,358.733C347.901,341.084 366.145,335.192 387.899,336.739C405.904,330.518 420.247,307.391 424.498,287.078C428.521,240.766 432.389,227.296 446.148,214.014L467.715,213.579C452.728,226.893 446.251,248.196 451.118,275.324C452.182,286.522 456.007,296.913 460.817,308.845C469.382,325.008 478.156,331.548 486.956,336.889C512.935,334.395 537.813,341.17 559.289,376.58C562.706,367.177 565.088,357.419 566.527,347.336L602.821,371.954L606.372,315.853L642.698,271.39L643.316,186.479L641.554,167.309L590.626,176.411L527.051,211.329L501.748,211.782L455.692,205.35L404.597,219.715L366.074,241.805L346.774,270.706L332.336,303.518L324.707,345.286L326.362,378.382L333.641,385.769Z" style="fill:rgb(254,168,68);"/>
+                    <path d="M420.203,218.462C414.65,236.455 414.234,254.504 421.878,269.662C430.162,235.529 439.185,218.238 448.689,211.851L420.203,218.462Z" style="fill:rgb(239,31,68);"/>
+                    <g transform="matrix(1,0,0,1,41.5742,-4.56329)">
+                        <path d="M424.134,218.13C418.581,236.123 414.234,254.504 421.878,269.662C430.162,235.529 441.966,227.452 451.469,221.065L424.134,218.13Z" style="fill:rgb(239,31,68);"/>
+                    </g>
+                    <path d="M338.029,356.812C343.817,389.04 366.575,413.801 396.863,435.247C427.63,455.41 448.672,458.194 463.963,450.699L456.099,449.516C476.495,444.943 491.655,429.233 506.219,413.476C504.506,424.176 502.149,432.811 499.104,439.24C529.982,429.918 542.694,412.523 554.184,394.586L549.959,412.355C557.205,406.579 561.072,398.479 559.009,377.209L565.212,344.816L581.662,352.421L587.629,392.726L582.459,409.905L517.775,464.718L503.602,465.593C465.984,478.168 434.323,472.843 403.109,466.177L342.796,418.519L324.509,380.146L329.059,356.199L338.029,356.812Z" style="fill:rgb(215,215,215);"/>
+                    <g id="mouth">
+                        <path d="M425.738,348.789C423.468,361.432 413,376.357 398.145,373.666C392.994,372.732 387.287,368.115 384.26,363.961C383.174,362.47 383.021,360.399 381.836,358.984C378.995,355.591 374.077,356.839 373.915,361.806C373.57,372.372 390.376,385.371 394.532,390.698C403.219,401.831 400.484,405.324 408.961,418.621C417.905,432.65 439.334,440.762 454.805,431.837C469.279,423.488 476.288,408.087 485.572,395.194C489.161,390.21 493.297,385.643 497.092,380.814C501.893,374.704 506.735,370.236 505.901,361.444C505.715,359.48 503.837,357.452 501.899,357.085C499.253,356.584 493.416,366.202 493.407,366.211C487.951,371.896 478.581,375.95 470.736,376.28C457.716,376.828 440.592,370.459 434.456,357.85C432.99,354.838 434.694,350.433 432.371,348.019C430.828,346.415 427.755,347.848 425.738,348.789Z"/>
+                        <g id="tongue">
+                            <g transform="matrix(1.08689,0,0,1.06794,-37.4338,-27.944)">
+                                <path d="M437.904,384.997C449.489,384.61 459.226,393.282 459.459,403.855C459.704,414.926 449.73,424.696 437.904,425.127C422.213,425.697 415.252,414.538 416.682,403.152C417.013,400.524 417.709,398.059 418.797,395.842C421.866,389.592 428.048,385.325 437.904,384.997Z" style="fill:rgb(255,75,98);"/>
+                            </g>
+                            <path d="M417.05,396.345C426.769,394.46 432.143,399.56 434.431,411.335C434.721,401.659 439.419,396.996 448.066,396.822C455.435,399.815 458.79,407.209 454.644,419.431C457.705,417.207 460.001,413.052 462.186,406.518C463.513,400.26 461.723,394.581 455.872,389.658C450.71,384.736 444.574,383.371 438.771,382.822C433.474,382.693 428.456,384.436 423.615,387.379C420.156,390.111 418.236,393.612 417.05,396.345Z" style="fill:rgb(190,27,65);"/>
+                            <path d="M418.459,395.949C418.732,395.046 419.686,394.536 420.588,394.809C421.49,395.082 422.001,396.036 421.728,396.938C420.842,399.868 420.221,402.834 420.23,405.757C420.239,408.566 420.841,411.333 422.363,413.974C424.904,418.409 429.975,420.6 435.245,421.009C436.818,421.132 438.41,421.084 439.975,420.913C441.032,420.797 442.076,420.632 443.096,420.402C444.413,420.107 445.684,419.74 446.884,419.238C448.146,418.711 449.329,418.11 450.382,417.33C450.743,417.006 451.299,417.035 451.623,417.396C451.947,417.757 451.917,418.313 451.557,418.637C450.548,419.731 449.377,420.685 448.062,421.511C446.801,422.303 445.418,422.942 443.956,423.443C442.82,423.832 441.635,424.113 440.428,424.304C438.638,424.587 436.799,424.639 434.988,424.513C428.536,424.065 422.439,421.134 419.339,415.703C417.888,413.148 417.139,410.502 416.895,407.813C416.539,403.903 417.26,399.894 418.459,395.949Z" style="fill:white;"/>
+                        </g>
+                        <path d="M391.97,364.318C391.943,364.301 391.935,364.265 391.953,364.238C391.97,364.211 392.006,364.203 392.033,364.221C392.845,364.466 393.559,364.609 394.332,364.808C395.101,365.005 395.808,365.156 396.534,365.335C396.835,365.409 397.127,365.489 397.419,365.572C398.11,365.768 398.782,365.952 399.452,366.082C401.763,366.532 403.988,366.416 406.152,365.65C408.65,364.766 411.041,363.039 413.379,360.435C414.647,359.023 415.863,357.341 417.142,355.446C417.869,354.369 418.63,353.247 419.395,352.028C419.872,351.27 420.364,350.504 420.85,349.685C421.004,349.356 421.397,349.214 421.726,349.368C422.056,349.522 422.198,349.914 422.044,350.244C421.632,351.399 421.224,352.49 420.776,353.534C420.289,354.67 419.784,355.734 419.234,356.727C418.048,358.868 416.727,360.669 415.406,362.212C412.775,365.286 409.972,367.27 407.082,368.286C404.436,369.215 401.692,369.359 398.891,368.708C398.119,368.528 397.335,368.306 396.567,367.978C396.252,367.844 395.943,367.695 395.637,367.522C395.422,367.4 395.215,367.278 395.008,367.135C394.537,366.808 394.101,366.478 393.657,366.075C393.05,365.525 392.545,364.972 391.97,364.318Z" style="fill:rgb(158,158,158);"/>
+                        <path d="M437.784,351.705C437.766,351.678 437.773,351.642 437.799,351.624C437.826,351.606 437.862,351.613 437.88,351.64C438.721,352.511 439.548,353.292 440.382,354.111C440.945,354.662 441.483,355.195 442.033,355.731C442.496,356.183 442.956,356.613 443.407,357.058C443.861,357.508 444.303,357.955 444.742,358.4C446.893,360.581 449.053,362.523 451.347,364.087C455.016,366.588 458.94,368.189 463.214,368.681C468.617,369.304 474.506,368.085 481.161,364.966C483.309,363.959 485.545,362.79 487.874,361.403C489.283,360.564 490.733,359.679 492.211,358.69C492.501,358.471 492.915,358.528 493.134,358.818C493.354,359.108 493.297,359.522 493.007,359.741C491.626,360.918 490.282,362.012 488.934,363.002C486.67,364.665 484.455,366.071 482.278,367.214C475.237,370.91 468.754,372.078 462.905,371.442C458.173,370.928 453.802,369.177 449.776,366.364C447.346,364.667 445.008,362.608 442.856,360.145C442.511,359.751 442.171,359.346 441.851,358.919C441.379,358.291 440.943,357.638 440.514,356.954C440.096,356.287 439.698,355.619 439.319,354.907C438.763,353.866 438.286,352.82 437.784,351.705Z" style="fill:rgb(158,158,158);"/>
+                    </g>
+                    <g id="nose">
+                        <path d="M411.938,335.053C420.32,343.906 425.614,352.584 430.108,360.894C431.318,351.465 437.492,338.294 449.644,333.385C448.375,330.905 440.224,330.163 429.573,330.053C415.517,330.273 410.649,332.118 411.938,335.053Z" style="fill:rgb(24,0,0);"/>
+                        <path d="M411.785,335.069C407.02,332.984 409.309,328.117 412.523,325.693C419.294,320.585 429.929,320.675 437.648,322.524C442.623,323.716 448.504,324.879 449.975,330.522C450.158,331.224 450.195,331.999 450,332.698C448.79,337.039 446.536,333.353 442.642,332.862C441.015,332.657 439.341,332.916 437.738,333.262C433.488,334.182 434.41,338.796 432.165,341.362C431.41,342.226 429.969,342.099 428.825,342.196C427.712,342.289 426.319,342.669 425.485,341.925C423.849,340.466 423.505,337.983 422.16,336.252C419.147,332.375 415.481,331.55 411.785,335.069Z" style="fill:rgb(255,62,84);"/>
+                        <path d="M416.144,328.604C415.867,328.707 415.557,328.566 415.454,328.288C415.35,328.01 415.492,327.701 415.769,327.597C416.512,327.174 417.222,326.764 417.995,326.416C418.507,326.184 419.028,325.99 419.562,325.82C422.684,324.829 425.941,324.437 429.242,324.43C431.173,324.426 433.131,324.588 435.111,324.947C435.929,325.095 436.753,325.265 437.572,325.501C438.281,325.705 438.984,325.947 439.688,326.23C440.705,326.639 441.693,327.125 442.708,327.659C442.984,327.768 443.119,328.08 443.01,328.355C442.902,328.631 442.59,328.767 442.314,328.658C441.604,328.47 440.91,328.326 440.216,328.167C439.152,327.924 438.115,327.727 437.086,327.534C436.297,327.386 435.522,327.232 434.749,327.114C432.886,326.829 431.055,326.691 429.246,326.694C426.139,326.698 423.128,327.216 420.118,327.885C419.597,328.001 419.078,328.104 418.551,328.2C417.744,328.348 416.957,328.443 416.144,328.604Z" style="fill:white;"/>
+                    </g>
+                    <g id="right-eye" serif:id="right eye" transform="matrix(1,0,0,1,109.51,0.444925)">
+                        <path id="left-eye" serif:id="left eye" d="M385.727,278.749C400.003,277.849 418.505,290.543 418.072,307.356C417.655,323.546 405.6,335.273 391.406,335.114C376.607,334.948 359.953,323.804 360.012,308.126C360.075,291.51 371.167,279.667 385.727,278.749Z"/>
+                        <g transform="matrix(1,0,0,1.04451,-2.6915,-13.2503)">
+                            <path d="M388.585,287.577C393.534,287.577 396.759,291.799 396.759,296.749C396.759,301.699 393.544,304.176 388.594,304.176C383.644,304.176 379.233,301.455 379.233,296.505C379.233,291.556 383.635,287.577 388.585,287.577Z" style="fill:white;"/>
+                        </g>
+                        <g transform="matrix(1,0,0,1,-0.284033,-0.138872)">
+                            <path d="M379.923,313.795C383.036,313.795 385.649,316.645 385.649,319.758C385.649,322.871 383.148,324.736 380.035,324.736C376.922,324.736 374.578,322.848 374.578,319.735C374.578,316.622 376.81,313.795 379.923,313.795Z" style="fill:white;"/>
+                        </g>
+                    </g>
+                    <g id="left-eye1" serif:id="left eye">
+                        <path id="left-eye2" serif:id="left eye" d="M385.408,279.182C395.222,279.182 405.159,284.485 408.935,294.3C414.653,309.16 401.259,332.146 383.505,333.979C366.561,335.727 356.502,315.326 359.335,300.334C361.696,287.841 372.808,279.182 385.408,279.182Z"/>
+                        <g transform="matrix(1,0,0,1.04451,0,-13.5988)">
+                            <path d="M388.585,287.577C393.534,287.577 396.759,291.799 396.759,296.749C396.759,301.699 393.544,304.176 388.594,304.176C383.644,304.176 379.233,301.455 379.233,296.505C379.233,291.556 383.635,287.577 388.585,287.577Z" style="fill:white;"/>
+                        </g>
+                        <path d="M379.923,313.795C383.036,313.795 385.649,316.645 385.649,319.758C385.649,322.871 383.148,324.736 380.035,324.736C376.922,324.736 374.578,322.848 374.578,319.735C374.578,316.622 376.81,313.795 379.923,313.795Z" style="fill:white;"/>
+                    </g>
+                    <g id="left-ear" serif:id="left ear">
+                        <path d="M328.442,277.49C333.65,284.442 393.951,209.484 393.101,208.987C352.807,185.405 307.041,180.601 307.041,180.601C307.041,180.601 309.213,251.82 328.442,277.49Z" style="fill:rgb(244,44,78);"/>
+                        <path d="M306.458,175.94C306.458,175.94 299.465,230.456 328.548,275.051" style="fill:none;stroke:white;stroke-width:10.25px;stroke-linecap:square;"/>
+                        <path d="M311.88,188.641C281.629,187.805 306.943,181.037 306.943,181.037C306.943,181.037 309.041,173.562 340.574,186.762C372.107,199.962 377.111,217.002 377.111,217.002C377.111,217.002 342.131,189.476 311.88,188.641Z" style="fill:rgb(0,3,255);stroke:white;stroke-width:10.25px;stroke-linecap:square;"/>
+                        <path d="M306.458,175.94C306.458,175.94 361.272,185.615 390.544,208.571" style="fill:none;stroke:white;stroke-width:10.25px;stroke-linecap:square;"/>
+                        <path d="M405.17,200.869C375.826,178.539 292.607,150.439 292.317,163.862C291.916,182.368 282.286,230.224 324.356,293.842" style="fill:none;stroke:black;stroke-width:16.23px;stroke-linecap:square;"/>
+                        <g transform="matrix(1,0,0,1,-0.732658,0)">
+                            <path d="M330.507,272.039C337.021,281.254 372.619,227.389 369.247,221.92C358.585,204.622 311.63,188.487 311.63,188.487C311.63,188.487 311.883,245.692 330.507,272.039Z" style="fill:rgb(239,31,68);"/>
+                        </g>
+                        <path d="M346.81,245.811C342.68,227.873 321.729,215.612 321.729,215.612C321.729,215.612 346.545,212.024 363.533,228.676C372.021,236.996 349.601,257.933 346.81,245.811Z"/>
+                    </g>
+                    <g id="right-ear" serif:id="right ear">
+                        <path d="M627.065,189.882C581.509,206.783 559.776,224.29 551.396,242.138C547.385,252.699 549.443,259.45 560.107,260.8C576.823,268.441 583.349,277.698 578.231,288.804C572.537,292.622 560.866,295.046 546.974,296.952C579.184,303.05 595.197,324.023 598.962,356.243C584.053,328.678 560.682,323.869 533.036,330.553C573.847,344.268 589.578,369.575 578.988,407.047L601.009,387.293L609.556,351.949L607.123,320.994L620.159,303.677L645.534,264.925L646.881,223.716L642.6,165.917L627.065,189.882Z" style="fill:rgb(239,31,68);"/>
+                        <path d="M628.283,222.127C601.934,236.496 592.839,252.722 594.207,270.073C594.699,279.274 598.588,284.955 606.338,286.633C617.332,281.627 623.802,273.478 628.131,263.842C631.998,237.349 631.457,225.397 628.283,222.127Z" style="fill:rgb(255,74,100);fill-opacity:0.31;"/>
+                        <path d="M618.017,217.804C585.753,216.564 562.648,225.197 552.294,247.572C565.965,252.003 577.934,258.14 585.497,268.697C589.057,240.979 601.256,226.022 618.017,217.804Z"/>
+                        <path d="M343.165,326.98C351.48,278.603 371.811,248.452 400.29,230.661C397.639,243.76 398.934,249.408 401.318,253.001C402.655,241.294 408.371,230.59 418.825,220.972C438.696,213.588 462.353,212.465 489.277,216.746C481.18,224.615 476.267,232.484 473.228,240.353C480.21,235.427 486.782,231.25 492.299,229.007L488.609,253.466C497.211,236.71 507.21,226.567 519.277,226.204C540.164,215.144 556.833,207.065 567.745,203.053C554.743,210.138 543.55,218.272 535.771,228.387C568.34,208.889 598.706,195.722 626.587,189.699C631.356,260.12 612.929,280.908 591.419,295.101C618.23,292.32 639.117,266.637 640.322,164.867L595.369,169.468L518.538,209.67L474.66,202.384L423.616,203.489L374.567,227.814L342.505,274.092C340.188,296.578 339.899,315.182 343.165,326.98Z" style="fill:white;"/>
+                        <path d="M424.054,460.05C421.72,462.242 419.065,463.492 414.77,464.58C411.567,465.392 408.39,465.481 404.847,465.297C402.214,465.161 399.705,464.557 397.36,463.923C392.015,462.48 387.88,460.313 386.286,459.455C377.867,454.843 373.258,452.118 369.03,449.05C364.753,445.947 360.881,442.472 353.804,436.216C348.482,431.491 343.269,426.366 338.516,420.856C333.623,415.182 329.226,409.094 325.67,402.614C318.592,389.65 314.87,375.601 313.638,361.237C312.441,347.275 313.609,333.016 316.263,319.229C318.997,305.133 323.363,290.574 329.404,276.783C335.526,262.807 343.365,249.621 352.905,238.441C365.936,223.197 383.138,211.467 402.063,203.735C420.807,196.077 441.223,192.329 460.821,192.873C470.391,193.147 479.587,194.234 488.62,196.14C497.611,198.038 506.441,200.74 515.313,204.261L522.863,207.23L516.925,222.33L509.376,219.361C501.363,216.239 493.395,213.849 485.285,212.191C477.194,210.537 468.961,209.619 460.399,209.428C443.057,209.025 425.012,212.438 408.458,219.287C392.074,226.067 377.147,236.231 365.904,249.502C357.454,259.462 350.569,271.228 345.158,283.661C339.664,296.286 335.696,309.606 333.221,322.501C330.855,334.735 329.768,347.385 330.811,359.778C331.822,371.789 334.835,383.562 340.728,394.415C343.678,399.876 347.356,404.999 351.433,409.791C355.659,414.757 360.307,419.373 365.047,423.639C371.501,429.473 375.019,432.726 378.914,435.643C382.668,438.455 386.77,440.958 394.249,445.243C395.388,445.901 398.402,447.116 402.054,448.628C403.219,449.111 404.426,449.634 405.657,450.214C407.096,450.893 408.46,451.633 409.885,452.424C412.215,453.717 414.026,455.054 416.173,456.26C419.444,458.097 421.356,459.628 424.054,460.05Z"/>
+                        <path d="M559.959,296.756L559.611,296.677L559.769,295.981L560.118,296.06C563.476,296 568.973,295.623 574.439,295.767C578.463,295.873 582.047,296.457 584.467,296.961C588.433,297.962 592.523,299.306 596.429,301.32C600.474,303.406 604.008,306.36 607.097,309.447C613.192,315.882 616.758,324.025 618.483,332.789C620.828,344.703 619.55,357.811 617.168,368.752C612.482,389.521 602.939,407.362 589.982,422.314C577.103,437.176 560.851,449.143 543.035,458.543C536.629,461.801 530.189,464.746 522.739,466.225C520.973,466.575 519.174,466.892 517.289,466.968C515.128,467.054 513.011,467.031 510.717,466.735C507.553,466.327 504.587,465.843 501.187,464.766C497.774,463.685 494.945,462.435 491.259,460.735L490.903,460.708L490.958,459.996L491.314,460.023C495.28,458.902 498.173,457.698 501.602,456.565C505.137,455.397 508.02,454.258 511.097,453.138C512.342,452.685 513.474,452.195 514.683,451.818C517.553,450.925 520.268,450.111 522.87,449.139C527.142,447.544 531.117,445.7 535.019,443.528C550.858,434.974 565.2,424.094 576.707,410.812C587.863,397.936 596.369,382.77 600.572,364.925C602.385,357.459 603.617,348.752 603.037,340.347C602.514,332.764 600.668,325.358 595.764,319.737C594.191,317.843 592.314,316.128 590.335,314.499C588.091,312.653 585.819,310.887 583.473,309.309C582.371,308.568 581.404,307.778 580.331,307.098L559.959,296.756Z"/>
+                        <path d="M519.6,211.112C550.871,186.242 640.578,148.567 645.664,164.195C653.005,186.748 663.082,267.484 612.285,316.584" style="fill:none;stroke:black;stroke-width:16.23px;stroke-linecap:square;"/>
+                    </g>
+                </g>
+                <g id="right-paw" serif:id="right paw" transform="matrix(0.88341,-0.468601,0.468601,0.88341,-364.307,256.58)">
+                    <path d="M539.548,620.041L544.724,579.505C546.748,563.78 538.682,542.26 530.413,522.673L568.186,570.887L567.649,606.929L554.373,625.503L544.802,628.829L539.548,620.041Z" style="fill:rgb(201,29,61);"/>
+                    <path d="M447.279,571.421L433.408,558.104L431.697,537.607L444.516,515.64L481.005,507.505L512.95,514.053L534.926,526.146L536.46,536.808C542.528,543.418 546.334,554.45 545.543,574.481C547.737,587.478 545.974,598.097 539.941,606.151L516.346,613.226L486.646,610.83L447.279,571.421Z" style="fill:white;"/>
+                    <g transform="matrix(1.3212,0.991722,-0.991722,1.3212,460.708,-1012.89)">
+                        <g transform="matrix(0.85395,0,0,1.56845,-96.8505,-820.997)">
+                            <path d="M778.526,1014.39L767.433,1016.04C767.77,1015.31 767.999,1014.84 768.342,1014.03C768.622,1013.37 768.804,1012.84 768.938,1012.14C769.078,1011.41 768.995,1010.7 769.031,1009.97C769.089,1008.82 769.091,1007.72 769.364,1006.74C769.758,1005.15 770.408,1003.74 771.262,1002.42C772.193,1000.98 773.324,999.684 774.64,998.46C773.726,999.762 772.979,1001.11 772.531,1002.59C772.136,1003.9 772.011,1005.28 772.157,1006.8C772.27,1007.71 772.539,1008.7 773.037,1009.72C773.355,1010.37 773.686,1011.01 774.248,1011.62C774.9,1012.32 775.65,1012.78 776.529,1013.35C777.236,1013.82 777.8,1014 778.526,1014.39Z"/>
+                        </g>
+                        <g transform="matrix(0.85395,0,0,1.56845,-61.0369,-820.629)">
+                            <path d="M778.526,1014.39L767.433,1016.04C767.77,1015.31 767.999,1014.84 768.342,1014.03C768.622,1013.37 768.804,1012.84 768.938,1012.14C769.078,1011.41 768.995,1010.7 769.031,1009.97C769.089,1008.82 769.091,1007.72 769.364,1006.74C769.758,1005.15 770.408,1003.74 771.262,1002.42C772.193,1000.98 773.324,999.684 774.64,998.46C773.726,999.762 772.979,1001.11 772.531,1002.59C772.136,1003.9 772.011,1005.28 772.157,1006.8C772.27,1007.71 772.539,1008.7 773.037,1009.72C773.355,1010.37 773.686,1011.01 774.248,1011.62C774.9,1012.32 775.65,1012.78 776.529,1013.35C777.236,1013.82 777.8,1014 778.526,1014.39Z"/>
+                        </g>
+                        <g transform="matrix(0.85395,0,0,1.56845,-79.3931,-819.776)">
+                            <path d="M778.526,1014.39L767.433,1016.04C767.77,1015.31 767.999,1014.84 768.342,1014.03C768.622,1013.37 768.804,1012.84 768.938,1012.14C769.078,1011.41 768.995,1010.7 769.031,1009.97C769.089,1008.82 769.091,1007.72 769.364,1006.74C769.758,1005.15 770.408,1003.74 771.262,1002.42C772.193,1000.98 773.324,999.684 774.64,998.46C773.726,999.762 772.979,1001.11 772.531,1002.59C772.136,1003.9 772.011,1005.28 772.157,1006.8C772.27,1007.71 772.539,1008.7 773.037,1009.72C773.355,1010.37 773.686,1011.01 774.248,1011.62C774.9,1012.32 775.65,1012.78 776.529,1013.35C777.236,1013.82 777.8,1014 778.526,1014.39Z"/>
+                        </g>
+                    </g>
+                    <path id="paw" d="M529.564,624.39C528.368,624.744 527.153,625.036 525.927,625.29C524.122,625.664 522.289,625.875 520.459,626.028C517.936,626.203 515.328,626.502 512.782,626.438C510.417,626.379 508.106,625.987 505.887,625.217C496.449,621.887 486.984,616.897 477.902,610.985C464.849,602.491 452.585,592.098 442.168,582.511C433.844,574.811 425.043,567.301 420.776,558.349C417.284,551.022 416.311,542.788 420.116,532.891C421.58,529.092 423.695,525.628 426.264,522.499C429.778,518.219 434.147,514.563 438.68,511.508C458.048,498.482 481.392,495.697 503.292,500.802C524.726,505.799 544.72,518.349 557.985,535.849C561.605,540.62 567.916,550.73 572.767,560.326C576.617,567.941 579.455,575.322 579.947,579.888C580.335,583.491 579.318,591.265 577.513,598.849C575.658,606.646 572.943,614.186 570.879,617.095C567.284,622.163 561.881,630.319 556.278,634.37C551.117,638.1 545.659,639.05 540.465,636.649C535.167,634.201 532.851,631.58 531.335,628.852C530.572,627.479 530.041,626.024 529.564,624.39ZM542.914,615.528C543.356,616.733 543.686,617.841 543.977,618.872C544.244,619.817 544.363,620.652 544.771,621.386C545.031,621.855 545.562,622.092 546.357,622.445C546.893,622.04 549.34,620.162 550.595,618.727C553.599,615.292 556.281,611.107 558.342,608.202C559.783,606.169 561.264,600.758 562.546,595.308C563.843,589.798 564.878,584.192 564.585,581.577C564.209,578.226 561.769,572.944 558.918,567.366C554.506,558.736 548.814,549.627 545.532,545.341C534.383,530.796 517.612,520.458 499.703,516.379C482.089,512.368 463.307,514.455 447.798,524.995C445.068,526.847 442.398,528.971 440.12,531.43C438.124,533.583 436.431,535.998 435.381,538.747C433.512,543.629 433.837,547.689 435.559,551.301C439.017,558.549 446.542,564.27 453.278,570.511C463.034,579.599 474.549,589.416 486.751,597.552C494.702,602.854 502.925,607.473 511.199,610.545C511.92,610.817 512.681,610.925 513.456,610.973C515.543,611.102 517.692,610.939 519.768,610.893C521.028,610.884 522.293,610.836 523.549,610.686C524.759,610.542 525.965,610.382 527.14,610.078C534.183,608.61 538.567,602.613 541.372,595.905C545.17,586.823 546.561,576.804 544.927,571.022L546.334,570.398C549.442,575.304 551.421,584.308 550.853,593.76C550.637,597.35 549.851,600.87 548.805,604.288C547.523,608.477 545.521,612.272 542.914,615.528Z"/>
+                </g>
+                <g id="left-paw" serif:id="left paw" transform="matrix(1.01046,-0.150726,0.150726,1.01046,-109.436,120.503)">
+                    <g transform="matrix(1,-5.55112e-17,5.55112e-17,1,41.3636,-56.5972)">
+                        <path d="M431.855,584.954L421.975,560.993L431.697,537.607L444.516,515.64L481.005,507.505L512.95,514.053L534.926,526.146L542.042,536.636C548.109,543.246 566.7,557.983 565.909,578.014C568.103,591.011 573.465,620.24 567.431,628.294C551.507,619.681 535.582,611.066 514.404,625.645L474.55,622.223L431.855,584.954Z" style="fill:white;"/>
+                    </g>
+                    <g transform="matrix(0.527307,0.849675,-0.849675,0.527307,846.754,87.2625)">
+                        <path d="M203.557,448.705C227.59,453.292 240.083,466.213 236.351,490.851L249.271,466.272L256.037,480.219L274.564,485.128L309.154,496.707L314.224,479.806C292.109,462.297 268.73,446.423 238.484,439.425L249.086,454.688C227.854,438.868 215.509,443.34 203.557,448.705Z" style="fill:rgb(255,132,0);"/>
+                    </g>
+                    <g transform="matrix(0.527307,0.849675,-0.849675,0.527307,846.754,87.2625)">
+                        <path d="M236.958,489.862C237.589,470.848 243.017,449.122 261.514,468.971C262.042,466.394 264.086,467.612 258.265,460.972C272.573,467.853 290.297,471.787 296.308,480.503C301.019,477.575 292.937,466.907 289.647,460.496L311.622,478.003L309.378,495.515L257.412,480.442L249.123,465.98L236.958,489.862Z" style="fill:rgb(201,29,61);"/>
+                    </g>
+                    <g transform="matrix(1.29094,0.973735,-0.973735,1.29094,489.817,-1020.47)">
+                        <g transform="matrix(0.85395,0,0,1.56845,-96.8505,-820.997)">
+                            <path d="M778.526,1014.39L767.433,1016.04C767.77,1015.31 767.999,1014.84 768.342,1014.03C768.622,1013.37 768.804,1012.84 768.938,1012.14C769.078,1011.41 768.995,1010.7 769.031,1009.97C769.089,1008.82 769.091,1007.72 769.364,1006.74C769.758,1005.15 770.408,1003.74 771.262,1002.42C772.193,1000.98 773.324,999.684 774.64,998.46C773.726,999.762 772.979,1001.11 772.531,1002.59C772.136,1003.9 772.011,1005.28 772.157,1006.8C772.27,1007.71 772.539,1008.7 773.037,1009.72C773.355,1010.37 773.686,1011.01 774.248,1011.62C774.9,1012.32 775.65,1012.78 776.529,1013.35C777.236,1013.82 777.8,1014 778.526,1014.39Z"/>
+                        </g>
+                        <g transform="matrix(0.85395,0,0,1.56845,-61.0369,-820.629)">
+                            <path d="M778.526,1014.39L767.433,1016.04C767.77,1015.31 767.999,1014.84 768.342,1014.03C768.622,1013.37 768.804,1012.84 768.938,1012.14C769.078,1011.41 768.995,1010.7 769.031,1009.97C769.089,1008.82 769.091,1007.72 769.364,1006.74C769.758,1005.15 770.408,1003.74 771.262,1002.42C772.193,1000.98 773.324,999.684 774.64,998.46C773.726,999.762 772.979,1001.11 772.531,1002.59C772.136,1003.9 772.011,1005.28 772.157,1006.8C772.27,1007.71 772.539,1008.7 773.037,1009.72C773.355,1010.37 773.686,1011.01 774.248,1011.62C774.9,1012.32 775.65,1012.78 776.529,1013.35C777.236,1013.82 777.8,1014 778.526,1014.39Z"/>
+                        </g>
+                        <g transform="matrix(0.85395,0,0,1.56845,-79.3931,-819.776)">
+                            <path d="M778.526,1014.39L767.433,1016.04C767.77,1015.31 767.999,1014.84 768.342,1014.03C768.622,1013.37 768.804,1012.84 768.938,1012.14C769.078,1011.41 768.995,1010.7 769.031,1009.97C769.089,1008.82 769.091,1007.72 769.364,1006.74C769.758,1005.15 770.408,1003.74 771.262,1002.42C772.193,1000.98 773.324,999.684 774.64,998.46C773.726,999.762 772.979,1001.11 772.531,1002.59C772.136,1003.9 772.011,1005.28 772.157,1006.8C772.27,1007.71 772.539,1008.7 773.037,1009.72C773.355,1010.37 773.686,1011.01 774.248,1011.62C774.9,1012.32 775.65,1012.78 776.529,1013.35C777.236,1013.82 777.8,1014 778.526,1014.39Z"/>
+                        </g>
+                    </g>
+                    <g id="paw1" serif:id="paw" transform="matrix(1,-5.55112e-17,5.55112e-17,1,41.3636,-56.5972)">
+                        <path d="M527.632,626.583C527.386,626.321 526.867,625.77 526.387,625.264C524.211,627.071 521.85,628.62 519.36,629.964C514.496,632.589 509.095,634.043 503.499,634.842C495.28,635.671 486.872,634.934 478.66,632.732C470.848,630.637 463.289,627.114 456.196,622.829C441.809,614.14 429.533,601.778 421.665,588.607C416.645,580.164 413.292,570.365 412.73,560.596C412.133,550.221 414.641,539.887 421.356,530.99C428.286,521.821 435.924,513.271 444.972,506.691C451.305,502.085 458.32,498.431 466.238,496.132C484.372,490.877 502.551,493.937 518.934,502.159C542.084,513.777 561.565,535.797 571.721,557.488C573.525,561.341 575.201,565.42 576.528,569.601C577.922,573.989 578.936,578.488 579.353,582.961C582.31,614.536 580.292,638.597 575.987,653.627C573.396,662.669 569.777,668.817 566.09,672.154C562.886,675.054 559.419,676.325 555.961,676.333C552.714,676.34 549.307,675.223 546,672.493C539.399,667.045 532.096,652.363 527.632,626.583ZM536.237,613.873C536.648,614.362 537.192,614.772 537.652,615.242C538.846,616.459 539.935,617.731 540.744,619.107C541.537,620.454 542.096,621.901 542.365,623.479C545.264,640.494 549.031,651.939 553.279,658.2C553.978,659.231 554.666,660.08 555.378,660.718C555.515,660.84 555.71,660.982 555.878,661.097C555.918,661.065 555.955,661.034 555.986,661.006C558.222,658.977 559.918,654.989 561.474,649.494C565.393,635.646 566.906,613.477 564.074,584.421C563.742,581.027 562.932,577.621 561.859,574.295C560.721,570.765 559.278,567.326 557.738,564.075C550.303,548.386 537.252,532.506 521.429,521.86C506.269,511.659 488.484,506.233 470.706,511.453C463.041,513.698 456.509,517.647 450.695,522.547C444.514,527.757 439.136,534.036 434.141,540.648C429.823,546.36 428.342,553.032 428.708,559.698C429.106,566.959 431.636,574.228 435.338,580.52C441.887,591.706 452.269,602.106 464.306,609.638C470.2,613.327 476.509,616.259 482.952,618.391C489.482,620.552 496.115,622.037 502.798,621.982C507.094,622.124 511.321,621.745 515.324,620.468C519.386,619.173 523.229,617.323 526.553,614.404C530.349,611.235 534.361,608.698 537.028,605.349C538.797,603.128 539.972,600.676 539.907,597.421L541.397,597.204C542.447,601.007 541.752,604.233 540.337,607.369C539.324,609.615 537.858,611.729 536.237,613.873Z"/>
+                    </g>
+                </g>
+            </g>
+        </g>
+        <g id="cheap-zipper" serif:id="cheap zipper">
+            <g transform="matrix(1,0,0,1,141.499,30.9749)">
+                <path d="M528.757,590.258L489.778,591.553C489.04,572.805 492.931,555.212 499.568,538.388C512.833,504.767 538.237,474.568 553.498,443.173C553.514,443.14 553.531,443.107 553.547,443.073C558.186,433.764 561.566,424.329 563.677,414.76C565.795,405.162 566.651,395.433 566.175,385.559C565.097,374.009 563.384,359.556 562.206,345.387C561.449,336.286 561.13,327.446 560.202,319.555C559.543,313.944 559.626,309.052 558.357,305.05C557.906,303.629 558.267,302.194 557.579,301.213C557.402,300.96 557.918,300.512 557.686,300.372L566.324,279.806C568.171,280.373 569.775,281.537 571.585,282.559C579.18,286.85 586.327,296.829 592.418,311.07C596.042,319.544 598.744,329.538 600.828,339.926C603.78,354.635 604.704,370.04 606.132,382.067C606.168,382.405 606.195,382.745 606.213,383.085C606.992,396.696 605.948,410.129 603.077,423.376C600.317,436.11 595.847,448.671 589.743,460.959C576.625,487.465 556.146,513.04 542.067,540.633C534.14,556.169 528.272,572.378 528.757,590.258Z"/>
+            </g>
+            <g transform="matrix(1,0,0,1,141.499,30.9749)">
+                <path d="M517.763,590.623L500.772,591.188C500.1,574.008 503.71,557.896 509.791,542.48C522.953,509.113 548.213,479.169 563.348,448.006C563.355,447.991 563.363,447.976 563.37,447.961C568.41,437.812 572.06,427.521 574.349,417.094C576.679,406.483 577.603,395.73 577.054,384.814C575.681,370.395 572.202,351.636 569.419,334.93C568.914,331.894 568.436,328.939 568.116,326.059C567.969,324.738 567.933,323.47 567.842,322.193C567.76,321.054 567.642,319.974 567.612,318.877C567.466,313.625 567.583,309.282 567.721,305.344C567.945,298.99 568.431,295.254 568.212,293.828C569.278,294.854 571.689,297.889 574.984,303.513C576.712,306.464 578.373,309.742 580.206,313.762C581.409,316.398 582.555,319.127 583.607,322.165C584.245,324.009 584.768,325.928 585.271,327.905C589.831,345.837 593.386,367.244 595.29,383.209C595.306,383.364 595.318,383.519 595.327,383.674C596.042,396.299 595.08,408.758 592.405,421.042C589.819,432.917 585.626,444.625 579.893,456.125C566.78,482.593 546.296,508.116 532.232,535.673C523.463,552.855 517.222,570.849 517.763,590.623Z" style="fill:rgb(249,233,232);"/>
+            </g>
+        </g>
+        <g transform="matrix(1.17103,0,0,1.17103,-224.817,-135.641)">
+            <path d="M680.815,660.712C696.203,666.314 728.471,642.38 734.657,648.246" style="fill:none;stroke:black;stroke-width:11.1px;stroke-linecap:butt;"/>
+        </g>
+        <g id="action" transform="matrix(1.17103,6.50052e-17,-6.50052e-17,1.17103,-26.8851,-55.5738)">
+            <g id="zipper">
+                <g id="action1" serif:id="action">
+                    <path d="M582.761,579.971C599.958,579.89 612.838,594.43 611.46,611.898C610.141,628.603 596.772,635.052 582.695,634.191C564.652,633.088 553.565,626.747 553.565,610.604C553.565,594.461 564.685,580.056 582.761,579.971Z" style="fill:rgb(255,244,243);"/>
+                    <g transform="matrix(1,0,0,1,0.585078,3.85718)">
+                        <path d="M571.175,596.229C577.42,592.765 584.08,592.297 591.265,595.609" style="fill:none;stroke:rgb(242,219,217);stroke-width:8.54px;"/>
+                    </g>
+                    <path d="M565.048,621.742C564.581,613.99 563.301,606.686 566.262,602.572C574.849,602.006 585.336,601.134 597.576,601.649C601.665,607.869 600.256,616.243 598.264,623.147" style="fill:none;stroke:rgb(112,112,112);stroke-width:8.54px;"/>
+                    <path d="M582.761,579.971C599.958,579.89 612.838,594.43 611.46,611.898C610.141,628.603 596.772,635.052 582.695,634.191C564.652,633.088 553.565,626.747 553.565,610.604C553.565,594.461 564.685,580.056 582.761,579.971Z" style="fill:none;stroke:black;stroke-width:8.54px;"/>
+                    <g transform="matrix(1,0,0,1.02174,0,-14.6088)">
+                        <path d="M567.987,605.794L595.744,605.195L596.741,621.7C601.989,634.015 604.731,646.701 602.29,650.836C597.794,664.222 592.215,663.85 583.413,665.131C571.748,664.175 566.974,662.588 561.246,650.343C560.216,642.794 560.231,634.421 567.595,621.006L567.987,605.794Z" style="fill:rgb(255,244,243);"/>
+                    </g>
+                    <g transform="matrix(1,0,0,0.888371,-2.56202,76.8296)">
+                        <path d="M568.463,651.574C568.276,651.569 568.092,651.474 567.967,651.296C567.747,650.98 567.795,650.522 568.076,650.274C568.226,650.044 568.593,650.019 569.235,650.259C569.556,650.379 569.998,650.622 570.611,651.014C571.115,651.336 571.706,651.712 572.357,652.231C573.674,653.281 575.22,654.745 577.113,655.935C579.363,657.351 582.024,658.511 585.005,658.599C588.362,658.697 591.98,657.264 596.099,653.744C596.659,653.267 597.238,652.784 597.846,652.269C598.286,651.897 598.735,651.551 599.206,651.165C599.666,650.788 600.12,650.448 600.599,650.041C600.832,649.736 601.24,649.702 601.511,649.964C601.782,650.226 601.812,650.686 601.579,650.991C601.281,651.609 601.006,652.167 600.69,652.73C600.357,653.321 600.022,653.854 599.655,654.37C599.135,655.101 598.585,655.745 598.02,656.331C593.512,660.994 588.903,662.295 584.929,662.198C581.383,662.112 578.193,660.752 575.55,659.001C573.498,657.642 571.703,656.143 570.463,654.717C570.058,654.251 569.743,653.792 569.458,653.368C569.071,652.791 568.82,652.319 568.588,651.969C568.481,651.808 568.37,651.591 568.37,651.591C568.37,651.591 568.417,651.579 568.463,651.574ZM568.521,651.572C568.524,651.573 568.528,651.573 568.531,651.574C568.62,651.604 568.687,651.557 568.753,651.504C568.679,651.543 568.6,651.566 568.521,651.572Z" style="fill:rgb(93,93,93);"/>
+                    </g>
+                    <g transform="matrix(1,0,0,1.02174,0,-14.6088)">
+                        <path d="M567.987,605.794L595.744,605.195L596.741,621.7C600.944,632.942 605.726,643.828 605.489,650.225C603.612,662.142 596.25,666.907 584.792,669.678C571.135,669.075 561.764,663.795 558.107,651.183C557.076,643.633 560.231,634.421 567.595,621.006L567.987,605.794Z" style="fill:none;stroke:black;stroke-width:8.45px;stroke-linecap:butt;"/>
+                    </g>
+                    <path d="M574.39,645.611C574.423,645.967 574.161,646.282 573.805,646.315C573.45,646.347 573.135,646.085 573.102,645.73C572.874,645.314 572.793,644.976 572.688,644.543C572.616,644.244 572.644,643.978 572.646,643.677C572.648,643.354 572.717,643.059 572.813,642.753C573.256,641.332 574.487,640.199 575.912,639.309C577.637,638.231 579.861,637.603 582.067,637.503C584.065,637.414 586.058,637.765 587.685,638.601C588.945,639.249 590.071,640.135 590.716,641.387C590.984,641.906 591.206,642.46 591.272,643.084C591.309,643.43 591.338,643.757 591.292,644.124C591.229,644.619 591.151,645.057 590.968,645.582C590.965,645.939 590.673,646.226 590.316,646.223C589.959,646.219 589.672,645.927 589.675,645.57C589.523,645.096 589.306,644.76 589.105,644.366C588.989,644.139 588.839,643.969 588.721,643.761C588.556,643.468 588.358,643.222 588.172,642.966C587.681,642.291 587.047,641.775 586.289,641.411C585.096,640.84 583.657,640.633 582.213,640.699C580.54,640.776 578.864,641.231 577.528,642.001C576.633,642.518 575.96,643.196 575.459,643.963C575.253,644.278 574.98,644.495 574.81,644.843C574.674,645.122 574.494,645.298 574.39,645.611Z" style="fill:rgb(93,93,93);"/>
+                    <g transform="matrix(1,0,0,1.52873,2.02916,-337.959)">
+                        <path d="M579.798,640.196C584.512,640.196 588.769,640.997 588.769,642.962C588.769,644.927 584.512,647.317 579.798,647.317C575.084,647.317 571.419,644.908 571.419,642.942C571.419,640.977 575.084,640.196 579.798,640.196Z"/>
+                    </g>
+                    <path d="M576.438,612.907C576.693,626.232 576.147,634.584 571.723,641.484C572.346,643.833 572.526,647.157 574.883,648.294C576.288,649.86 578.013,651.269 581.834,651.653C584.904,651.531 586.199,651.067 588.9,648.528C590.752,646.905 591.632,644.916 592.672,640.377C590.819,639.997 588.726,619.384 589.447,612.694L576.438,612.907Z" style="fill:rgb(219,176,172);fill-opacity:0.37;"/>
+                </g>
+            </g>
+        </g>
+    </g>
+    <defs>
+        <image id="_Image3" width="1200px" height="1200px" xlink:href="data:image/png;base64,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"/>
+        <image id="_Image5" width="2400px" height="2072px" xlink:href="data:image/png;base64,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"/>
+        <radialGradient id="_Radial6" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="matrix(138.211,0,0,115.087,259.378,759.319)"><stop offset="0" style="stop-color:rgb(63,199,255);stop-opacity:1"/><stop offset="0.08" style="stop-color:rgb(255,200,0);stop-opacity:1"/><stop offset="1" style="stop-color:rgb(191,32,255);stop-opacity:1"/></radialGradient>
+        <image id="_Image7" width="300px" height="300px" xlink:href="data:image/png;base64,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"/>
+    </defs>
+</svg>
diff --git a/docs/public/stackblitz.svg b/docs/public/stackblitz.svg
new file mode 100644
index 0000000..2106dc2
--- /dev/null
+++ b/docs/public/stackblitz.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="#1389FD" viewBox="0 0 32 32" width="1em" height="1em"><path d="M5.853 18.647h8.735L9.45 31l16.697-17.647h-8.735L22.55 1z"></path></svg>
\ No newline at end of file
diff --git a/docs/quick-start.md b/docs/quick-start.md
new file mode 100644
index 0000000..ad35827
--- /dev/null
+++ b/docs/quick-start.md
@@ -0,0 +1,63 @@
+# Quick Start
+
+## Installation
+
+```bash
+# bun
+bun add @kitbag/query
+# yarn
+yarn add @kitbag/query
+# npm
+npm install @kitbag/query
+```
+
+## Creating a query
+
+Simply pass the function (`searchCats`) and a getter for the arguments to that function (`() => ['Maine Coon']`).
+
+```ts
+import { useQuery } from '@kitbag/query'
+
+function searchCats(breed?: string) {
+  ...
+}
+
+const catsQuery = useQuery(searchCats, () => ['Maine Coon'])
+```
+
+That's it! Now you have access to several useful properties on the query for tracking loading state, error state, and of course the response from `searchCats` when it's resolved.
+
+## Using a query
+
+```vue
+<template>
+  <div v-if="catsQuery.loading">
+    Loading...
+  </div>
+  
+  <div v-else-if="catsQuery.errored">
+    Error: {{ catsQuery.error }}
+  </div>
+  
+  <div v-for="cat in catsQuery.data ?? []" :key="cat.id">
+    <h1>{{ cat.name }}</h1>
+  </div>
+</template>
+```
+
+## Client
+
+Kitbag query exports a default client, so you can import `useQuery` directly which is perfect for most use cases. More on creating your own [clients](/core-concepts/query-client) in a bit.
+
+## Caching
+
+Any other components that create a query for `searchCats` with the same `breed` argument will share this cached response. Learn more about [caching](/core-concepts/caching).
+
+## Next Steps
+
+Now that you have a basic query working, let's keep going
+
+- [Queries](/core-concepts/queries) - Dive deeper into query options and patterns
+- [Tags & Invalidation](/core-concepts/tags-invalidation) - Manage cache invalidation
+- [Mutations](/core-concepts/mutations) - Handle data modifications
+- [Query Client](/core-concepts/query-client) - Learn about configuration options
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index e9a5c9e..0daadfa 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@kitbag/query",
-  "version": "0.0.1-beta.2",
+  "version": "0.0.1-beta.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@kitbag/query",
-      "version": "0.0.1-beta.2",
+      "version": "0.0.1-beta.3",
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "vue": "^3.5.21"
@@ -19,9 +19,268 @@
         "typescript": "^5.8.3",
         "vite": "^7.0.5",
         "vite-plugin-dts": "^4.5.4",
+        "vitepress": "^1.6.3",
         "vitest": "^3.2.4"
       }
     },
+    "node_modules/@algolia/abtesting": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@algolia/abtesting/-/abtesting-1.3.0.tgz",
+      "integrity": "sha512-KqPVLdVNfoJzX5BKNGM9bsW8saHeyax8kmPFXul5gejrSPN3qss7PgsFH5mMem7oR8tvjvNkia97ljEYPYCN8Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/autocomplete-core": {
+      "version": "1.17.7",
+      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.17.7.tgz",
+      "integrity": "sha512-BjiPOW6ks90UKl7TwMv7oNQMnzU+t/wk9mgIDi6b1tXpUek7MW0lbNOUHpvam9pe3lVCf4xPFT+lK7s+e+fs7Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/autocomplete-plugin-algolia-insights": "1.17.7",
+        "@algolia/autocomplete-shared": "1.17.7"
+      }
+    },
+    "node_modules/@algolia/autocomplete-plugin-algolia-insights": {
+      "version": "1.17.7",
+      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.17.7.tgz",
+      "integrity": "sha512-Jca5Ude6yUOuyzjnz57og7Et3aXjbwCSDf/8onLHSQgw1qW3ALl9mrMWaXb5FmPVkV3EtkD2F/+NkT6VHyPu9A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/autocomplete-shared": "1.17.7"
+      },
+      "peerDependencies": {
+        "search-insights": ">= 1 < 3"
+      }
+    },
+    "node_modules/@algolia/autocomplete-preset-algolia": {
+      "version": "1.17.7",
+      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.17.7.tgz",
+      "integrity": "sha512-ggOQ950+nwbWROq2MOCIL71RE0DdQZsceqrg32UqnhDz8FlO9rL8ONHNsI2R1MH0tkgVIDKI/D0sMiUchsFdWA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/autocomplete-shared": "1.17.7"
+      },
+      "peerDependencies": {
+        "@algolia/client-search": ">= 4.9.1 < 6",
+        "algoliasearch": ">= 4.9.1 < 6"
+      }
+    },
+    "node_modules/@algolia/autocomplete-shared": {
+      "version": "1.17.7",
+      "resolved": "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.17.7.tgz",
+      "integrity": "sha512-o/1Vurr42U/qskRSuhBH+VKxMvkkUVTLU6WZQr+L5lGZZLYWyhdzWjW0iGXY7EkwRTjBqvN2EsR81yCTGV/kmg==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@algolia/client-search": ">= 4.9.1 < 6",
+        "algoliasearch": ">= 4.9.1 < 6"
+      }
+    },
+    "node_modules/@algolia/client-abtesting": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/client-abtesting/-/client-abtesting-5.37.0.tgz",
+      "integrity": "sha512-Dp2Zq+x9qQFnuiQhVe91EeaaPxWBhzwQ6QnznZQnH9C1/ei3dvtmAFfFeaTxM6FzfJXDLvVnaQagTYFTQz3R5g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-analytics": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-5.37.0.tgz",
+      "integrity": "sha512-wyXODDOluKogTuZxRII6mtqhAq4+qUR3zIUJEKTiHLe8HMZFxfUEI4NO2qSu04noXZHbv/sRVdQQqzKh12SZuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-common": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-5.37.0.tgz",
+      "integrity": "sha512-GylIFlPvLy9OMgFG8JkonIagv3zF+Dx3H401Uo2KpmfMVBBJiGfAb9oYfXtplpRMZnZPxF5FnkWaI/NpVJMC+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-insights": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/client-insights/-/client-insights-5.37.0.tgz",
+      "integrity": "sha512-T63afO2O69XHKw2+F7mfRoIbmXWGzgpZxgOFAdP3fR4laid7pWBt20P4eJ+Zn23wXS5kC9P2K7Bo3+rVjqnYiw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-personalization": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-5.37.0.tgz",
+      "integrity": "sha512-1zOIXM98O9zD8bYDCJiUJRC/qNUydGHK/zRK+WbLXrW1SqLFRXECsKZa5KoG166+o5q5upk96qguOtE8FTXDWQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-query-suggestions": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/client-query-suggestions/-/client-query-suggestions-5.37.0.tgz",
+      "integrity": "sha512-31Nr2xOLBCYVal+OMZn1rp1H4lPs1914Tfr3a34wU/nsWJ+TB3vWjfkUUuuYhWoWBEArwuRzt3YNLn0F/KRVkg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/client-search": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.37.0.tgz",
+      "integrity": "sha512-DAFVUvEg+u7jUs6BZiVz9zdaUebYULPiQ4LM2R4n8Nujzyj7BZzGr2DCd85ip4p/cx7nAZWKM8pLcGtkTRTdsg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/ingestion": {
+      "version": "1.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/ingestion/-/ingestion-1.37.0.tgz",
+      "integrity": "sha512-pkCepBRRdcdd7dTLbFddnu886NyyxmhgqiRcHHaDunvX03Ij4WzvouWrQq7B7iYBjkMQrLS8wQqSP0REfA4W8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/monitoring": {
+      "version": "1.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/monitoring/-/monitoring-1.37.0.tgz",
+      "integrity": "sha512-fNw7pVdyZAAQQCJf1cc/ih4fwrRdQSgKwgor4gchsI/Q/ss9inmC6bl/69jvoRSzgZS9BX4elwHKdo0EfTli3w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/recommend": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-5.37.0.tgz",
+      "integrity": "sha512-U+FL5gzN2ldx3TYfQO5OAta2TBuIdabEdFwD5UVfWPsZE5nvOKkc/6BBqP54Z/adW/34c5ZrvvZhlhNTZujJXQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/requester-browser-xhr": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.37.0.tgz",
+      "integrity": "sha512-Ao8GZo8WgWFABrU7iq+JAftXV0t+UcOtCDL4mzHHZ+rQeTTf1TZssr4d0vIuoqkVNnKt9iyZ7T4lQff4ydcTrw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/requester-fetch": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/requester-fetch/-/requester-fetch-5.37.0.tgz",
+      "integrity": "sha512-H7OJOXrFg5dLcGJ22uxx8eiFId0aB9b0UBhoOi4SMSuDBe6vjJJ/LeZyY25zPaSvkXNBN3vAM+ad6M0h6ha3AA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/@algolia/requester-node-http": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-5.37.0.tgz",
+      "integrity": "sha512-npZ9aeag4SGTx677eqPL3rkSPlQrnzx/8wNrl1P7GpWq9w/eTmRbOq+wKrJ2r78idlY0MMgmY/mld2tq6dc44g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/client-common": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
     "node_modules/@babel/helper-string-parser": {
       "version": "7.27.1",
       "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
@@ -68,6 +327,57 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@docsearch/css": {
+      "version": "3.8.2",
+      "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.8.2.tgz",
+      "integrity": "sha512-y05ayQFyUmCXze79+56v/4HpycYF3uFqB78pLPrSV5ZKAlDuIAAJNhaRi8tTdRNXh05yxX/TyNnzD6LwSM89vQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@docsearch/js": {
+      "version": "3.8.2",
+      "resolved": "https://registry.npmjs.org/@docsearch/js/-/js-3.8.2.tgz",
+      "integrity": "sha512-Q5wY66qHn0SwA7Taa0aDbHiJvaFJLOJyHmooQ7y8hlwwQLQ/5WwCcoX0g7ii04Qi2DJlHsd0XXzJ8Ypw9+9YmQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@docsearch/react": "3.8.2",
+        "preact": "^10.0.0"
+      }
+    },
+    "node_modules/@docsearch/react": {
+      "version": "3.8.2",
+      "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.8.2.tgz",
+      "integrity": "sha512-xCRrJQlTt8N9GU0DG4ptwHRkfnSnD/YpdeaXe02iKfqs97TkZJv60yE+1eq/tjPcVnTW8dP5qLP7itifFVV5eg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/autocomplete-core": "1.17.7",
+        "@algolia/autocomplete-preset-algolia": "1.17.7",
+        "@docsearch/css": "3.8.2",
+        "algoliasearch": "^5.14.2"
+      },
+      "peerDependencies": {
+        "@types/react": ">= 16.8.0 < 19.0.0",
+        "react": ">= 16.8.0 < 19.0.0",
+        "react-dom": ">= 16.8.0 < 19.0.0",
+        "search-insights": ">= 1 < 3"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "react": {
+          "optional": true
+        },
+        "react-dom": {
+          "optional": true
+        },
+        "search-insights": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.25.8",
       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.8.tgz",
@@ -789,6 +1099,23 @@
         "url": "https://github.com/sponsors/nzakas"
       }
     },
+    "node_modules/@iconify-json/simple-icons": {
+      "version": "1.2.52",
+      "resolved": "https://registry.npmjs.org/@iconify-json/simple-icons/-/simple-icons-1.2.52.tgz",
+      "integrity": "sha512-c41YOMzBhl3hp58WJLxT+Qq3UhBd8GZAMkbS8ddlCuIGLW0COGe2YSfOA2+poA8/bxLhUQODRNjAy3KhiAOtzA==",
+      "dev": true,
+      "license": "CC0-1.0",
+      "dependencies": {
+        "@iconify/types": "*"
+      }
+    },
+    "node_modules/@iconify/types": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@iconify/types/-/types-2.0.0.tgz",
+      "integrity": "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@isaacs/cliui": {
       "version": "8.0.2",
       "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
@@ -1338,6 +1665,93 @@
         "string-argv": "~0.3.1"
       }
     },
+    "node_modules/@shikijs/core": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/core/-/core-2.5.0.tgz",
+      "integrity": "sha512-uu/8RExTKtavlpH7XqnVYBrfBkUc20ngXiX9NSrBhOVZYv/7XQRKUyhtkeflY5QsxC0GbJThCerruZfsUaSldg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/engine-javascript": "2.5.0",
+        "@shikijs/engine-oniguruma": "2.5.0",
+        "@shikijs/types": "2.5.0",
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "@types/hast": "^3.0.4",
+        "hast-util-to-html": "^9.0.4"
+      }
+    },
+    "node_modules/@shikijs/engine-javascript": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/engine-javascript/-/engine-javascript-2.5.0.tgz",
+      "integrity": "sha512-VjnOpnQf8WuCEZtNUdjjwGUbtAVKuZkVQ/5cHy/tojVVRIRtlWMYVjyWhxOmIq05AlSOv72z7hRNRGVBgQOl0w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "2.5.0",
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "oniguruma-to-es": "^3.1.0"
+      }
+    },
+    "node_modules/@shikijs/engine-oniguruma": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-2.5.0.tgz",
+      "integrity": "sha512-pGd1wRATzbo/uatrCIILlAdFVKdxImWJGQ5rFiB5VZi2ve5xj3Ax9jny8QvkaV93btQEwR/rSz5ERFpC5mKNIw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "2.5.0",
+        "@shikijs/vscode-textmate": "^10.0.2"
+      }
+    },
+    "node_modules/@shikijs/langs": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/langs/-/langs-2.5.0.tgz",
+      "integrity": "sha512-Qfrrt5OsNH5R+5tJ/3uYBBZv3SuGmnRPejV9IlIbFH3HTGLDlkqgHymAlzklVmKBjAaVmkPkyikAV/sQ1wSL+w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "2.5.0"
+      }
+    },
+    "node_modules/@shikijs/themes": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/themes/-/themes-2.5.0.tgz",
+      "integrity": "sha512-wGrk+R8tJnO0VMzmUExHR+QdSaPUl/NKs+a4cQQRWyoc3YFbUzuLEi/KWK1hj+8BfHRKm2jNhhJck1dfstJpiw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "2.5.0"
+      }
+    },
+    "node_modules/@shikijs/transformers": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/transformers/-/transformers-2.5.0.tgz",
+      "integrity": "sha512-SI494W5X60CaUwgi8u4q4m4s3YAFSxln3tzNjOSYqq54wlVgz0/NbbXEb3mdLbqMBztcmS7bVTaEd2w0qMmfeg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/core": "2.5.0",
+        "@shikijs/types": "2.5.0"
+      }
+    },
+    "node_modules/@shikijs/types": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@shikijs/types/-/types-2.5.0.tgz",
+      "integrity": "sha512-ygl5yhxki9ZLNuNpPitBWvcy9fsSKKaRuO4BAlMyagszQidxcpLAr0qiW/q43DtSIDxO6hEbtYLiFZNXO/hdGw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "@types/hast": "^3.0.4"
+      }
+    },
+    "node_modules/@shikijs/vscode-textmate": {
+      "version": "10.0.2",
+      "resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-10.0.2.tgz",
+      "integrity": "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@stylistic/eslint-plugin": {
       "version": "2.13.0",
       "resolved": "https://registry.npmjs.org/@stylistic/eslint-plugin/-/eslint-plugin-2.13.0.tgz",
@@ -1389,6 +1803,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/hast": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
+      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
     "node_modules/@types/json-schema": {
       "version": "7.0.15",
       "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
@@ -1396,6 +1820,55 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/linkify-it": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@types/linkify-it/-/linkify-it-5.0.0.tgz",
+      "integrity": "sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/markdown-it": {
+      "version": "14.1.2",
+      "resolved": "https://registry.npmjs.org/@types/markdown-it/-/markdown-it-14.1.2.tgz",
+      "integrity": "sha512-promo4eFwuiW+TfGxhi+0x3czqTYJkG8qB17ZUJiVF10Xm7NLVRSLUsfRTU/6h1e24VvRnXCx+hG7li58lkzog==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/linkify-it": "^5",
+        "@types/mdurl": "^2"
+      }
+    },
+    "node_modules/@types/mdast": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
+      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/mdurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@types/mdurl/-/mdurl-2.0.0.tgz",
+      "integrity": "sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/unist": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
+      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/web-bluetooth": {
+      "version": "0.0.21",
+      "resolved": "https://registry.npmjs.org/@types/web-bluetooth/-/web-bluetooth-0.0.21.tgz",
+      "integrity": "sha512-oIQLCGWtcFZy2JW77j9k8nHzAOpqMHLQejDA48XXMWH6tjCQHz5RCFz1bzsmROyL6PUm+LLnUiI4BCn221inxA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@typescript-eslint/eslint-plugin": {
       "version": "8.33.0",
       "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.33.0.tgz",
@@ -1653,6 +2126,13 @@
         "url": "https://opencollective.com/typescript-eslint"
       }
     },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/@vitejs/plugin-vue": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-6.0.0.tgz",
@@ -1885,6 +2365,42 @@
         "he": "^1.2.0"
       }
     },
+    "node_modules/@vue/devtools-api": {
+      "version": "7.7.7",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-7.7.7.tgz",
+      "integrity": "sha512-lwOnNBH2e7x1fIIbVT7yF5D+YWhqELm55/4ZKf45R9T8r9dE2AIOy8HKjfqzGsoTHFbWbr337O4E0A0QADnjBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/devtools-kit": "^7.7.7"
+      }
+    },
+    "node_modules/@vue/devtools-kit": {
+      "version": "7.7.7",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-kit/-/devtools-kit-7.7.7.tgz",
+      "integrity": "sha512-wgoZtxcTta65cnZ1Q6MbAfePVFxfM+gq0saaeytoph7nEa7yMXoi6sCPy4ufO111B9msnw0VOWjPEFCXuAKRHA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/devtools-shared": "^7.7.7",
+        "birpc": "^2.3.0",
+        "hookable": "^5.5.3",
+        "mitt": "^3.0.1",
+        "perfect-debounce": "^1.0.0",
+        "speakingurl": "^14.0.1",
+        "superjson": "^2.2.2"
+      }
+    },
+    "node_modules/@vue/devtools-shared": {
+      "version": "7.7.7",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-shared/-/devtools-shared-7.7.7.tgz",
+      "integrity": "sha512-+udSj47aRl5aKb0memBvcUG9koarqnxNM5yjuREvqwK6T3ap4mn3Zqqc17QrBFTqSMjr3HK1cvStEZpMDpfdyw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "rfdc": "^1.4.1"
+      }
+    },
     "node_modules/@vue/language-core": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/@vue/language-core/-/language-core-2.2.0.tgz",
@@ -1987,23 +2503,129 @@
         "vue-component-type-helpers": "^2.0.0"
       }
     },
-    "node_modules/abbrev": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-3.0.0.tgz",
-      "integrity": "sha512-+/kfrslGQ7TNV2ecmQwMJj/B65g5KVq1/L3SGVZ3tCYGqlzFuFCGBZJtMP99wH3NpEUyAjn0zPdPUg0D+DwrOA==",
+    "node_modules/@vueuse/core": {
+      "version": "12.8.2",
+      "resolved": "https://registry.npmjs.org/@vueuse/core/-/core-12.8.2.tgz",
+      "integrity": "sha512-HbvCmZdzAu3VGi/pWYm5Ut+Kd9mn1ZHnn4L5G8kOQTPs/IwIAmJoBrmYk2ckLArgMXZj0AW3n5CAejLUO+PhdQ==",
       "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^18.17.0 || >=20.5.0"
+      "license": "MIT",
+      "dependencies": {
+        "@types/web-bluetooth": "^0.0.21",
+        "@vueuse/metadata": "12.8.2",
+        "@vueuse/shared": "12.8.2",
+        "vue": "^3.5.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
       }
     },
-    "node_modules/acorn": {
-      "version": "8.15.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
-      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+    "node_modules/@vueuse/integrations": {
+      "version": "12.8.2",
+      "resolved": "https://registry.npmjs.org/@vueuse/integrations/-/integrations-12.8.2.tgz",
+      "integrity": "sha512-fbGYivgK5uBTRt7p5F3zy6VrETlV9RtZjBqd1/HxGdjdckBgBM4ugP8LHpjolqTj14TXTxSK1ZfgPbHYyGuH7g==",
       "dev": true,
       "license": "MIT",
-      "bin": {
+      "dependencies": {
+        "@vueuse/core": "12.8.2",
+        "@vueuse/shared": "12.8.2",
+        "vue": "^3.5.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      },
+      "peerDependencies": {
+        "async-validator": "^4",
+        "axios": "^1",
+        "change-case": "^5",
+        "drauu": "^0.4",
+        "focus-trap": "^7",
+        "fuse.js": "^7",
+        "idb-keyval": "^6",
+        "jwt-decode": "^4",
+        "nprogress": "^0.2",
+        "qrcode": "^1.5",
+        "sortablejs": "^1",
+        "universal-cookie": "^7"
+      },
+      "peerDependenciesMeta": {
+        "async-validator": {
+          "optional": true
+        },
+        "axios": {
+          "optional": true
+        },
+        "change-case": {
+          "optional": true
+        },
+        "drauu": {
+          "optional": true
+        },
+        "focus-trap": {
+          "optional": true
+        },
+        "fuse.js": {
+          "optional": true
+        },
+        "idb-keyval": {
+          "optional": true
+        },
+        "jwt-decode": {
+          "optional": true
+        },
+        "nprogress": {
+          "optional": true
+        },
+        "qrcode": {
+          "optional": true
+        },
+        "sortablejs": {
+          "optional": true
+        },
+        "universal-cookie": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vueuse/metadata": {
+      "version": "12.8.2",
+      "resolved": "https://registry.npmjs.org/@vueuse/metadata/-/metadata-12.8.2.tgz",
+      "integrity": "sha512-rAyLGEuoBJ/Il5AmFHiziCPdQzRt88VxR+Y/A/QhJ1EWtWqPBBAxTAFaSkviwEuOEZNtW8pvkPgoCZQ+HxqW1A==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/@vueuse/shared": {
+      "version": "12.8.2",
+      "resolved": "https://registry.npmjs.org/@vueuse/shared/-/shared-12.8.2.tgz",
+      "integrity": "sha512-dznP38YzxZoNloI0qpEfpkms8knDtaoQ6Y/sfS0L7Yki4zh40LFHEhur0odJC6xTHG5dxWVPiUWBXn+wCG2s5w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "vue": "^3.5.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/abbrev": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-3.0.0.tgz",
+      "integrity": "sha512-+/kfrslGQ7TNV2ecmQwMJj/B65g5KVq1/L3SGVZ3tCYGqlzFuFCGBZJtMP99wH3NpEUyAjn0zPdPUg0D+DwrOA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.15.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
         "acorn": "bin/acorn"
       },
       "engines": {
@@ -2070,6 +2692,32 @@
         }
       }
     },
+    "node_modules/algoliasearch": {
+      "version": "5.37.0",
+      "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.37.0.tgz",
+      "integrity": "sha512-y7gau/ZOQDqoInTQp0IwTOjkrHc4Aq4R8JgpmCleFwiLl+PbN2DMWoDUWZnrK8AhNJwT++dn28Bt4NZYNLAmuA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@algolia/abtesting": "1.3.0",
+        "@algolia/client-abtesting": "5.37.0",
+        "@algolia/client-analytics": "5.37.0",
+        "@algolia/client-common": "5.37.0",
+        "@algolia/client-insights": "5.37.0",
+        "@algolia/client-personalization": "5.37.0",
+        "@algolia/client-query-suggestions": "5.37.0",
+        "@algolia/client-search": "5.37.0",
+        "@algolia/ingestion": "1.37.0",
+        "@algolia/monitoring": "1.37.0",
+        "@algolia/recommend": "5.37.0",
+        "@algolia/requester-browser-xhr": "5.37.0",
+        "@algolia/requester-fetch": "5.37.0",
+        "@algolia/requester-node-http": "5.37.0"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
     "node_modules/alien-signals": {
       "version": "0.4.14",
       "resolved": "https://registry.npmjs.org/alien-signals/-/alien-signals-0.4.14.tgz",
@@ -2132,6 +2780,16 @@
       "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
       "dev": true
     },
+    "node_modules/birpc": {
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/birpc/-/birpc-2.6.1.tgz",
+      "integrity": "sha512-LPnFhlDpdSH6FJhJyn4M0kFO7vtQ5iPw24FnG0y21q09xC7e8+1LeR31S1MAIrDAHp4m7aas4bEkTDTvMAtebQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
     "node_modules/boolbase": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
@@ -2181,6 +2839,17 @@
         "node": ">=6"
       }
     },
+    "node_modules/ccount": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
+      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/chai": {
       "version": "5.3.3",
       "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
@@ -2228,6 +2897,28 @@
         "node": ">=8"
       }
     },
+    "node_modules/character-entities-html4": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
+      "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-legacy": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
+      "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/check-error": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz",
@@ -2258,6 +2949,17 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/comma-separated-tokens": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
+      "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/compare-versions": {
       "version": "6.1.1",
       "resolved": "https://registry.npmjs.org/compare-versions/-/compare-versions-6.1.1.tgz",
@@ -2290,6 +2992,22 @@
         "proto-list": "~1.2.1"
       }
     },
+    "node_modules/copy-anything": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/copy-anything/-/copy-anything-3.0.5.tgz",
+      "integrity": "sha512-yCEafptTtb4bk7GLEQoM8KVJpxAfdBJYaXyzQEgQQQgYrZiDp8SJmGKlYza6CYjEDNstAdNdKA3UuoULlEbS6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-what": "^4.1.8"
+      },
+      "engines": {
+        "node": ">=12.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/mesqueeb"
+      }
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -2366,6 +3084,30 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/devlop": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",
+      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/eastasianwidth": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
@@ -2425,6 +3167,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/emoji-regex-xs": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex-xs/-/emoji-regex-xs-1.0.0.tgz",
+      "integrity": "sha512-LRlerrMYoIDrT6jgpeZ2YYl/L8EulRTt5hQcYjy5AInh7HWXKimpqx68aknBFpGL2+/IcogTcaydJEgaTmOpDg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/entities": {
       "version": "4.5.0",
       "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
@@ -2915,6 +3664,16 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/focus-trap": {
+      "version": "7.6.5",
+      "resolved": "https://registry.npmjs.org/focus-trap/-/focus-trap-7.6.5.tgz",
+      "integrity": "sha512-7Ke1jyybbbPZyZXFxEftUtxFGLMpE2n6A+z//m4CRDlj0hW+o3iYSmh8nFlYMurOiJVDmJRilUQtJr08KfIxlg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tabbable": "^6.2.0"
+      }
+    },
     "node_modules/foreground-child": {
       "version": "3.3.0",
       "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.0.tgz",
@@ -3074,6 +3833,44 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/hast-util-to-html": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.5.tgz",
+      "integrity": "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "html-void-elements": "^3.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "stringify-entities": "^4.0.0",
+        "zwitch": "^2.0.4"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-whitespace": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
+      "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/he": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
@@ -3084,6 +3881,24 @@
         "he": "bin/he"
       }
     },
+    "node_modules/hookable": {
+      "version": "5.5.3",
+      "resolved": "https://registry.npmjs.org/hookable/-/hookable-5.5.3.tgz",
+      "integrity": "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/html-void-elements": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz",
+      "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/ignore": {
       "version": "5.3.2",
       "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
@@ -3197,6 +4012,19 @@
         "node": ">=0.12.0"
       }
     },
+    "node_modules/is-what": {
+      "version": "4.1.16",
+      "resolved": "https://registry.npmjs.org/is-what/-/is-what-4.1.16.tgz",
+      "integrity": "sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/mesqueeb"
+      }
+    },
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -3425,6 +4253,35 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/mark.js": {
+      "version": "8.11.1",
+      "resolved": "https://registry.npmjs.org/mark.js/-/mark.js-8.11.1.tgz",
+      "integrity": "sha512-1I+1qpDt4idfgLQG+BNWmrqku+7/2bi5nLf4YwF8y8zXvmfiTBY3PV3ZibfrjBueCByROpuBjLLFCajqkgYoLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/mdast-util-to-hast": {
+      "version": "13.2.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz",
+      "integrity": "sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "trim-lines": "^3.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/merge2": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
@@ -3435,6 +4292,100 @@
         "node": ">= 8"
       }
     },
+    "node_modules/micromark-util-character": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-encode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-sanitize-uri": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-symbol": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-types": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+      "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/micromatch": {
       "version": "4.0.8",
       "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
@@ -3496,6 +4447,20 @@
         "node": ">=16 || 14 >=14.17"
       }
     },
+    "node_modules/minisearch": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/minisearch/-/minisearch-7.2.0.tgz",
+      "integrity": "sha512-dqT2XBYUOZOiC5t2HRnwADjhNS2cecp9u+TJRiJ1Qp/f5qjkeT5APcGPjHw+bz89Ms8Jp+cG4AlE+QZ/QnDglg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/mitt": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
+      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/mlly": {
       "version": "1.7.4",
       "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.7.4.tgz",
@@ -3596,6 +4561,18 @@
         "url": "https://github.com/fb55/nth-check?sponsor=1"
       }
     },
+    "node_modules/oniguruma-to-es": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-3.1.1.tgz",
+      "integrity": "sha512-bUH8SDvPkH3ho3dvwJwfonjlQ4R80vjyvrU8YpxuROddv55vAEJrTuCuCVUhhsHbtlD9tGGbaNApGQckXhS8iQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex-xs": "^1.0.0",
+        "regex": "^6.0.1",
+        "regex-recursion": "^6.0.2"
+      }
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -3743,7 +4720,14 @@
         "node": ">= 14.16"
       }
     },
-    "node_modules/picocolors": {
+    "node_modules/perfect-debounce": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/perfect-debounce/-/perfect-debounce-1.0.0.tgz",
+      "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
       "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
@@ -3816,6 +4800,17 @@
         "node": ">=4"
       }
     },
+    "node_modules/preact": {
+      "version": "10.27.2",
+      "resolved": "https://registry.npmjs.org/preact/-/preact-10.27.2.tgz",
+      "integrity": "sha512-5SYSgFKSyhCbk6SrXyMpqjb5+MQBgfvEKE/OC+PujcY34sOpqtr+0AZQtPYx5IA6VxynQ7rUPCtKzyovpj9Bpg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/preact"
+      }
+    },
     "node_modules/prelude-ls": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
@@ -3826,6 +4821,17 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/property-information": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz",
+      "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/proto-list": {
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz",
@@ -3881,6 +4887,33 @@
       ],
       "license": "MIT"
     },
+    "node_modules/regex": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/regex/-/regex-6.0.1.tgz",
+      "integrity": "sha512-uorlqlzAKjKQZ5P+kTJr3eeJGSVroLKoHmquUj4zHWuR+hEyNqlXsSKlYYF5F4NI6nl7tWCs0apKJ0lmfsXAPA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "regex-utilities": "^2.3.0"
+      }
+    },
+    "node_modules/regex-recursion": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/regex-recursion/-/regex-recursion-6.0.2.tgz",
+      "integrity": "sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "regex-utilities": "^2.3.0"
+      }
+    },
+    "node_modules/regex-utilities": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/regex-utilities/-/regex-utilities-2.3.0.tgz",
+      "integrity": "sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/require-from-string": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
@@ -3933,6 +4966,13 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/rfdc": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
+      "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/rollup": {
       "version": "4.45.1",
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.45.1.tgz",
@@ -3997,6 +5037,14 @@
         "queue-microtask": "^1.2.2"
       }
     },
+    "node_modules/search-insights": {
+      "version": "2.17.3",
+      "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.17.3.tgz",
+      "integrity": "sha512-RQPdCYTa8A68uM2jwxoY842xDhvx3E5LFL1LxvxCNMev4o5mLuokczhzjAgGwUZBAmOKZknArSxLKmXtIi2AxQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/semver": {
       "version": "7.5.4",
       "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz",
@@ -4033,6 +5081,23 @@
         "node": ">=8"
       }
     },
+    "node_modules/shiki": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/shiki/-/shiki-2.5.0.tgz",
+      "integrity": "sha512-mI//trrsaiCIPsja5CNfsyNOqgAZUb6VpJA+340toL42UpzQlXpwRV9nch69X6gaUxrr9kaOOa6e3y3uAkGFxQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/core": "2.5.0",
+        "@shikijs/engine-javascript": "2.5.0",
+        "@shikijs/engine-oniguruma": "2.5.0",
+        "@shikijs/langs": "2.5.0",
+        "@shikijs/themes": "2.5.0",
+        "@shikijs/types": "2.5.0",
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "@types/hast": "^3.0.4"
+      }
+    },
     "node_modules/siginfo": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
@@ -4071,6 +5136,27 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/space-separated-tokens": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
+      "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/speakingurl": {
+      "version": "14.0.1",
+      "resolved": "https://registry.npmjs.org/speakingurl/-/speakingurl-14.0.1.tgz",
+      "integrity": "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/sprintf-js": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
@@ -4166,6 +5252,21 @@
         "node": ">=8"
       }
     },
+    "node_modules/stringify-entities": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
+      "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "character-entities-html4": "^2.0.0",
+        "character-entities-legacy": "^3.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/strip-ansi": {
       "version": "7.1.0",
       "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
@@ -4232,6 +5333,19 @@
         "url": "https://github.com/sponsors/antfu"
       }
     },
+    "node_modules/superjson": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/superjson/-/superjson-2.2.2.tgz",
+      "integrity": "sha512-5JRxVqC8I8NuOUjzBbvVJAKNM8qoVuH0O77h4WInc/qC2q5IreqKxYwgkga3PfA22OayK2ikceb/B26dztPl+Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "copy-anything": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
     "node_modules/supports-color": {
       "version": "8.1.1",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
@@ -4261,6 +5375,13 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/tabbable": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.2.0.tgz",
+      "integrity": "sha512-Cat63mxsVJlzYvN51JmVXIgNoUokrIaT2zLclCXjRd8boZ0004U4KCs/sToJ75C6sdlByWxpYnb5Boif1VSFew==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tinybench": {
       "version": "2.9.0",
       "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
@@ -4335,6 +5456,17 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/trim-lines": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
+      "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/ts-api-utils": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.1.0.tgz",
@@ -4418,6 +5550,79 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/unist-util-is": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.0.tgz",
+      "integrity": "sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-position": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
+      "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-stringify-position": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+      "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz",
+      "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit-parents": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz",
+      "integrity": "sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/universalify": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
@@ -4445,6 +5650,36 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/vfile": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+      "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-message": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
+      "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/vite": {
       "version": "7.0.5",
       "resolved": "https://registry.npmjs.org/vite/-/vite-7.0.5.tgz",
@@ -4570,121 +5805,667 @@
         }
       }
     },
-    "node_modules/vitest": {
-      "version": "3.2.4",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.4.tgz",
-      "integrity": "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/chai": "^5.2.2",
-        "@vitest/expect": "3.2.4",
-        "@vitest/mocker": "3.2.4",
-        "@vitest/pretty-format": "^3.2.4",
-        "@vitest/runner": "3.2.4",
-        "@vitest/snapshot": "3.2.4",
-        "@vitest/spy": "3.2.4",
-        "@vitest/utils": "3.2.4",
-        "chai": "^5.2.0",
-        "debug": "^4.4.1",
-        "expect-type": "^1.2.1",
-        "magic-string": "^0.30.17",
-        "pathe": "^2.0.3",
-        "picomatch": "^4.0.2",
-        "std-env": "^3.9.0",
-        "tinybench": "^2.9.0",
-        "tinyexec": "^0.3.2",
-        "tinyglobby": "^0.2.14",
-        "tinypool": "^1.1.1",
-        "tinyrainbow": "^2.0.0",
-        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0",
-        "vite-node": "3.2.4",
-        "why-is-node-running": "^2.3.0"
+    "node_modules/vitepress": {
+      "version": "1.6.4",
+      "resolved": "https://registry.npmjs.org/vitepress/-/vitepress-1.6.4.tgz",
+      "integrity": "sha512-+2ym1/+0VVrbhNyRoFFesVvBvHAVMZMK0rw60E3X/5349M1GuVdKeazuksqopEdvkKwKGs21Q729jX81/bkBJg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@docsearch/css": "3.8.2",
+        "@docsearch/js": "3.8.2",
+        "@iconify-json/simple-icons": "^1.2.21",
+        "@shikijs/core": "^2.1.0",
+        "@shikijs/transformers": "^2.1.0",
+        "@shikijs/types": "^2.1.0",
+        "@types/markdown-it": "^14.1.2",
+        "@vitejs/plugin-vue": "^5.2.1",
+        "@vue/devtools-api": "^7.7.0",
+        "@vue/shared": "^3.5.13",
+        "@vueuse/core": "^12.4.0",
+        "@vueuse/integrations": "^12.4.0",
+        "focus-trap": "^7.6.4",
+        "mark.js": "8.11.1",
+        "minisearch": "^7.1.1",
+        "shiki": "^2.1.0",
+        "vite": "^5.4.14",
+        "vue": "^3.5.13"
       },
       "bin": {
-        "vitest": "vitest.mjs"
-      },
-      "engines": {
-        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+        "vitepress": "bin/vitepress.js"
       },
       "peerDependencies": {
-        "@edge-runtime/vm": "*",
-        "@types/debug": "^4.1.12",
-        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
-        "@vitest/browser": "3.2.4",
-        "@vitest/ui": "3.2.4",
-        "happy-dom": "*",
-        "jsdom": "*"
+        "markdown-it-mathjax3": "^4",
+        "postcss": "^8"
       },
       "peerDependenciesMeta": {
-        "@edge-runtime/vm": {
+        "markdown-it-mathjax3": {
           "optional": true
         },
-        "@types/debug": {
-          "optional": true
-        },
-        "@types/node": {
-          "optional": true
-        },
-        "@vitest/browser": {
-          "optional": true
-        },
-        "@vitest/ui": {
-          "optional": true
-        },
-        "happy-dom": {
-          "optional": true
-        },
-        "jsdom": {
+        "postcss": {
           "optional": true
         }
       }
     },
-    "node_modules/vscode-uri": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz",
-      "integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==",
+    "node_modules/vitepress/node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
       "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/vue": {
-      "version": "3.5.21",
-      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.21.tgz",
-      "integrity": "sha512-xxf9rum9KtOdwdRkiApWL+9hZEMWE90FHh8yS1+KJAiWYh+iGWV1FquPjoO9VUHQ+VIhsCXNNyZ5Sf4++RVZBA==",
       "license": "MIT",
-      "dependencies": {
-        "@vue/compiler-dom": "3.5.21",
-        "@vue/compiler-sfc": "3.5.21",
-        "@vue/runtime-dom": "3.5.21",
-        "@vue/server-renderer": "3.5.21",
-        "@vue/shared": "3.5.21"
-      },
-      "peerDependencies": {
-        "typescript": "*"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/vue-component-type-helpers": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/vue-component-type-helpers/-/vue-component-type-helpers-2.2.0.tgz",
-      "integrity": "sha512-cYrAnv2me7bPDcg9kIcGwjJiSB6Qyi08+jLDo9yuvoFQjzHiPTzML7RnkJB1+3P6KMsX/KbCD4QE3Tv/knEllw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/vue-eslint-parser": {
-      "version": "9.4.3",
-      "resolved": "https://registry.npmjs.org/vue-eslint-parser/-/vue-eslint-parser-9.4.3.tgz",
-      "integrity": "sha512-2rYRLWlIpaiN8xbPiDyXZXRgLGOtWxERV7ND5fFAv5qo1D2N9Fu9MNajBNc6o13lZ+24DAWCkQCvj4klgmcITg==",
+    "node_modules/vitepress/node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/vitepress/node_modules/@vitejs/plugin-vue": {
+      "version": "5.2.4",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz",
+      "integrity": "sha512-7Yx/SXSOcQq5HiiV3orevHUFn+pmMB4cgbEkDYgnkUWb0WfeQ/wa2yFv6D5ICiCQOVpjA7vYDXrC7AGO8yjDHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^5.0.0 || ^6.0.0",
+        "vue": "^3.2.25"
+      }
+    },
+    "node_modules/vitepress/node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/vitepress/node_modules/vite": {
+      "version": "5.4.20",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.20.tgz",
+      "integrity": "sha512-j3lYzGC3P+B5Yfy/pfKNgVEg4+UtcIJcVRt2cDjIOmhLourAqPqf8P7acgxeiSgUB7E3p2P8/3gNIgDLpwzs4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.4.tgz",
+      "integrity": "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "^5.2.2",
+        "@vitest/expect": "3.2.4",
+        "@vitest/mocker": "3.2.4",
+        "@vitest/pretty-format": "^3.2.4",
+        "@vitest/runner": "3.2.4",
+        "@vitest/snapshot": "3.2.4",
+        "@vitest/spy": "3.2.4",
+        "@vitest/utils": "3.2.4",
+        "chai": "^5.2.0",
+        "debug": "^4.4.1",
+        "expect-type": "^1.2.1",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.2",
+        "std-env": "^3.9.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^0.3.2",
+        "tinyglobby": "^0.2.14",
+        "tinypool": "^1.1.1",
+        "tinyrainbow": "^2.0.0",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0",
+        "vite-node": "3.2.4",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@types/debug": "^4.1.12",
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "@vitest/browser": "3.2.4",
+        "@vitest/ui": "3.2.4",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@types/debug": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vscode-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz",
+      "integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vue": {
+      "version": "3.5.21",
+      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.21.tgz",
+      "integrity": "sha512-xxf9rum9KtOdwdRkiApWL+9hZEMWE90FHh8yS1+KJAiWYh+iGWV1FquPjoO9VUHQ+VIhsCXNNyZ5Sf4++RVZBA==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.21",
+        "@vue/compiler-sfc": "3.5.21",
+        "@vue/runtime-dom": "3.5.21",
+        "@vue/server-renderer": "3.5.21",
+        "@vue/shared": "3.5.21"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vue-component-type-helpers": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/vue-component-type-helpers/-/vue-component-type-helpers-2.2.0.tgz",
+      "integrity": "sha512-cYrAnv2me7bPDcg9kIcGwjJiSB6Qyi08+jLDo9yuvoFQjzHiPTzML7RnkJB1+3P6KMsX/KbCD4QE3Tv/knEllw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vue-eslint-parser": {
+      "version": "9.4.3",
+      "resolved": "https://registry.npmjs.org/vue-eslint-parser/-/vue-eslint-parser-9.4.3.tgz",
+      "integrity": "sha512-2rYRLWlIpaiN8xbPiDyXZXRgLGOtWxERV7ND5fFAv5qo1D2N9Fu9MNajBNc6o13lZ+24DAWCkQCvj4klgmcITg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
         "debug": "^4.3.4",
         "eslint-scope": "^7.1.1",
         "eslint-visitor-keys": "^3.3.0",
@@ -4916,6 +6697,17 @@
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
+    },
+    "node_modules/zwitch": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
+      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
     }
   }
 }
diff --git a/package.json b/package.json
index 8e9b772..3ef7364 100644
--- a/package.json
+++ b/package.json
@@ -1,14 +1,19 @@
 {
   "name": "@kitbag/query",
   "private": false,
-  "version": "0.0.1-beta.2",
+  "version": "0.0.1-beta.5",
   "type": "module",
   "scripts": {
     "build": "vite build",
+    "build:watch": "vite build --watch --minify=false",
     "test": "vitest --typecheck",
     "types": "tsc --noEmit",
     "lint": "eslint ./src",
-    "lint:fix": "eslint ./src --fix"
+    "lint:fix": "eslint ./src --fix",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "docs:generate": "vite build && typedoc && sleep 5 && node ./scripts/api.js"
   },
   "keywords": [
     "typescript",
@@ -45,6 +50,7 @@
     "typescript": "^5.8.3",
     "vite": "^7.0.5",
     "vite-plugin-dts": "^4.5.4",
+    "vitepress": "^1.6.3",
     "vitest": "^3.2.4"
   }
 }
diff --git a/src/createQueryClient.spec.ts b/src/createQueryClient.spec.ts
index 5f06b58..484ff8c 100644
--- a/src/createQueryClient.spec.ts
+++ b/src/createQueryClient.spec.ts
@@ -465,6 +465,32 @@ describe('useQuery', () => {
       expect(query.errored).toBe(true)
     })
   })
+
+  describe('retries', () => {
+    test('retries the action', async () => {
+      const action = vi.fn(() => {
+        throw new Error('Expected error')
+      })
+
+      const { useQuery } = createQueryClient()
+
+      const result = useQuery(action, () => [], { retries: { count: 1, delay: 100 } })
+
+      await vi.advanceTimersByTimeAsync(0)
+
+      expect(action).toHaveBeenCalledTimes(1)
+      expect(result.error).toBeUndefined()
+      expect(result.errored).toBe(false)
+      expect(result.executed).toBe(false)
+
+      await vi.advanceTimersByTimeAsync(100)
+
+      expect(action).toHaveBeenCalledTimes(2)
+      expect(result.error).toBeDefined()
+      expect(result.errored).toBe(true)
+      expect(result.executed).toBe(true)
+    })
+  })
 })
 
 describe('defineQuery', () => {
diff --git a/src/main.ts b/src/main.ts
index 0bdb290..2997f67 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -1,11 +1,24 @@
 import { createQueryClient } from './createQueryClient'
 import { tag } from './tag'
 
+import { QueryClient, QueryFunction, DefinedQueryFunction, UseQueryOptions, QueryComposition, DefinedQueryComposition, DefineQuery, DefinedQuery, QueryDataSetter, SetQueryData, RefreshQueryData } from './types/client'
+import { ClientOptions } from './types/clientOptions'
+import { MutationAction, MutationData, MutationTagsContext, MutationTagsBeforeContext, MutationTagsAfterContext, MutationTags, MutationTagsType, OnExecuteContext, OnSuccessContext, SetQueryDataBeforeContext, SetQueryDataAfterContext, OnErrorContext, MutationOptions, Mutation, AwaitedMutation, MutationFunction, DefinedMutationFunction, MutationComposition, DefinedMutationComposition, DefinedMutation, DefineMutation } from './types/mutation'
+import { QueryAction, QueryData, QueryActionArgs, QueryTags, QueryOptions, Query, AwaitedQuery } from './types/query'
+import { QueryTag, QueryTagType, QueryTagCallback, QueryTagFactory } from './types/tags'
+
 const { query, useQuery } = createQueryClient()
 
 export {
-  query,
-  useQuery,
   createQueryClient,
-  tag
+  tag,
+  query, useQuery
+}
+
+export type {
+  QueryClient, QueryFunction, DefinedQueryFunction, UseQueryOptions, QueryComposition, DefinedQueryComposition, DefineQuery, DefinedQuery, QueryDataSetter, SetQueryData, RefreshQueryData,
+  ClientOptions,
+  MutationAction, MutationData, MutationTagsContext, MutationTagsBeforeContext, MutationTagsAfterContext, MutationTags, MutationTagsType, OnExecuteContext, OnSuccessContext, SetQueryDataBeforeContext, SetQueryDataAfterContext, OnErrorContext, MutationOptions, Mutation, AwaitedMutation, MutationFunction, DefinedMutationFunction, MutationComposition, DefinedMutationComposition, DefinedMutation, DefineMutation,
+  QueryAction, QueryData, QueryActionArgs, QueryTags, QueryOptions, Query, AwaitedQuery,
+  QueryTag, QueryTagType, QueryTagCallback, QueryTagFactory
 }
diff --git a/vite.config.js b/vite.config.js
index 16c9f4d..7d1757a 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -23,22 +23,22 @@ export default defineConfig({
       name: '@kitbag/query',
       fileName: 'kitbag-query',
     },
+    rollupOptions: {
+      external: ['vue'],
+      output: {
+        globals: {
+          vue: 'Vue',
+        },
+      },
+    },
   },
   plugins: [
     vue(),
-    dts({ 
-      rollupTypes: true 
-    })
+    dts({
+      rollupTypes: true,
+    }),
   ],
   esbuild: {
-    target: 'es2022'
-  },
-  rollupOptions: {
-    external: ['vue'],
-    output: {
-      globals: {
-        vue: 'Vue',
-      },
-    },
+    target: 'es2022',
   },
-})
\ No newline at end of file
+})