nuxt-ai-ready 2.3.4 → 2.4.0

package/dist/chunks/prerender.mjs

@@ -10,6 +10,7 @@ import { normalizePagePath, toMarkdownPath } from '../../dist/runtime/markdown-p
 import { toDeployedRoute, toLogicalRoute } from '../../dist/runtime/route-path.js';
 import { initSchema, computeContentHash, insertPage, queryAllPages, exportDbDump } from '../../dist/runtime/server/db/shared.js';
 import { buildLlmsFullTxtHeader, formatPageForLlmsFullTxt } from '../../dist/runtime/server/utils/llms-full.js';
+import { resolvePageUpdatedAt } from '../../dist/runtime/server/utils/page-updated-at.js';
 import { SITEMAP_MD_ROUTE, appendSitemapSection } from '../../dist/runtime/server/utils/sitemap-md.js';
 import 'node:crypto';
 import 'node:module';
@@ -150,12 +151,7 @@ function resolveRouteLocale(route, i18n) {
 async function processMarkdownRoute(state, nuxt, route, parsed, lastmod, options) {
   route = normalizePagePath(route);
   const { title, description, headings, keywords, updatedAt: metaUpdatedAt } = parsed;
-  let updatedAt = (lastmod instanceof Date ? lastmod.toISOString() : lastmod) || (/* @__PURE__ */ new Date()).toISOString();
-  if (metaUpdatedAt) {
-    const parsedDate = new Date(metaUpdatedAt);
-    if (!Number.isNaN(parsedDate.getTime()))
-      updatedAt = parsedDate.toISOString();
-  }
+  const updatedAt = resolvePageUpdatedAt(lastmod, metaUpdatedAt);
   const hookContext = { ...parsed, route };
   await nuxt.hooks.callHook("ai-ready:page:markdown", hookContext);
   const { markdown } = hookContext;
@@ -353,7 +349,7 @@ function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, extras
             markdown: "",
             headings: "",
             keywords: [],
-            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            updatedAt: "",
             isError: true,
             locale: resolveRouteLocale(route, state.i18n)
           });

package/dist/module.json

@@ -4,7 +4,7 @@
     "nuxt": ">=4.0.0"
   },
   "configKey": "aiReady",
-  "version": "2.3.4",
+  "version": "2.4.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"

package/dist/runtime/server/db/drizzle/queries.js

@@ -675,7 +675,6 @@ export async function seedRoutes(event, routes, options = {}) {
   if (routes.length === 0)
     return 0;
   const refreshWindowMs = Math.max(0, Math.trunc(Number.isFinite(options.refreshWindowMs) ? options.refreshWindowMs : SEED_REFRESH_WINDOW_MS));
-  const now = (/* @__PURE__ */ new Date()).toISOString();
   const nowMs = Date.now();
   const byRoute = /* @__PURE__ */ new Map();
   for (const entry of routes) {
@@ -688,14 +687,14 @@ export async function seedRoutes(event, routes, options = {}) {
       locale: deriveLocale(event, route, explicitLocale, entryUrl)
     });
   }
