nuxt-ai-ready 0.6.2 → 0.7.0

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

@@ -1,35 +1,39 @@
 import { useNitroApp, useRuntimeConfig } from "nitropack/runtime";
-import { useDatabase } from "../db/index.js";
-import { getPage, isPageFresh, upsertPage } from "../db/queries.js";
+import { getPageHash, isPageFresh, queryPages, upsertPage } from "../db/queries.js";
+import { computeContentHash } from "../db/shared.js";
 import { logger } from "../logger.js";
-import { convertHtmlToMarkdownMeta } from "../utils.js";
-import { extractKeywords, stripMarkdown } from "./keywords.js";
-export async function indexPage(route, html, options = {}) {
+import { convertHtmlToMarkdown } from "../utils.js";
+import { extractKeywords } from "./keywords.js";
+export const INDEXING_HEADER = "x-ai-ready-indexing";
+export async function indexPage(route, html, options = {}, event) {
   const config = useRuntimeConfig()["nuxt-ai-ready"];
-  const db = await useDatabase();
-  const ttl = options.ttl ?? config.ttl ?? 0;
-  if (!options.force && await isPageFresh(db, route, ttl)) {
+  const ttl = options.ttl ?? config.runtimeSync.ttl;
+  if (!options.force && await isPageFresh(event, route, ttl)) {
     logger.debug(`[indexPage] Skipping ${route} - still fresh`);
     return { success: true, skipped: true, isUpdate: true };
   }
-  const existing = await getPage(db, route);
+  const existing = await queryPages(event, { route });
   const isUpdate = !!existing;
   const isError = html.includes("__NUXT_ERROR__") || html.includes("nuxt-error-page");
-  const result = await convertHtmlToMarkdownMeta(html, route, config.mdreamOptions);
+  const result = await convertHtmlToMarkdown(html, route, config.mdreamOptions, { extractUpdatedAt: true });
   const updatedAt = result.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
   const headings = JSON.stringify(result.headings);
-  const keywords = extractKeywords(stripMarkdown(result.markdown), result.metaKeywords);
-  await upsertPage(db, {
+  const keywords = extractKeywords(result.textContent, result.metaKeywords);
+  const contentHash = await computeContentHash(result.markdown);
+  const existingHash = await getPageHash(event, route);
+  const contentChanged = existingHash !== contentHash;
+  await upsertPage(event, {
     route,
     title: result.title,
     description: result.description,
     markdown: result.markdown,
     headings,
     keywords,
+    contentHash,
     updatedAt,
     isError
   });
-  logger.debug(`[indexPage] Indexed: ${route} "${result.title}"`);
+  logger.debug(`[indexPage] Indexed: ${route} "${result.title}" (changed=${contentChanged})`);
   if (!options.skipHook) {
     const nitro = useNitroApp();
     const hookContext = {
@@ -40,13 +44,15 @@ export async function indexPage(route, html, options = {}) {
       keywords,
       markdown: result.markdown,
       updatedAt,
-      isUpdate
+      isUpdate,
+      contentChanged
     };
     await nitro.hooks.callHook("ai-ready:page:indexed", hookContext);
   }
   return {
     success: true,
     isUpdate,
+    contentChanged,
     data: {
       route,
       title: result.title,
@@ -54,23 +60,32 @@ export async function indexPage(route, html, options = {}) {
       headings,
       keywords,
       markdown: result.markdown,
+      contentHash,
       updatedAt
     }
   };
 }
 export async function indexPageByRoute(route, event, options = {}) {
-  const fetchFn = event?.fetch || globalThis.$fetch;
-  const html = await fetchFn(route, {
-    headers: { "x-ai-ready-internal": "1" }
+  const html = await event.$fetch(route, {
+    headers: { [INDEXING_HEADER]: "1" }
   }).catch((err) => {
-    logger.error(`[indexPageByRoute] Failed to fetch ${route}:`, err);
+    logger.warn(`[indexPageByRoute] Failed to fetch ${route}:`, err.message);
     return null;
   });
-  if (!html) {
+  if (!html || typeof html !== "string") {
+    if (options.markFailedAsError) {
+      await upsertPage(event, {
+        route,
+        title: "",
+        description: "",
+        markdown: "",
+        headings: "[]",
+        keywords: [],
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        isError: true
+      });
+    }
     return { success: false, error: `Failed to fetch HTML for ${route}` };
   }
-  if (typeof html !== "string") {
-    return { success: false, error: `Response for ${route} is not HTML` };
-  }
-  return indexPage(route, html, options);
+  return indexPage(route, html, options, event);
 }

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

@@ -0,0 +1,27 @@
+import type { H3Event } from 'h3';
+export interface IndexNowResult {
+    success: boolean;
+    submitted: number;
+    remaining: number;
+    error?: string;
+}
+export interface IndexNowConfig {
+    enabled?: boolean;
+    key?: string;
+    host?: string;
+}
+/**
+ * Submit URLs to IndexNow API
+ */
+export declare function submitToIndexNow(routes: string[], config: {
+    key: string;
+    host?: string;
+}, siteUrl: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Submit pending pages to IndexNow
+ * Queries DB for pages needing sync, submits, marks as synced
+ */
+export declare function syncToIndexNow(event: H3Event, limit?: number): Promise<IndexNowResult>;

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

@@ -0,0 +1,66 @@
+import { useSiteConfig } from "#imports";
+import { useRuntimeConfig } from "nitropack/runtime";
+import {
+  countPagesNeedingIndexNowSync,
+  getPagesNeedingIndexNowSync,
+  markIndexNowSynced,
+  updateIndexNowStats
+} from "../db/queries.js";
+import { logger } from "../logger.js";
+export async function submitToIndexNow(routes, config, siteUrl) {
+  if (!siteUrl) {
+    return { success: false, error: "Site URL not configured" };
+  }
+  const host = config.host || "api.indexnow.org";
+  const endpoint = `https://${host}/indexnow`;
+  const urlList = routes.map(
+    (route) => route.startsWith("http") ? route : `${siteUrl}${route}`
+  );
+  const body = {
+    host: new URL(siteUrl).host,
+    key: config.key,
+    keyLocation: `${siteUrl}/${config.key}.txt`,
+    urlList
+  };
+  logger.debug(`[indexnow] Submitting ${urlList.length} URLs to ${endpoint}`);
+  const response = await $fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body
+  }).catch((err) => ({ error: err.message }));
+  if (response && typeof response === "object" && "error" in response) {
+    logger.warn(`[indexnow] Submission failed: ${response.error}`);
+    return { success: false, error: response.error };
+  }
+  logger.debug(`[indexnow] Successfully submitted ${urlList.length} URLs`);
+  return { success: true };
+}
+export async function syncToIndexNow(event, limit = 100) {
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  const siteConfig = useSiteConfig();
+  if (!config.indexNow?.enabled || !config.indexNow?.key) {
+    return { success: false, submitted: 0, remaining: 0, error: "IndexNow not configured" };
+  }
+  if (!siteConfig.url) {
+    return { success: false, submitted: 0, remaining: 0, error: "Site URL not configured" };
+  }
+  const pages = await getPagesNeedingIndexNowSync(event, limit);
+  if (pages.length === 0) {
+    return { success: true, submitted: 0, remaining: 0 };
+  }
+  const routes = pages.map((p) => p.route);
+  const result = await submitToIndexNow(routes, config.indexNow, siteConfig.url);
+  if (result.success) {
+    await markIndexNowSynced(event, routes);
+    await updateIndexNowStats(event, routes.length);
+  } else {
+    await updateIndexNowStats(event, 0, result.error);
+  }
+  const remaining = await countPagesNeedingIndexNowSync(event);
+  return {
+    success: result.success,
+    submitted: result.success ? routes.length : 0,
+    remaining,
+    error: result.error
+  };
+}

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

@@ -2,7 +2,3 @@
  * Extract keywords from text using word frequency
  */
 export declare function extractKeywords(text: string, metaKeywords?: string, max?: number): string[];
-/**
- * Strip markdown formatting to get plain text
- */
-export declare function stripMarkdown(markdown: string): string;

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

@@ -277,6 +277,3 @@ export function extractKeywords(text, metaKeywords, max = 10) {
     freq.set(word, (freq.get(word) || 0) + 1);
   return Array.from(freq.entries()).sort((a, b) => b[1] - a[1]).slice(0, max).map(([word]) => word);
 }
-export function stripMarkdown(markdown) {
-  return markdown.replace(/```[\s\S]*?```/g, "").replace(/`[^`]+`/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/!\[[^\]]*\]\([^)]+\)/g, "").replace(/^#{1,6}\s+/gm, "").replace(/[*_]{1,2}([^*_]+)[*_]{1,2}/g, "$1").replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
-}

package/dist/runtime/server/utils/llms-full.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utilities for formatting llms-full.txt content
+ */
+import type { LlmsTxtConfig } from '../../types.js';
+export declare function formatPageForLlmsFullTxt(route: string, title: string, description: string, markdown: string, siteUrl?: string): string;
+export interface SiteInfo {
+    name?: string;
+    url?: string;
+    description?: string;
+}
+export declare function buildLlmsFullTxtHeader(siteInfo?: SiteInfo, llmsTxtConfig?: LlmsTxtConfig): string;

package/dist/runtime/server/utils/llms-full.js

@@ -0,0 +1,39 @@
+import { normalizeLlmsTxtConfig } from "../../llms-txt-format.js";
+export function formatPageForLlmsFullTxt(route, title, description, markdown, siteUrl) {
+  const canonicalUrl = siteUrl ? `${siteUrl.replace(/\/$/, "")}${route}` : route;
+  const heading = title && title !== route ? `### ${title}` : `### ${route}`;
+  const content = markdown.replace(/^---\n[\s\S]*?\n---\n*/, "").replace(/^(#{1,6}) ([^\n]+)$/gm, (_, hashes, text) => `h${hashes.length}. ${text}`);
+  const parts = [heading, ""];
+  parts.push(`Source: ${canonicalUrl}`);
+  if (description)
+    parts.push(`Description: ${description}`);
+  parts.push("");
+  if (content.trim()) {
+    parts.push(content.trim());
+    parts.push("");
+  }
+  parts.push("---");
+  parts.push("");
+  return `${parts.join("\n")}
+`;
+}
+export function buildLlmsFullTxtHeader(siteInfo, llmsTxtConfig) {
+  const parts = [];
+  parts.push(`# ${siteInfo?.name || siteInfo?.url || "Site"}`);
+  if (siteInfo?.description)
+    parts.push(`
+> ${siteInfo.description}`);
+  if (siteInfo?.url)
+    parts.push(`
+Canonical Origin: ${siteInfo.url}`);
+  parts.push("");
+  if (llmsTxtConfig) {
+    const normalizedContent = normalizeLlmsTxtConfig(llmsTxtConfig);
+    if (normalizedContent) {
+      parts.push(normalizedContent);
+      parts.push("");
+    }
+  }
+  parts.push("## Pages\n\n");
+  return parts.join("\n");
+}

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

@@ -3,16 +3,16 @@ import { logger } from "../logger.js";
 export async function fetchSitemapUrls(event) {
   const sitemapRes = await event.$fetch("/sitemap.xml", { responseType: "text" }).catch(() => null);
   if (!sitemapRes) {
-    logger.warn("Sitemap not found at /sitemap.xml - llms.txt will have no pages listed");
+    logger.warn("Sitemap not found at /sitemap.xml - ensure @nuxtjs/sitemap is installed and configured");
     return [];
   }
   const result = await parseSitemapXml(sitemapRes).catch((e) => {
-    logger.warn("Failed to parse sitemap.xml:", e);
+    logger.warn(`Failed to parse sitemap.xml: ${e instanceof Error ? e.message : e}`);
     return { urls: [] };
   });
   const urls = result?.urls || [];
   if (urls.length === 0) {
-    logger.warn("Sitemap is empty - llms.txt will have no pages listed");
+    logger.warn("Sitemap is empty - add routes to sitemap or configure sitemap.sources in nuxt.config");
   }
   return urls.map((entry) => {
     if (typeof entry === "string")

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

@@ -1,23 +1,25 @@
 import type { H3Event } from 'h3';
 import type { ModulePublicRuntimeConfig } from '../../module.js';
-export declare function normalizeWhitespace(text: string): string;
 export declare function getMarkdownRenderInfo(event: H3Event, explicitOnly?: boolean): {
     path: string;
     isExplicit: boolean;
 } | null;
-export declare function clientPrefersMarkdown(event: H3Event): boolean;
-export declare function convertHtmlToMarkdown(html: string, url: string, config: ModulePublicRuntimeConfig, route: string, event: H3Event): Promise<{
-    markdown: string;
-    title: string;
-    description: string;
-    headings: Record<string, string>[];
-    metaKeywords: string;
-}>;
-export declare function convertHtmlToMarkdownMeta(html: string, url: string, mdreamOptions: ModulePublicRuntimeConfig['mdreamOptions']): Promise<{
+interface ConvertHtmlOptions {
+    /** Extract updatedAt from meta tags */
+    extractUpdatedAt?: boolean;
+    /** Call runtime hooks (ai-ready:mdreamConfig, ai-ready:markdown) */
+    hooks?: {
+        route: string;
+        event: H3Event;
+    };
+}
+export declare function convertHtmlToMarkdown(html: string, url: string, mdreamOptions: ModulePublicRuntimeConfig['mdreamOptions'], opts?: ConvertHtmlOptions): Promise<{
     updatedAt?: string | undefined;
     markdown: string;
     title: string;
     description: string;
     headings: Record<string, string>[];
     metaKeywords: string;
+    textContent: string;
 }>;
+export {};

package/dist/runtime/server/utils.js

@@ -4,9 +4,44 @@ import { htmlToMarkdown } from "mdream";
 import { extractionPlugin } from "mdream/plugins";
 import { withMinimalPreset } from "mdream/preset/minimal";
 import { useNitroApp } from "nitropack/runtime";
-export function normalizeWhitespace(text) {
+function normalizeWhitespace(text) {
   return text.replace(/\u00A0/g, " ");
 }
+function buildMdreamOptions(url, mdreamOptions, meta, extractUpdatedAt = false) {
+  const extractPlugin = extractionPlugin({
+    "title": (el) => {
+      meta.title = el.textContent;
+    },
+    'meta[name="description"]': (el) => {
+      meta.description = el.attributes.content || "";
+    },
+    'meta[name="keywords"]': (el) => {
+      meta.metaKeywords = el.attributes.content || "";
+    },
+    "h1, h2, h3, h4, h5, h6": (el) => {
+      const text = el.textContent?.trim();
+      if (text)
+        meta.headings.push({ [el.name.toLowerCase()]: text });
+    },
+    "p, li, td, th, blockquote, figcaption": (el) => {
+      const text = el.textContent?.trim();
+      if (text)
+        meta.textContent.push(text);
+    },
+    ...extractUpdatedAt && {
+      'meta[property="article:modified_time"], meta[name="last-modified"], meta[name="updated"], meta[property="og:updated_time"], meta[name="lastmod"]': (el) => {
+        if (!meta.updatedAt && el.attributes.content)
+          meta.updatedAt = el.attributes.content;
+      }
+    }
+  });
+  let options = { origin: url, ...mdreamOptions };
+  if (mdreamOptions?.preset === "minimal") {
+    options = withMinimalPreset(options);
+  }
+  options.plugins = [extractPlugin, ...options.plugins || []];
+  return options;
+}
 export function getMarkdownRenderInfo(event, explicitOnly = false) {
   const originalPath = event.path;
   if (originalPath.startsWith("/api") || originalPath.startsWith("/_") || originalPath.startsWith("/@")) {
@@ -32,7 +67,7 @@ export function getMarkdownRenderInfo(event, explicitOnly = false) {
   }
   return { path, isExplicit };
 }
-export function clientPrefersMarkdown(event) {
+function clientPrefersMarkdown(event) {
   const accept = getHeader(event, "accept") || "";
   const secFetchDest = getHeader(event, "sec-fetch-dest") || "";
   if (secFetchDest === "document") {
@@ -50,100 +85,34 @@ export function clientPrefersMarkdown(event) {
   }
   return false;
 }
-export async function convertHtmlToMarkdown(html, url, config, route, event) {
-  const nitroApp = useNitroApp();
-  let title = "";
-  let description = "";
-  let metaKeywords = "";
-  const headings = [];
-  const extractPlugin = extractionPlugin({
-    title(el) {
-      title = el.textContent;
-    },
-    'meta[name="description"]': (el) => {
-      description = el.attributes.content || "";
-    },
-    'meta[name="keywords"]': (el) => {
-      metaKeywords = el.attributes.content || "";
-    },
-    "h1, h2, h3, h4, h5, h6": (el) => {
-      const text = el.textContent?.trim();
-      const level = el.name.toLowerCase();
-      if (text)
-        headings.push({ [level]: text });
-    }
-  });
-  let options = {
-    origin: url,
-    ...config.mdreamOptions
-  };
-  if (config.mdreamOptions?.preset === "minimal") {
-    options = withMinimalPreset(options);
-    options.plugins = [extractPlugin, ...options.plugins || []];
-  } else {
-    options.plugins = [extractPlugin, ...options.plugins || []];
-  }
-  await nitroApp.hooks.callHook("ai-ready:mdreamConfig", options);
-  let markdown = htmlToMarkdown(html, options);
-  const context = {
-    html,
-    markdown,
-    route,
-    title,
-    description,
-    isPrerender: false,
-    event
-  };
-  await nitroApp.hooks.callHook("ai-ready:markdown", context);
-  markdown = normalizeWhitespace(context.markdown);
-  return { markdown, title: normalizeWhitespace(title), description: normalizeWhitespace(description), headings, metaKeywords };
-}
-export async function convertHtmlToMarkdownMeta(html, url, mdreamOptions) {
-  let title = "";
-  let description = "";
-  let metaKeywords = "";
-  let updatedAt;
-  const headings = [];
-  const extractPlugin = extractionPlugin({
-    title(el) {
-      title = el.textContent;
-    },
-    'meta[name="description"]': (el) => {
-      description = el.attributes.content || "";
-    },
-    'meta[name="keywords"]': (el) => {
-      metaKeywords = el.attributes.content || "";
-    },
-    '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;
-      }
-    },
-    "h1, h2, h3, h4, h5, h6": (el) => {
-      const text = el.textContent?.trim();
-      const level = el.name.toLowerCase();
-      if (text)
-        headings.push({ [level]: text });
-    }
-  });
-  let options = {
-    origin: url,
-    ...mdreamOptions
-  };
-  if (mdreamOptions?.preset === "minimal") {
-    options = withMinimalPreset(options);
-    options.plugins = [extractPlugin, ...options.plugins || []];
+export async function convertHtmlToMarkdown(html, url, mdreamOptions, opts = {}) {
+  const meta = { title: "", description: "", metaKeywords: "", headings: [], textContent: [] };
+  const options = buildMdreamOptions(url, mdreamOptions, meta, opts.extractUpdatedAt);
+  let markdown;
+  if (opts.hooks) {
+    const nitroApp = useNitroApp();
+    await nitroApp.hooks.callHook("ai-ready:mdreamConfig", options);
+    const context = {
+      html,
+      markdown: htmlToMarkdown(html, options),
+      route: opts.hooks.route,
+      title: meta.title,
+      description: meta.description,
+      isPrerender: false,
+      event: opts.hooks.event
+    };
+    await nitroApp.hooks.callHook("ai-ready:markdown", context);
+    markdown = context.markdown;
   } else {
-    options.plugins = [extractPlugin, ...options.plugins || []];
+    markdown = htmlToMarkdown(html, options);
   }
-  const rawMarkdown = htmlToMarkdown(html, options);
-  const markdown = normalizeWhitespace(rawMarkdown);
   return {
-    markdown,
-    title: normalizeWhitespace(title),
-    description: normalizeWhitespace(description),
-    headings,
-    metaKeywords,
-    ...updatedAt && { updatedAt }
+    markdown: normalizeWhitespace(markdown),
+    title: normalizeWhitespace(meta.title),
+    description: normalizeWhitespace(meta.description),
+    headings: meta.headings,
+    metaKeywords: meta.metaKeywords,
+    textContent: meta.textContent.join(" "),
+    ...meta.updatedAt && { updatedAt: meta.updatedAt }
   };
 }

package/dist/runtime/types.d.ts

@@ -74,13 +74,6 @@ export interface ModuleOptions {
      * @default 600 (10 minutes)
      */
     cacheMaxAgeSeconds?: number;
-    /**
-     * TTL for re-indexing pages in seconds
-     * Pages are automatically indexed on visit; this controls how often to refresh
-     * 0 = never re-index (rely on prerendered data)
-     * @default 0
-     */
-    ttl?: number;
     /**
      * Database configuration for page storage
      * Uses db0 for cross-platform SQLite support
@@ -110,6 +103,68 @@ export interface ModuleOptions {
          */
         authToken?: string;
     };
+    /**
+     * Runtime sync configuration (opt-in for dynamic content sites)
+     * When enabled, pages are re-indexed at runtime from sitemap
+     * @default disabled - prerendered data is used
+     */
+    runtimeSync?: {
+        /**
+         * Enable runtime sync
+         * When false (default), runtime uses prerendered data only
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * TTL for refresh in seconds (sitemap + page re-indexing)
+         * Controls how often to refresh sitemap routes and re-index stale pages
+         * @default 3600 (1 hour)
+         */
+        ttl?: number;
+        /**
+         * Pages to index per batch
+         * @default 20
+         */
+        batchSize?: number;
+        /**
+         * Cron expression for scheduled indexing (e.g. every 5 minutes)
+         * When set, enables automatic background indexing via Nitro task
+         */
+        cron?: string;
+        /**
+         * Secret token for authenticating poll endpoint
+         * When set, requires ?secret=<token> query param
+         */
+        secret?: string;
+        /**
+         * TTL for pruning stale routes in seconds
+         * Routes not seen in sitemap for longer than this are deleted
+         * 0 = never prune (default)
+         * @default 0
+         */
+        pruneTtl?: number;
+    };
+    /**
+     * IndexNow configuration for instant search engine notifications
+     * Submits changed URLs to Bing, Yandex, Naver, Seznam via IndexNow protocol
+     */
+    indexNow?: {
+        /**
+         * Enable IndexNow submissions
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * Your IndexNow API key
+         * Get one from https://www.bing.com/indexnow
+         */
+        key?: string;
+        /**
+         * IndexNow endpoint host
+         * @default 'api.indexnow.org'
+         */
+        host?: string;
+    };
 }
 /**
  * Page-level entry for discovery and metadata queries
@@ -199,28 +254,6 @@ export interface LlmsTxtConfig {
     /** Notes section (always appears at the end) */
     notes?: string | string[];
 }
-/**
- * Hook context for page markdown processing (Nuxt build-time hook)
- *
- * Called once per page during prerender when markdown content has changed.
- * Allows integrations to process page content (e.g., for embedding generation).
- *
- * @example Process page markdown
- * nuxt.hooks.hook('ai-ready:page:markdown', async (context) => {
- *   console.log(`Processing ${context.route}: ${context.title}`)
- *   // Generate embeddings, update search index, etc.
- * })
- */
-export interface PageMarkdownContext {
-    /** The route being processed (e.g., '/about') */
-    route: string;
-    /** The markdown content */
-    markdown: string;
-    /** Page title extracted from HTML */
-    title: string;
-    /** Page description from meta tags */
-    description: string;
-}
 /**
  * Context for runtime page indexing hook
  */
@@ -241,15 +274,6 @@ export interface PageIndexedContext {
     updatedAt: string;
     /** Whether this is a new page or an update */
     isUpdate: boolean;
-}
-declare module 'nitropack/types' {
-    interface NitroRuntimeHooks {
-        'ai-ready:markdown': (context: MarkdownContext) => void | Promise<void>;
-        'ai-ready:mdreamConfig': (config: import('mdream').HTMLToMarkdownOptions) => void | Promise<void>;
-        /**
-         * Called when a page is indexed at runtime
-         * Use this to sync with external systems (embeddings, search, etc)
-         */
-        'ai-ready:page:indexed': (context: PageIndexedContext) => void | Promise<void>;
-    }
+    /** Whether the content hash changed (triggers IndexNow sync) */
+    contentChanged: boolean;
 }