nuxt-ai-ready 0.2.4 → 0.3.1

package/README.md

@@ -4,7 +4,7 @@
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
 [![Nuxt][nuxt-src]][nuxt-href]
 
-> Best practice AI & LLM discoverability for Nuxt sites 
+> Best practice AI & LLM discoverability for Nuxt sites
 
 ## Why Nuxt AI Ready?
 
@@ -27,6 +27,7 @@ Nuxt AI Ready converts your indexable pages into clean markdown that AI systems
 - 🌐 **Indexable Pages**: Integrating with [Nuxt Sitemap](https://nuxtseo.com/sitemap) to index only AI-allowed pages
 - 📦 **Bulk Chunk Export**: Exported token optimized chunks ready for RAG and semantic search
 - ⚡ **MCP Integration**: Let AI agents query your site directly
+- ⏱️ **Automatic Last Updated**: Content freshness automatically tracked and added to your [sitemap.xml](https://nuxtseo.com/docs/ai-ready/guides/automatic-updated-at)
 
 ## Installation
 

package/dist/module.json

@@ -4,7 +4,7 @@
     "nuxt": ">=4.0.0"
   },
   "configKey": "aiReady",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,17 +1,118 @@
-import { useLogger, useNuxt, defineNuxtModule, createResolver, addTypeTemplate, hasNuxtModule, addServerHandler, addPlugin } from '@nuxt/kit';
+import { dirname, join } from 'node:path';
+import { useLogger, useNuxt, defineNuxtModule, createResolver, addTypeTemplate, hasNuxtModule, addServerHandler, addPlugin, extendPages } from '@nuxt/kit';
 import defu from 'defu';
 import { useSiteConfig, installNuxtSiteConfig, withSiteUrl } from 'nuxt-site-config/kit';
 import { relative } from 'pathe';
 import { readPackageJSON } from 'pkg-types';
 import { createHash } from 'node:crypto';
 import { mkdirSync, createWriteStream } from 'node:fs';
-import { stat, open } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
+import { mkdir, stat, open } from 'node:fs/promises';
 import { encodeLines } from '@toon-format/toon';
 import { createLlmsTxtStream } from 'mdream/llms-txt';
+import { createStorage } from 'unstorage';
+import fsDriver from 'unstorage/drivers/fs';
 
 const logger = useLogger("nuxt-ai-ready");
 
+function createContentHashManager(options) {
+  const { storagePath, debug = false } = options;
+  let storage;
+  let manifest = {
+    pages: {},
+    version: "1"
+  };
+  async function initStorage() {
+    await mkdir(dirname(storagePath), { recursive: true });
+    storage = createStorage({
+      driver: fsDriver({ base: dirname(storagePath) })
+    });
+  }
+  function hashContent(markdown) {
+    return createHash("sha256").update(markdown).digest("hex");
+  }
+  async function getManifest() {
+    if (!storage) {
+      await initStorage();
+    }
+    const stored = await storage.getItem("content-hashes.json");
+    if (stored) {
+      manifest = stored;
+      if (debug) {
+        logger.debug(`Loaded manifest with ${Object.keys(manifest.pages).length} pages`);
+      }
+    } else {
+      if (debug) {
+        logger.debug("No existing manifest found, starting fresh");
+      }
+    }
+    return manifest;
+  }
+  async function saveManifest() {
+    if (!storage) {
+      await initStorage();
+    }
+    await storage.setItem("content-hashes.json", manifest);
+    if (debug) {
+      logger.debug(`Saved manifest with ${Object.keys(manifest.pages).length} pages`);
+    }
+  }
+  function updatePageHash(route, markdown, previousManifest) {
+    const contentHash = hashContent(markdown);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = previousManifest.pages[route];
+    let result;
+    if (!existing) {
+      result = {
+        contentHash,
+        updatedAt: now,
+        firstSeenAt: now
+      };
+      if (debug) {
+        logger.debug(`New page detected: ${route}`);
+      }
+    } else if (existing.contentHash !== contentHash) {
+      result = {
+        contentHash,
+        updatedAt: now,
+        firstSeenAt: existing.firstSeenAt
+      };
+      if (debug) {
+        logger.debug(`Content changed: ${route}`);
+      }
+    } else {
+      result = {
+        contentHash: existing.contentHash,
+        updatedAt: existing.updatedAt,
+        firstSeenAt: existing.firstSeenAt
+      };
+      if (debug) {
+        logger.debug(`Content unchanged: ${route}`);
+      }
+    }
+    manifest.pages[route] = result;
+    return result;
+  }
+  function setPageTimestamp(route, markdown, timestamp, previousManifest) {
+    const contentHash = hashContent(markdown);
+    const existing = previousManifest.pages[route];
+    manifest.pages[route] = {
+      contentHash,
+      updatedAt: timestamp,
+      firstSeenAt: existing?.firstSeenAt || timestamp
+    };
+    if (debug) {
+      logger.debug(`Manual timestamp set for ${route}: ${timestamp}`);
+    }
+  }
+  return {
+    getManifest,
+    saveManifest,
+    hashContent,
+    updatePageHash,
+    setPageTimestamp
+  };
+}
+
 function generateVectorId(route, chunkIdx) {
   const hash = createHash("sha256").update(route).digest("hex").substring(0, 8);
   return `${hash}-${chunkIdx}`;
@@ -30,7 +131,7 @@ async function updateFirstLine(filePath, newFirstLine) {
     await fh.close();
   }
 }
-function setupPrerenderHandler(llmsTxtConfig) {
+function setupPrerenderHandler(llmsTxtConfig, timestampsConfig) {
   const nuxt = useNuxt();
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     let writer = null;
@@ -41,6 +142,18 @@ function setupPrerenderHandler(llmsTxtConfig) {
     const startTime = Date.now();
     const pagesChunksPath = join(nitro.options.output.publicDir, "llms-full.toon");
     const pagesPath = join(nitro.options.output.publicDir, "llms.toon");
+    let contentHashManager = null;
+    let previousManifest = null;
+    if (timestampsConfig?.enabled) {
+      const manifestPath = join(
+        nuxt.options.rootDir,
+        timestampsConfig.manifestPath || "node_modules/.cache/nuxt-seo/ai-index/content-hashes.json"
+      );
+      contentHashManager = createContentHashManager({
+        storagePath: manifestPath,
+        debug: !!nuxt.options.debug
+      });
+    }
     nitro.hooks.hook("prerender:generate", async (route) => {
       if (!route.fileName?.endsWith(".md")) {
         return;
@@ -61,15 +174,39 @@ function setupPrerenderHandler(llmsTxtConfig) {
           notes: llmsTxtConfig.notes
         });
         writer = stream.getWriter();
+        if (contentHashManager && !previousManifest) {
+          previousManifest = await contentHashManager.getManifest();
+        }
         mkdirSync(dirname(pagesChunksPath), { recursive: true });
         mkdirSync(dirname(pagesPath), { recursive: true });
         chunksStream = createWriteStream(pagesChunksPath, { encoding: "utf-8" });
         chunksStream.write("pageChunks[999999]{id,route,content}:\n");
         pagesStream = createWriteStream(pagesPath, { encoding: "utf-8" });
-        pagesStream.write("pages[999999]{route,title,description,headings,chunkIds}:\n");
+        pagesStream.write("pages[999999]{route,title,description,headings,chunkIds,updatedAt}:\n");
       }
-      const { chunks, title, description, headings } = JSON.parse(route.contents || "{}");
+      const { chunks, title, description, headings, updatedAt: metaUpdatedAt } = JSON.parse(route.contents || "{}");
       const markdown = chunks.map((c) => c.content).join("\n\n");
+      let pageTimestamp = {
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      let usedMetaTimestamp = false;
+      if (metaUpdatedAt) {
+        const parsedDate = new Date(metaUpdatedAt);
+        if (!Number.isNaN(parsedDate.getTime())) {
+          pageTimestamp.updatedAt = parsedDate.toISOString();
+          usedMetaTimestamp = true;
+          if (contentHashManager && previousManifest) {
+            contentHashManager.setPageTimestamp(pageRoute, markdown, pageTimestamp.updatedAt, previousManifest);
+          }
+        }
+      }
+      if (!usedMetaTimestamp && contentHashManager && previousManifest) {
+        pageTimestamp = contentHashManager.updatePageHash(
+          pageRoute,
+          markdown,
+          previousManifest
+        );
+      }
       await writer.write({
         url: pageRoute,
         title,
@@ -121,7 +258,8 @@ function setupPrerenderHandler(llmsTxtConfig) {
           ([tag, texts]) => texts.map((text) => `${tag}:${text}`)
         ).join("|") : "",
         // Join chunkIds array to comma-separated string
-        chunkIds: chunkIds.join(",")
+        chunkIds: chunkIds.join(","),
+        updatedAt: pageTimestamp.updatedAt
       };
       if (pagesStream) {
         const lines = Array.from(encodeLines({ pages: [pageDoc] }));
@@ -152,7 +290,11 @@ function setupPrerenderHandler(llmsTxtConfig) {
         });
       }
       await updateFirstLine(pagesChunksPath, `pageChunks[${chunksProcessed}]{id,route,content}:`);
-      await updateFirstLine(pagesPath, `pages[${pageCount}]{route,title,description,headings,chunkIds}:`);
+      await updateFirstLine(pagesPath, `pages[${pageCount}]{route,title,description,headings,chunkIds,updatedAt}:`);
+      if (contentHashManager) {
+        await contentHashManager.saveManifest();
+        logger.debug("Saved content hash manifest");
+      }
       logger.info(`Wrote llms-full.toon with ${chunksProcessed} chunks`);
       logger.info(`Wrote llms.toon with ${pageCount} pages`);
       const llmsTxtPath = join(nitro.options.output.publicDir, "llms.txt");
@@ -196,6 +338,23 @@ function setupPrerenderHandler(llmsTxtConfig) {
   });
 }
 
+function createPagesPromise(nuxt = useNuxt()) {
+  return new Promise((resolve) => {
+    nuxt.hooks.hook("modules:done", () => {
+      if (typeof nuxt.options.pages === "boolean" && !nuxt.options.pages || typeof nuxt.options.pages === "object" && !nuxt.options.pages.enabled) {
+        return resolve([]);
+      }
+      extendPages(resolve);
+    });
+  });
+}
+function flattenPages(pages, parent = "") {
+  return pages.flatMap((page) => {
+    const path = parent + page.path;
+    const current = { path, name: page.name, meta: page.meta };
+    return page.children?.length ? [current, ...flattenPages(page.children, path)] : [current];
+  });
+}
 const module$1 = defineNuxtModule({
   meta: {
     name: "nuxt-ai-ready",
@@ -227,6 +386,10 @@ const module$1 = defineNuxtModule({
         maxAge: 3600,
         // 1 hour
         swr: true
+      },
+      timestamps: {
+        enabled: false,
+        manifestPath: "node_modules/.cache/nuxt-seo/ai-index/content-hashes.json"
       }
     };
   },
@@ -247,9 +410,17 @@ const module$1 = defineNuxtModule({
     }
     nuxt.options.nitro.scanDirs = nuxt.options.nitro.scanDirs || [];
     nuxt.options.nitro.scanDirs.push(
-      resolve("./runtime/server/utils"),
-      resolve("./runtime/server/mcp")
+      resolve("./runtime/server/utils")
     );
+    const pagesPromise = createPagesPromise(nuxt);
+    nuxt.hooks.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.virtual = nitroConfig.virtual || {};
+      nitroConfig.virtual["#ai-ready/routes.mjs"] = async () => {
+        const pages = await pagesPromise;
+        const routes = flattenPages(pages);
+        return `export default ${JSON.stringify(routes)}`;
+      };
+    });
     if (typeof config.contentSignal === "object") {
       nuxt.options.robots.groups.push({
         userAgent: "*",
@@ -305,22 +476,12 @@ export {}
     const hasMCP = hasNuxtModule("@nuxtjs/mcp-toolkit");
     if (hasMCP) {
       nuxt.hook("mcp:definitions:paths", (paths) => {
-        const mcpRuntimeDir = resolve("./runtime/server/mcp");
-        paths.tools = paths.tools || [];
-        paths.resources = paths.resources || [];
-        paths.prompts = paths.prompts || [];
+        const mcpRuntimeDir = resolve(`./runtime/server/mcp/${nuxt.options.dev ? "dev" : "prod"}`);
         const mcpConfig = config.mcp || {};
-        const toolsConfig = mcpConfig.tools ?? {};
-        const resourcesConfig = mcpConfig.resources ?? {};
-        if (toolsConfig.listPages !== false) {
-          paths.tools.push(`${mcpRuntimeDir}/tools/list-pages.ts`);
-        }
-        if (resourcesConfig.pages !== false) {
-          paths.resources.push(`${mcpRuntimeDir}/resources/pages.ts`);
-        }
-        if (resourcesConfig.pagesChunks !== false) {
-          paths.resources.push(`${mcpRuntimeDir}/resources/pages-chunks.ts`);
-        }
+        if (mcpConfig.tools !== false)
+          (paths.tools ||= []).push(`${mcpRuntimeDir}/tools`);
+        if (mcpConfig.resources !== false)
+          (paths.resources ||= []).push(`${mcpRuntimeDir}/resources`);
       });
       const mcpLink = {
         title: "MCP",
@@ -350,16 +511,25 @@ export {}
     await nuxt.callHook("ai-ready:llms-txt", llmsTxtPayload);
     mergedLlmsTxt.sections = llmsTxtPayload.sections;
     mergedLlmsTxt.notes = llmsTxtPayload.notes.length > 0 ? llmsTxtPayload.notes : void 0;
+    const timestampsManifestPath = config.timestamps?.enabled ? join(nuxt.options.rootDir, config.timestamps.manifestPath || "node_modules/.cache/nuxt-seo/ai-index/content-hashes.json") : void 0;
     nuxt.options.runtimeConfig["nuxt-ai-ready"] = {
       version: version || "0.0.0",
       debug: config.debug || false,
+      hasSitemap: hasNuxtModule("@nuxtjs/sitemap"),
       mdreamOptions: config.mdreamOptions || {},
       markdownCacheHeaders: defu(config.markdownCacheHeaders, {
         maxAge: 3600,
         swr: true
       }),
-      llmsTxt: mergedLlmsTxt
+      llmsTxt: mergedLlmsTxt,
+      timestampsManifestPath
     };
+    if (config.timestamps?.enabled && hasNuxtModule("@nuxtjs/sitemap")) {
+      nuxt.hook("nitro:config", (nitroConfig) => {
+        nitroConfig.plugins = nitroConfig.plugins || [];
+        nitroConfig.plugins.push(resolve("./runtime/server/plugins/sitemap-lastmod"));
+      });
+    }
     addServerHandler({
       middleware: true,
       handler: resolve("./runtime/server/middleware/mdream")
@@ -371,7 +541,7 @@ export {}
     addServerHandler({ route: "/llms-full.txt", handler: resolve("./runtime/server/routes/llms.txt.get") });
     const isStatic = nuxt.options.nitro.static || nuxt.options._generate || false;
     if (isStatic || nuxt.options.nitro.prerender?.routes?.length) {
-      setupPrerenderHandler(mergedLlmsTxt);
+      setupPrerenderHandler(mergedLlmsTxt, config.timestamps);
     }
     nuxt.options.nitro.routeRules = nuxt.options.nitro.routeRules || {};
     nuxt.options.nitro.routeRules["/llms.toon"] = { headers: { "Content-Type": "text/toon; charset=utf-8" } };

package/dist/runtime/nuxt/plugins/prerender.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/server/mcp/dev/resources/pages.js

@@ -0,0 +1,19 @@
+import { getDevPages } from "../utils.js";
+export default {
+  uri: "resource://nuxt-ai-ready/pages",
+  name: "All Pages",
+  description: "Page routes from sitemap/routes. In dev mode, returns JSON (TOON format unavailable until build).",
+  metadata: {
+    mimeType: "application/json"
+  },
+  async handler(uri) {
+    const pages = await getDevPages();
+    return {
+      contents: [{
+        uri: uri.toString(),
+        mimeType: "application/json",
+        text: JSON.stringify(pages, null, 2)
+      }]
+    };
+  }
+};

package/dist/runtime/server/mcp/dev/tools/list-pages.js

@@ -0,0 +1,10 @@
+import { getDevPages, jsonResult } from "../utils.js";
+export default {
+  name: "list_pages",
+  description: "Lists all available pages with their routes. In dev mode, returns JSON from sitemap/routes (TOON format unavailable until build).",
+  inputSchema: {},
+  async handler() {
+    const pages = await getDevPages();
+    return jsonResult(pages);
+  }
+};

package/dist/runtime/server/mcp/dev/utils.js

@@ -0,0 +1,22 @@
+import routes from "#ai-ready/routes.mjs";
+import { useRuntimeConfig } from "nitropack/runtime";
+export { jsonResult } from "../utils.js";
+export async function getDevPages() {
+  const config = useRuntimeConfig()["nuxt-ai-ready"];
+  if (!config.hasSitemap)
+    return routes.map((r) => ({ route: r.path, name: r.name, meta: r.meta }));
+  const { parseSitemapXml } = await import("@nuxtjs/sitemap/utils");
+  const sitemapRes = await fetch("/sitemap.xml");
+  if (!sitemapRes.ok)
+    return routes.map((r) => ({ route: r.path, name: r.name, meta: r.meta }));
+  const xml = await sitemapRes.text();
+  const { urls } = await parseSitemapXml(xml);
+  return urls.map((entry) => {
+    if (typeof entry === "string")
+      return { route: new URL(entry).pathname };
+    return {
+      route: new URL(entry.loc).pathname,
+      lastmod: entry.lastmod
+    };
+  });
+}

package/dist/runtime/server/mcp/{tools → prod/tools}/list-pages.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { toonResult } from "../utils.js";
+import { toonResult } from "../../utils.js";
 const schema = {
   mode: z.enum(["chunks", "minimal"]).default("minimal").describe("Return individual content chunks (chunks) or page-level metadata (minimal)")
 };

package/dist/runtime/server/plugins/sitemap-lastmod.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/sitemap-lastmod.js

@@ -0,0 +1,22 @@
+import { readFile } from "node:fs/promises";
+import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
+export default defineNitroPlugin((nitroApp) => {
+  const config = useRuntimeConfig();
+  const manifestPath = config["nuxt-ai-ready"]?.timestampsManifestPath;
+  if (!manifestPath) {
+    return;
+  }
+  nitroApp.hooks.hook("sitemap:resolved", async (ctx) => {
+    const manifest = await readFile(manifestPath, "utf-8").then((data) => JSON.parse(data)).catch(() => null);
+    if (!manifest) {
+      return;
+    }
+    for (const url of ctx.urls) {
+      const route = url.loc.replace(/^https?:\/\/[^/]+/, "").replace(/\/$/, "") || "/";
+      const pageData = manifest.pages[route];
+      if (pageData?.updatedAt) {
+        url.lastmod = pageData.updatedAt;
+      }
+    }
+  });
+});

package/dist/runtime/server/utils.d.ts

@@ -1,7 +1,8 @@
 import type { ModulePublicRuntimeConfig } from '../../module.js';
 export declare function convertHtmlToMarkdownChunks(html: string, url: string, mdreamOptions: ModulePublicRuntimeConfig['mdreamOptions']): Promise<{
+    headings: Record<string, string[]>;
+    updatedAt?: string | undefined;
     chunks: import("mdream").MarkdownChunk[];
     title: string;
     description: string;
-    headings: Record<string, string[]>;
 }>;

package/dist/runtime/server/utils.js

@@ -6,12 +6,19 @@ import { estimateTokenCount } from "tokenx";
 export async function convertHtmlToMarkdownChunks(html, url, mdreamOptions) {
   let title = "";
   let description = "";
+  let updatedAt;
   const extractPlugin = extractionPlugin({
     title(el) {
       title = el.textContent;
     },
     'meta[name="description"]': (el) => {
       description = el.attributes.content || "";
+    },
+    // Extract timestamp from various meta tag formats
+    'meta[property="article:modified_time"], meta[name="last-modified"], meta[name="updated"], meta[property="og:updated_time"], meta[name="lastmod"]': (el) => {
+      if (!updatedAt && el.attributes.content) {
+        updatedAt = el.attributes.content;
+      }
     }
   });
   let options = {
@@ -38,13 +45,19 @@ export async function convertHtmlToMarkdownChunks(html, url, mdreamOptions) {
   for await (const chunk of chunksStream) {
     chunks.push(chunk);
   }
-  return { chunks, title, description, headings: chunks.reduce((set, m) => {
-    Object.entries(m.metadata?.headers || {}).forEach(([k, v]) => {
-      if (!set[k])
-        set[k] = [];
-      if (v && !set[k].includes(v))
-        set[k].push(v);
-    });
-    return set;
-  }, {}) };
+  return {
+    chunks,
+    title,
+    description,
+    ...updatedAt && { updatedAt },
+    headings: chunks.reduce((set, m) => {
+      Object.entries(m.metadata?.headers || {}).forEach(([k, v]) => {
+        if (!set[k])
+          set[k] = [];
+        if (v && !set[k].includes(v))
+          set[k].push(v);
+      });
+      return set;
+    }, {})
+  };
 }

package/dist/runtime/types.d.ts

@@ -63,24 +63,25 @@ export interface ModuleOptions {
      * @default All enabled when @nuxtjs/mcp-toolkit is installed
      */
     mcp?: {
+        /** Enable MCP tools (list-pages) @default true */
+        tools?: boolean;
+        /** Enable MCP resources (pages, pages-chunks) @default true */
+        resources?: boolean;
+    };
+    /**
+     * Content timestamp tracking configuration
+     */
+    timestamps?: {
         /**
-         * Enable/disable specific MCP tools
-         * @default All tools enabled
+         * Enable timestamp tracking
+         * @default false
          */
-        tools?: {
-            /** Get page by route - fetches markdown content for specific page */
-            listPages?: boolean;
-        };
+        enabled?: boolean;
         /**
-         * Enable/disable specific MCP resources
-         * @default All resources enabled
+         * Path to store content hash manifest
+         * @default 'node_modules/.cache/nuxt-seo/ai-index/content-hashes.json'
          */
-        resources?: {
-            /** pages://list - all pages without markdown content */
-            pages?: boolean;
-            /** pages://chunks - individual content chunks from all pages */
-            pagesChunks?: boolean;
-        };
+        manifestPath?: string;
     };
 }
 /**
@@ -112,6 +113,8 @@ export interface BulkDocument {
     headings: Array<Record<string, string>>;
     /** All chunk IDs for this page (first ID can be used as document ID) */
     chunkIds: string[];
+    /** ISO 8601 timestamp of last content update */
+    updatedAt?: string;
 }
 /**
  * Hook context for markdown processing (Nitro runtime hook)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",
@@ -43,10 +43,11 @@
     "pkg-types": "^2.3.0",
     "std-env": "^3.10.0",
     "tokenx": "^1.2.1",
-    "ufo": "^1.6.1"
+    "ufo": "^1.6.1",
+    "unstorage": "^1.17.3"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^6.4.1",
+    "@antfu/eslint-config": "^6.4.2",
     "@arethetypeswrong/cli": "^0.18.2",
     "@headlessui/vue": "^1.7.23",
     "@nuxt/content": "^3.9.0",
@@ -75,7 +76,7 @@
     "vitest": "^4.0.15",
     "vue": "^3.5.25",
     "vue-router": "^4.6.3",
-    "vue-tsc": "^3.1.5",
+    "vue-tsc": "^3.1.6",
     "zod": "^4.1.13"
   },
   "resolutions": {

package/dist/runtime/server/mcp/resources/pages-chunks.d.ts

@@ -1,17 +0,0 @@
-declare const _default: {
-    uri: string;
-    name: string;
-    description: string;
-    metadata: {
-        mimeType: string;
-    };
-    cache: "1h";
-    handler(uri: URL): Promise<{
-        contents: {
-            uri: string;
-            mimeType: string;
-            text: string;
-        }[];
-    }>;
-};
-export default _default;

package/dist/runtime/server/mcp/resources/pages.d.ts

@@ -1,17 +0,0 @@
-declare const _default: {
-    uri: string;
-    name: string;
-    description: string;
-    metadata: {
-        mimeType: string;
-    };
-    cache: "1h";
-    handler(uri: URL): Promise<{
-        contents: {
-            uri: string;
-            mimeType: string;
-            text: string;
-        }[];
-    }>;
-};
-export default _default;

package/dist/runtime/server/mcp/tools/list-pages.d.ts

@@ -1,86 +0,0 @@
-import { z } from 'zod';
-/**
- * Lists all pages by fetching and returning TOON-encoded data
- * TOON (Token-Oriented Object Notation) is a compact encoding that minimizes tokens for LLM input
- * See https://toonformat.dev
- */
-declare const _default: {
-    name: string;
-    description: string;
-    inputSchema: {
-        mode: z.ZodDefault<z.ZodEnum<{
-            minimal: "minimal";
-            chunks: "chunks";
-        }>>;
-    };
-    cache: "1h";
-    handler({ mode }: import("@modelcontextprotocol/sdk/server/zod-compat.js").ShapeOutput<Readonly<{
-        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-    }>>): Promise<{
-        [x: string]: unknown;
-        content: ({
-            type: "text";
-            text: string;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        } | {
-            type: "image";
-            data: string;
-            mimeType: string;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        } | {
-            type: "audio";
-            data: string;
-            mimeType: string;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        } | {
-            uri: string;
-            name: string;
-            type: "resource_link";
-            description?: string | undefined;
-            mimeType?: string | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-            }[] | undefined;
-            title?: string | undefined;
-        } | {
-            type: "resource";
-            resource: {
-                uri: string;
-                text: string;
-                mimeType?: string | undefined;
-                _meta?: {
-                    [x: string]: unknown;
-                } | undefined;
-            } | {
-                uri: string;
-                blob: string;
-                mimeType?: string | undefined;
-                _meta?: {
-                    [x: string]: unknown;
-                } | undefined;
-            };
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        })[];
-        _meta?: {
-            [x: string]: unknown;
-        } | undefined;
-        structuredContent?: {
-            [x: string]: unknown;
-        } | undefined;
-        isError?: boolean | undefined;
-    }>;
-};
-export default _default;