-  const rowsPerInsert = maxRowsPerInsert(5);
+  const rowsPerInsert = maxRowsPerInsert(4);
   const db = await useRawDb(event);
   const entries = [...byRoute.values()];
   const stmts = [];
   for (let i = 0; i < entries.length; i += rowsPerInsert) {
     const batch = entries.slice(i, i + rowsPerInsert);
-    const valuesSql = batch.map(() => `(?, ?, '', '', '', '[]', '[]', ?, 0, 0, 0, 'runtime', ?, ?)`).join(", ");
-    const params = batch.flatMap((r) => [r.route, r.routeKey, now, nowMs, r.locale]);
+    const valuesSql = batch.map(() => `(?, ?, '', '', '', '[]', '[]', '', 0, 0, 0, 'runtime', ?, ?)`).join(", ");
+    const params = batch.flatMap((r) => [r.route, r.routeKey, nowMs, r.locale]);
     stmts.push({
       sql: `
         INSERT INTO ai_ready_pages (route, route_key, title, description, markdown, headings, keywords, updated_at, indexed_at, is_error, indexed, source, last_seen_at, locale)

package/dist/runtime/server/db/queries.d.ts

@@ -124,6 +124,8 @@ export declare function isPageFresh(event: H3Event | undefined, route: string, t
 export interface PageIndexState {
     indexedAt: number;
     contentHash: string | null;
+    updatedAt: string;
+    source: 'prerender' | 'runtime';
 }
 /**
  * Fetch a page's index bookkeeping in one lightweight query.

package/dist/runtime/server/db/queries.js

@@ -324,10 +324,15 @@ export async function getPageIndexState(event, route) {
   if (!db)
     return void 0;
   const row = await db.first(
-    "SELECT indexed_at, content_hash FROM ai_ready_pages WHERE route = ?",
+    "SELECT indexed_at, content_hash, updated_at, source FROM ai_ready_pages WHERE route = ?",
     [route]
   );
-  return row ? { indexedAt: toNumber(row.indexed_at), contentHash: row.content_hash } : void 0;
+  return row ? {
+    indexedAt: toNumber(row.indexed_at),
+    contentHash: row.content_hash,
+    updatedAt: row.updated_at || "",
+    source: row.source === "runtime" ? "runtime" : "prerender"
+  } : void 0;
 }
 export async function getPageHash(event, route) {
   const db = await getDb(event);
@@ -347,7 +352,6 @@ export async function seedRoutes(event, routes, options = {}) {
   if (!db || routes.length === 0)
     return 0;
   const refreshWindowMs = Math.max(0, Math.trunc(Number.isFinite(options.refreshWindowMs) ? options.refreshWindowMs : SEED_REFRESH_WINDOW_MS));
-  const now = (/* @__PURE__ */ new Date()).toISOString();
   const nowMs = Date.now();
   const byRoute = /* @__PURE__ */ new Map();
   for (const entry of routes) {
@@ -360,11 +364,11 @@ export async function seedRoutes(event, routes, options = {}) {
       locale: deriveLocale(event, route, explicitLocale, entryUrl)
     });
   }
-  const rowsPerInsert = maxRowsPerInsert(5);
+  const rowsPerInsert = maxRowsPerInsert(4);
   const stmts = [];
   for (const batch of chunk([...byRoute.values()], rowsPerInsert)) {
-    const valuesSql = batch.map(() => `(?, ?, '', '', '', '[]', '[]', ?, 0, 0, 0, 'runtime', ?, ?)`).join(", ");
-    const params = batch.flatMap((r) => [r.route, r.routeKey, now, nowMs, r.locale]);
+    const valuesSql = batch.map(() => `(?, ?, '', '', '', '[]', '[]', '', 0, 0, 0, 'runtime', ?, ?)`).join(", ");
+    const params = batch.flatMap((r) => [r.route, r.routeKey, nowMs, r.locale]);
     stmts.push({
       sql: `
         INSERT INTO ai_ready_pages (route, route_key, title, description, markdown, headings, keywords, updated_at, indexed_at, is_error, indexed, source, last_seen_at, locale)

package/dist/runtime/server/db/shared.d.ts

@@ -1,5 +1,8 @@
 /**
- * Compute content hash for change detection (first 16 chars of SHA-256)
+ * Compute content hash for change detection (first 16 chars of SHA-256).
+ * Hash the page body only. Frontmatter holds per-conversion fields
+ * (`canonical_url`, `last_updated`) that differ between the build and runtime
+ * paths, so hashing it marks unchanged pages as changed.
  */
 export declare function computeContentHash(markdown: string): Promise<string>;
 export interface DatabaseAdapter {

package/dist/runtime/server/db/shared.js

@@ -1,8 +1,21 @@
 import { subtle } from "uncrypto";
+import { isMap, isScalar, parseDocument } from "yaml";
 import { buildSchemaSql, DROP_TABLES_SQL, resolveFtsTokenizer, SCHEMA_VERSION } from "./schema-sql.js";
+const LEADING_BLOCK_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+const PAGE_FRONTMATTER_KEYS = /* @__PURE__ */ new Set(["title", "description", "meta", "canonical_url", "last_updated", "locale", "alternates"]);
+function stripPageFrontmatter(markdown) {
+  const match = markdown.match(LEADING_BLOCK_RE);
+  if (!match)
+    return markdown;
+  const document = parseDocument(match[1]);
+  if (document.errors.length || !isMap(document.contents))
+    return markdown;
+  const isPageFrontmatter = document.contents.items.some((item) => isScalar(item.key) && PAGE_FRONTMATTER_KEYS.has(String(item.key.value)));
+  return isPageFrontmatter ? markdown.slice(match[0].length) : markdown;
+}
 export async function computeContentHash(markdown) {
   const encoder = new TextEncoder();
-  const data = encoder.encode(markdown);
+  const data = encoder.encode(stripPageFrontmatter(markdown).trim());
   const hashBuffer = await subtle.digest("SHA-256", data);
   const hashArray = [...new Uint8Array(hashBuffer)];
   return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);

package/dist/runtime/server/middleware/markdown.js

@@ -1,8 +1,9 @@
-import { createError, defineEventHandler, setHeader, setResponseStatus } from "#nuxtseo/h3";
+import { createError, defineEventHandler, getRequestURL, setHeader, setResponseStatus } from "#nuxtseo/h3";
 import { useNitroApp, useRuntimeConfig } from "#nuxtseo/nitro";
 import { resolveLocaleAlternateUrl } from "../../i18n-url.js";
 import { logger } from "../logger.js";
 import { computeLocaleAlternates, resolveLocaleFromRoute } from "../utils/i18n.js";
+import { resolveMarkdownRedirect } from "../utils/markdown-redirect.js";
 import { INTERNAL_HEADER } from "../utils/negotiation-decision.js";
 import { applyNegotiation, buildNegotiationContext, decideNegotiation, ensureSiteConfig, setMarkdownHeaders } from "../utils/negotiation-response.js";
 import { appendSitemapSection, isSitemapMdRequest, SITEMAP_MD_ROUTE } from "../utils/sitemap-md.js";
@@ -30,7 +31,6 @@ function notFoundMarkdown(ctx, canonicalUrl, build) {
     title: "Page not found",
     description: `No content is available at ${path}.`,
     canonical_url: canonicalUrl,
-    last_updated: (/* @__PURE__ */ new Date()).toISOString(),
     locale,
     alternates
   });
@@ -67,7 +67,7 @@ export default defineEventHandler(async (event) => {
       title: title ?? path,
       description,
       canonical_url: canonicalUrl,
-      last_updated: updatedAt || (/* @__PURE__ */ new Date()).toISOString()
+      last_updated: updatedAt
     }, markdown);
     setMarkdownHeaders(event, ctx);
     return finalizeMarkdown(responseMarkdown);
@@ -82,37 +82,49 @@ export default defineEventHandler(async (event) => {
       title: contentPage.title,
       description: contentPage.description,
       canonical_url: canonicalUrl,
-      last_updated: contentPage.updatedAt || (/* @__PURE__ */ new Date()).toISOString()
+      last_updated: contentPage.updatedAt
     });
     setMarkdownHeaders(event, ctx);
     return finalizeMarkdown(`${frontmatter}
 ${contentPage.markdown}`);
   }
-  logger.debug(`[markdown] Fetching HTML for ${path}`);
-  const response = await fetchRawWithEvent(event, resolvePath(path), {
-    headers: { [INTERNAL_HEADER]: "1" },
-    redirect: "manual"
-  }).catch((e) => {
-    logger.error(`Failed to fetch HTML for ${path}`, e);
-    return null;
-  });
+  const origin = getRequestURL(event).origin;
+  const siteUrl = resolveUrl("/");
+  const redirectOptions = {
+    pageUrl: `${origin}${resolvePath(path)}`,
+    origins: URL.canParse(siteUrl) ? [new URL(siteUrl).origin] : []
+  };
+  let htmlPath = resolvePath(path);
+  let response = null;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    logger.debug(`[markdown] Fetching HTML for ${htmlPath}`);
+    response = await fetchRawWithEvent(event, htmlPath, {
+      headers: { [INTERNAL_HEADER]: "1" },
+      redirect: "manual"
+    }).catch((e) => {
+      logger.error(`Failed to fetch HTML for ${htmlPath}`, e);
+      return null;
+    });
+    const location = response && response.status >= 300 && response.status < 400 ? response.headers.get("location") : null;
+    if (!response || !location)
+      break;
+    const redirect = resolveMarkdownRedirect(location, redirectOptions);
+    if (redirect._tag === "follow" && attempt === 0) {
+      htmlPath = redirect.path;
+      continue;
+    }
+    setHeader(event, "location", redirect._tag === "redirect" ? redirect.location : location);
+    return createError({
+      statusCode: response.status,
+      statusMessage: response.statusText
+    });
+  }
   if (!response) {
     throw createError({
       statusCode: 502,
       statusMessage: "Bad Gateway"
     });
   }
-  if (response.status >= 300 && response.status < 400) {
-    const location = response.headers.get("location");
-    if (location) {
-      const redirectTarget = location.endsWith("/") ? `${location.slice(0, -1)}.md` : `${location}.md`;
-      setHeader(event, "location", redirectTarget);
-      return createError({
-        statusCode: response.status,
-        statusMessage: response.statusText
-      });
-    }
-  }
   if (!response.ok && response.status !== 404)
     return response;
   if (response.status === 404) {
@@ -139,11 +151,12 @@ ${contentPage.markdown}`);
     logger.debug(`[markdown] DB lookup failed for ${path}:`, err);
     return void 0;
   });
-  const lastUpdated = dbPage?.updatedAt || extractLastUpdated(html) || (/* @__PURE__ */ new Date()).toISOString();
+  const lastUpdated = dbPage?.updatedAt || extractLastUpdated(html);
   const additionalFrontmatter = {
-    canonical_url: canonicalUrl,
-    last_updated: lastUpdated
+    canonical_url: canonicalUrl
   };
+  if (lastUpdated)
+    additionalFrontmatter.last_updated = lastUpdated;
   if (config.i18n) {
     additionalFrontmatter.locale = resolveLocaleFromRoute(path, config.i18n, routeContext).locale;
   }

package/dist/runtime/server/middleware/markdown.prerender.js

@@ -45,12 +45,11 @@ export default defineEventHandler(async (event) => {
   });
   if (contentPage) {
     logger.debug(`[markdown.prerender] Using content source for ${path} (${contentPage.markdown.length} bytes)`);
-    const lastUpdated2 = contentPage.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
     const frontmatter = buildFrontmatter({
       title: contentPage.title,
       description: contentPage.description,
       canonical_url: canonicalUrl,
-      last_updated: lastUpdated2
+      last_updated: contentPage.updatedAt
     });
     const markdown = `${frontmatter}
 ${contentPage.markdown}`;
@@ -62,7 +61,8 @@ ${contentPage.markdown}`;
       description: contentPage.description || "",
       headings,
       keywords: keywords2,
-      updatedAt: lastUpdated2
+      // Only a real content date feeds the page index and sitemap lastmod.
+      ...contentPage.updatedAt && { updatedAt: contentPage.updatedAt }
     });
   }
   let html = consumePrerenderedHtml(path);
@@ -97,7 +97,7 @@ ${contentPage.markdown}`;
       message: `Page rendered as error: ${path}`
     });
   }
-  const lastUpdated = extractLastUpdated(html) || (/* @__PURE__ */ new Date()).toISOString();
+  const lastUpdated = extractLastUpdated(html);
   const result = await convertHtmlToMarkdown(
     html,
     canonicalUrl,
@@ -106,7 +106,7 @@ ${contentPage.markdown}`;
       extractUpdatedAt: true,
       additionalFrontmatter: {
         canonical_url: canonicalUrl,
-        last_updated: lastUpdated
+        ...lastUpdated && { last_updated: lastUpdated }
       }
     }
   );

package/dist/runtime/server/utils/indexPage.js

@@ -6,6 +6,7 @@ import { convertHtmlToMarkdown } from "../utils.js";
 import { createUniversalContext } from "./context.js";
 import { extractKeywords } from "./keywords.js";
 import { INTERNAL_HEADER } from "./negotiation-decision.js";
+import { resolveIndexedUpdatedAt, resolvePageUpdatedAt } from "./page-updated-at.js";
 export async function indexPage(route, html, options = {}, event) {
   const config = useRuntimeConfig()["nuxt-ai-ready"];
   const ttl = options.ttl ?? config.runtimeSync.ttl;
@@ -19,11 +20,17 @@ export async function indexPage(route, html, options = {}, event) {
   const { siteUrl } = createUniversalContext(event);
   const fullUrl = siteUrl ? `${siteUrl}${route}` : route;
   const result = await convertHtmlToMarkdown(html, fullUrl, config.mdreamOptions, { extractUpdatedAt: true });
-  const updatedAt = result.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
   const headings = JSON.stringify(result.headings);
   const keywords = extractKeywords(result.textContent, result.metaKeywords);
   const contentHash = await computeContentHash(result.markdown);
   const contentChanged = state?.contentHash !== contentHash;
+  const updatedAt = isError ? "" : resolveIndexedUpdatedAt({
+    declared: resolvePageUpdatedAt(void 0, result.updatedAt),
+    previous: state,
+    contentHash,
+    now: /* @__PURE__ */ new Date(),
+    detectDrift: config.runtimeSync.enabled
+  });
   await upsertPage(event, {
     route,
     title: result.title,
@@ -92,7 +99,7 @@ export async function indexPageByRoute(route, event, options = {}) {
         markdown: "",
         headings: "[]",
         keywords: [],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: "",
         isError: true
       });
     }

package/dist/runtime/server/utils/markdown-redirect.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What a `.md` request does with an upstream redirect of its HTML page.
+ *
+ * `redirect` sends the client to `location`. `follow` means the target is the
+ * same markdown document as the request, as with a trailing-slash redirect, so
+ * the handler converts the HTML at `path` instead of redirecting to itself.
+ */
+export type MarkdownRedirect = {
+    _tag: 'redirect';
+    location: string;
+} | {
+    _tag: 'follow';
+    path: string;
+};
+export interface MarkdownRedirectOptions {
+    /** Absolute URL of the HTML page that answered with the redirect. */
+    pageUrl: string;
+    /** Other origins that serve this site, such as the configured site URL. */
+    origins?: readonly string[];
+}
+/**
+ * Map an upstream `Location` onto the markdown sibling of its target.
+ *
+ * A target on another origin, or one without a markdown sibling, keeps its
+ * original location. Query and fragment carry over to the sibling.
+ */
+export declare function resolveMarkdownRedirect(location: string, { pageUrl, origins }: MarkdownRedirectOptions): MarkdownRedirect;

package/dist/runtime/server/utils/markdown-redirect.js

@@ -0,0 +1,18 @@
+import { markdownAlternatePath, toMarkdownPath } from "../../markdown-path.js";
+const RE_ABSOLUTE_URL = /^(?:[a-z][a-z\d+.-]*:|\/\/)/i;
+export function resolveMarkdownRedirect(location, { pageUrl, origins = [] }) {
+  const page = new URL(pageUrl);
+  const target = URL.canParse(location, page) ? new URL(location, page) : null;
+  if (!target || target.origin !== page.origin && !origins.includes(target.origin))
+    return { _tag: "redirect", location };
+  const markdownPath = markdownAlternatePath(target.pathname);
+  if (!markdownPath)
+    return { _tag: "redirect", location };
+  if (markdownPath === toMarkdownPath(page.pathname))
+    return { _tag: "follow", path: `${target.pathname}${target.search}` };
+  const markdownLocation = `${markdownPath}${target.search}${target.hash}`;
+  return {
+    _tag: "redirect",
+    location: RE_ABSOLUTE_URL.test(location) ? `${target.origin}${markdownLocation}` : markdownLocation
+  };
+}

package/dist/runtime/server/utils/page-updated-at.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Resolve when a page's content last changed, from sources that know it.
+ *
+ * Returns an empty string when no source gives a valid date. The index time is
+ * never a fallback: it moves on every deploy or re-index, so a sitemap lastmod
+ * built from it tells crawlers every page changed, and they learn to ignore it.
+ */
+export declare function resolvePageUpdatedAt(sitemapLastmod: string | Date | undefined, metaUpdatedAt: string | undefined): string;
+export interface StoredPageDate {
+    contentHash: string | null;
+    updatedAt: string;
+    source: 'prerender' | 'runtime';
+}
+export interface IndexedUpdatedAtInput {
+    /** Date the page declares itself, already resolved. Empty when none. */
+    declared: string;
+    /** The row before this index, if any. */
+    previous: StoredPageDate | undefined;
+    contentHash: string;
+    now: Date;
+    /** Only true when runtime indexing runs, so two indexes can be compared. */
+    detectDrift: boolean;
+}
+/**
+ * Date a runtime-indexed page. A declared date always wins. Otherwise a page
+ * gets the detection time only when its body hash differs from an earlier
+ * runtime index of the same page. A prerender hash comes from another pipeline,
+ * so a difference there proves nothing and never produces a date.
+ */
+export declare function resolveIndexedUpdatedAt(input: IndexedUpdatedAtInput): string;

package/dist/runtime/server/utils/page-updated-at.js

@@ -0,0 +1,21 @@
+function toIsoDate(value) {
+  if (!value)
+    return "";
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? "" : date.toISOString();
+}
+export function resolvePageUpdatedAt(sitemapLastmod, metaUpdatedAt) {
+  return toIsoDate(metaUpdatedAt) || toIsoDate(sitemapLastmod);
+}
+export function resolveIndexedUpdatedAt(input) {
+  if (input.declared)
+    return input.declared;
+  if (!input.detectDrift)
+    return "";
+  const { previous } = input;
+  if (!previous?.contentHash)
+    return "";
+  if (previous.source === "runtime" && previous.contentHash !== input.contentHash)
+    return input.now.toISOString();
+  return previous.updatedAt;
+}

package/dist/runtime/types.d.ts

@@ -452,7 +452,7 @@ export interface MarkdownSource {
     title?: string;
     /** Page description. */
     description?: string;
-    /** ISO timestamp for `last_updated`. Defaults to now. */
+    /** ISO timestamp for `last_updated`. Omitted when not set. */
     updatedAt?: string;
 }
 /**
@@ -536,7 +536,7 @@ export interface PageIndexedContext {
     keywords: string[];
     /** Full markdown content */
     markdown: string;
-    /** ISO timestamp */
+    /** ISO timestamp of the last content change from page meta. Empty string when the page gives none. */
     updatedAt: string;
     /** Whether this is a new page or an update */
     isUpdate: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "2.3.4",
+  "version": "2.4.0",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",
@@ -45,7 +45,7 @@
     "webmcp.d.ts"
   ],
   "peerDependencies": {
-    "@libsql/client": "^0.14.0",
+    "@libsql/client": "^0.18.0",
     "@neondatabase/serverless": "^1.0.0",
     "@nuxtjs/sitemap": ">=8.3.1",
     "better-sqlite3": "^11.0.0 || ^12.0.0 || ^13.0.0",
@@ -66,62 +66,62 @@
     }
   },
   "dependencies": {
-    "@mdream/js": "^1.7.1",
+    "@mdream/js": "^1.7.2",
     "@nuxt/kit": "^4.5.2",
     "citty": "^0.2.2",
     "consola": "^3.4.2",
     "defu": "^6.1.7",
     "drizzle-orm": "1.0.0-rc.4",
-    "mdream": "^1.7.1",
+    "mdream": "^1.7.2",
     "nuxt-site-config": "^4.2.3",
-    "nuxtseo-shared": "^5.3.15",
+    "nuxtseo-shared": "^5.3.16",
     "pathe": "^2.0.3",
-    "pkg-types": "^2.3.2",
+    "pkg-types": "^2.3.3",
     "site-config-stack": "^4.2.3",
     "sitemapd": "^0.2.2",
     "ufo": "^1.6.4",
     "uncrypto": "^0.1.3",
-    "yaml": "^2.9.0"
+    "yaml": "^2.9.1"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^9.5.1",
     "@arethetypeswrong/cli": "^0.18.5",
     "@harlan-zw/comark-content": "^0.1.5",
     "@libsql/client": "^0.18.0",
-    "@nuxt/content": "^3.16.0",
+    "@nuxt/content": "^3.16.1",
     "@nuxt/module-builder": "^1.0.3",
-    "@nuxt/test-utils": "^4.2.0",
+    "@nuxt/test-utils": "^4.3.2",
     "@nuxtjs/eslint-config-typescript": "^12.1.0",
-    "@nuxtjs/mcp-toolkit": "^0.19.0",
-    "@nuxtjs/robots": "^6.2.0",
-    "@nuxtjs/sitemap": "^8.5.0",
+    "@nuxtjs/mcp-toolkit": "^0.21.0",
+    "@nuxtjs/robots": "^6.2.3",
+    "@nuxtjs/sitemap": "^8.5.1",
     "@types/better-sqlite3": "^9.6.0",
-    "@vitest/coverage-v8": "^5.0.0",
-    "@vue/test-utils": "^2.5.0",
-    "@vueuse/nuxt": "^14.4.0",
+    "@vitest/coverage-v8": "^5.0.1",
+    "@vue/test-utils": "^2.5.1",
+    "@vueuse/nuxt": "^15.0.0",
     "better-sqlite3": "^13.0.3",
     "bumpp": "^12.3.0",
-    "eslint": "^10.10.0",
-    "eslint-plugin-harlanzw": "^0.21.1",
+    "eslint": "^10.11.0",
+    "eslint-plugin-harlanzw": "^0.23.0",
     "execa": "^10.0.1",
     "h3": "^1.15.11",
-    "happy-dom": "^20.14.0",
+    "happy-dom": "^20.14.5",
     "nitropack": "^2.13.4",
     "nuxt": "^4.5.2",
     "nuxt-site-config": "^4.2.3",
-    "nuxtseo-layer-devtools": "^5.3.14",
+    "nuxtseo-layer-devtools": "^5.3.16",
     "playwright": "^1.63.0",
     "playwright-core": "^1.63.0",
     "postgres": "^3.4.9",
     "tinyglobby": "^0.2.17",
     "typescript": "6.0.3",
     "unbuild": "^3.6.1",
-    "vitest": "^5.0.0",
-    "vue": "^3.5.42",
+    "vitest": "^5.0.1",
+    "vue": "^3.5.43",
     "vue-router": "^5.3.1",
     "vue-tsc": "^3.3.11",
-    "wrangler": "^4.129.0",
-    "zod": "^4.5.4"
+    "wrangler": "^4.136.3",
+    "zod": "^4.6.5"
   },
   "scripts": {
     "lint": "eslint .",