nuxt-ai-ready 0.6.2 → 0.7.0

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

@@ -1,4 +1,5 @@
-import { getPagesList } from "../../utils/pageData.js";
+import { useEvent } from "nitropack/runtime";
+import { queryPages } from "../../db/queries.js";
 export default {
   uri: "resource://nuxt-ai-ready/pages",
   name: "All Pages",
@@ -8,12 +9,19 @@ export default {
   },
   cache: "1h",
   async handler(uri) {
-    const pages = await getPagesList();
+    const event = useEvent();
+    const pages = await queryPages(event);
     return {
       contents: [{
         uri: uri.toString(),
         mimeType: "application/json",
-        text: JSON.stringify(pages)
+        text: JSON.stringify(pages.map((p) => ({
+          route: p.route,
+          title: p.title || p.route,
+          description: p.description || "",
+          headings: p.headings || void 0,
+          keywords: p.keywords?.length ? p.keywords : void 0
+        })))
       }]
     };
   }

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

@@ -1,11 +1,37 @@
-import { getPagesList } from "../../utils/pageData.js";
-export default {
+import { useEvent } from "nitropack/runtime";
+import { z } from "zod";
+import { countPages, queryPages } from "../../db/queries.js";
+const inputSchema = {
+  limit: z.number().optional().default(100).describe("Max pages to return (default: 100)"),
+  offset: z.number().optional().default(0).describe("Skip first N pages (for pagination)")
+};
+const tool = {
   name: "list_pages",
-  description: "Lists all available pages with titles, descriptions and routes.",
-  inputSchema: {},
+  description: "Lists all available pages with titles, descriptions and routes. Supports pagination via limit/offset.",
+  inputSchema,
   cache: "1h",
-  async handler() {
-    const pages = await getPagesList();
-    return { content: [{ type: "text", text: JSON.stringify(pages) }] };
+  async handler({ limit, offset }) {
+    const event = useEvent();
+    const pages = await queryPages(event, { limit, offset });
+    const total = await countPages(event);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          pages: pages.map((p) => ({
+            route: p.route,
+            title: p.title || p.route,
+            description: p.description || "",
+            headings: p.headings || void 0,
+            keywords: p.keywords?.length ? p.keywords : void 0
+          })),
+          total,
+          limit,
+          offset,
+          hasMore: offset + pages.length < total
+        })
+      }]
+    };
   }
 };
+export default tool;

package/dist/runtime/server/mcp/tools/search-pages.js

@@ -1,5 +1,5 @@
+import { useEvent } from "nitropack/runtime";
 import { z } from "zod";
-import { useDatabase } from "../../db/index.js";
 import { searchPages } from "../../db/queries.js";
 const inputSchema = {
   query: z.string().describe("Search query"),
@@ -11,8 +11,8 @@ const tool = {
   inputSchema,
   cache: "5m",
   async handler({ query, limit }) {
-    const db = await useDatabase();
-    const results = await searchPages(db, query, { limit });
+    const event = useEvent();
+    const results = await searchPages(event, query, { limit });
     return { content: [{ type: "text", text: JSON.stringify(results) }] };
   }
 };

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

@@ -53,9 +53,8 @@ export default defineEventHandler(async (event) => {
   const result = await convertHtmlToMarkdown(
     html,
     withSiteUrl(event, path),
-    config,
-    path,
-    event
+    config.mdreamOptions,
+    { hooks: { route: path, event } }
   );
   setHeader(event, "content-type", "text/markdown; charset=utf-8");
   if (config.markdownCacheHeaders) {

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

@@ -1,8 +1,8 @@
 import { withSiteUrl } from "#site-config/server/composables/utils";
 import { createError, defineEventHandler } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
-import { extractKeywords, stripMarkdown } from "../utils/keywords.js";
-import { convertHtmlToMarkdownMeta, getMarkdownRenderInfo } from "../utils.js";
+import { convertHtmlToMarkdown, getMarkdownRenderInfo } from "../utils.js";
+import { extractKeywords } from "../utils/keywords.js";
 export default defineEventHandler(async (event) => {
   if (!import.meta.prerender) {
     return;
@@ -27,12 +27,13 @@ export default defineEventHandler(async (event) => {
       message: `Page rendered as error: ${path}`
     });
   }
-  const result = await convertHtmlToMarkdownMeta(
+  const result = await convertHtmlToMarkdown(
     html,
     withSiteUrl(event, path),
-    runtimeConfig.mdreamOptions
+    runtimeConfig.mdreamOptions,
+    { extractUpdatedAt: true }
   );
-  const keywords = extractKeywords(stripMarkdown(result.markdown), result.metaKeywords);
+  const keywords = extractKeywords(result.textContent, result.metaKeywords);
   return JSON.stringify({
     markdown: result.markdown,
     title: result.title,

package/dist/runtime/server/plugins/db-restore.js

@@ -1,13 +1,14 @@
 import { defineNitroPlugin } from "nitropack/runtime";
 import { useDatabase } from "../db/index.js";
-import { hasPages } from "../db/queries.js";
-import { decompressDump, importDump } from "../db/dump.js";
+import { countPages } from "../db/queries.js";
+import { decompressFromBase64, importDbDump } from "../db/shared.js";
 import { logger } from "../logger.js";
 export default defineNitroPlugin(async () => {
-  if (import.meta.prerender) return;
-  if (import.meta.dev) return;
-  const db = await useDatabase();
-  if (await hasPages(db)) {
+  if (import.meta.prerender)
+    return;
+  if (import.meta.dev)
+    return;
+  if (await countPages() > 0) {
     logger.debug("[db-restore] Database already has data, skipping restore");
     return;
   }
@@ -18,7 +19,8 @@ export default defineNitroPlugin(async () => {
     logger.debug("[db-restore] No dump found, starting with empty database");
     return;
   }
-  const rows = await decompressDump(dumpData);
-  await importDump(db, rows);
+  const db = await useDatabase();
+  const rows = await decompressFromBase64(dumpData);
+  await importDbDump(db, rows);
   logger.info(`[db-restore] Restored ${rows.length} pages from dump`);
 });

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

@@ -0,0 +1,44 @@
+import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
+import { getSitemapSeededAt, pruneStaleRoutes, seedRoutes, setSitemapSeededAt } from "../db/queries.js";
+import { logger } from "../logger.js";
+import { fetchSitemapUrls } from "../utils/sitemap.js";
+let seeding = null;
+export default defineNitroPlugin((nitro) => {
+  if (import.meta.prerender)
+    return;
+  nitro.hooks.hook("request", async (event) => {
+    if (!seeding) {
+      seeding = seedFromSitemap(event).catch((err) => {
+        logger.error("[sitemap-seeder] Failed to seed:", err);
+      });
+    }
+  });
+});
+async function seedFromSitemap(event) {
+  const config = useRuntimeConfig()["nuxt-ai-ready"];
+  const { ttl, pruneTtl } = config.runtimeSync;
+  const seededAt = await getSitemapSeededAt(event);
+  if (seededAt && ttl > 0) {
+    const age = (Date.now() - seededAt) / 1e3;
+    if (age < ttl) {
+      logger.debug(`[sitemap-seeder] Sitemap fresh (${Math.round(age)}s old), skipping`);
+      return;
+    }
+  }
+  const urls = await fetchSitemapUrls(event);
+  if (urls.length === 0) {
+    return;
+  }
+  const routes = urls.map((u) => {
+    const url = new URL(u.loc);
+    return url.pathname;
+  }).filter((route) => !route.includes("."));
+  await seedRoutes(event, routes);
+  await setSitemapSeededAt(event, Date.now());
+  logger.info(`[sitemap-seeder] Seeded ${routes.length} routes from sitemap`);
+  if (pruneTtl > 0) {
+    const pruned = await pruneStaleRoutes(event, pruneTtl);
+    if (pruned > 0)
+      logger.info(`[sitemap-seeder] Pruned ${pruned} stale routes`);
+  }
+}

package/dist/runtime/server/routes/__ai-ready/indexnow.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../utils/indexnow.js").IndexNowResult>>;
+export default _default;

package/dist/runtime/server/routes/__ai-ready/indexnow.post.js

@@ -0,0 +1,18 @@
+import { createError, eventHandler, getQuery } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { syncToIndexNow } from "../../utils/indexnow.js";
+export default eventHandler(async (event) => {
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  if (!config.indexNow?.enabled) {
+    throw createError({ statusCode: 400, message: "IndexNow not enabled" });
+  }
+  const query = getQuery(event);
+  if (config.runtimeSync?.secret) {
+    const secret = query.secret;
+    if (secret !== config.runtimeSync.secret) {
+      throw createError({ statusCode: 401, message: "Unauthorized" });
+    }
+  }
+  const limit = query.limit ? Number(query.limit) : 100;
+  return syncToIndexNow(event, limit);
+});

package/dist/runtime/server/routes/__ai-ready/poll.post.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    indexed: number;
+    remaining: number;
+    errors: string[] | undefined;
+    duration: number;
+    complete: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/routes/__ai-ready/poll.post.js

@@ -0,0 +1,25 @@
+import { createError, eventHandler, getQuery } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { batchIndexPages } from "../../utils/batchIndex.js";
+export default eventHandler(async (event) => {
+  const config = useRuntimeConfig()["nuxt-ai-ready"];
+  const query = getQuery(event);
+  if (config.runtimeSync.secret) {
+    const secret = query.secret;
+    if (secret !== config.runtimeSync.secret) {
+      throw createError({ statusCode: 401, message: "Unauthorized" });
+    }
+  }
+  const result = await batchIndexPages(event, {
+    limit: query.limit ? Number(query.limit) : void 0,
+    all: query.all === "true" || query.all === "1",
+    timeout: query.timeout ? Number(query.timeout) : void 0
+  });
+  return {
+    indexed: result.indexed,
+    remaining: result.remaining,
+    errors: result.errors.length > 0 ? result.errors : void 0,
+    duration: result.duration,
+    complete: result.complete
+  };
+});

package/dist/runtime/server/routes/__ai-ready/prune.post.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    routes: string[];
+    count: number;
+    ttl: number;
+    dry: boolean;
+    pruned?: undefined;
+} | {
+    pruned: number;
+    ttl: number;
+    dry: boolean;
+    routes?: undefined;
+    count?: undefined;
+}>>;
+export default _default;

package/dist/runtime/server/routes/__ai-ready/prune.post.js

@@ -0,0 +1,21 @@
+import { createError, eventHandler, getQuery } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { getStaleRoutes, pruneStaleRoutes } from "../../db/queries.js";
+export default eventHandler(async (event) => {
+  const config = useRuntimeConfig()["nuxt-ai-ready"];
+  const query = getQuery(event);
+  const dry = query.dry === "true" || query.dry === "1";
+  if (!dry && config.runtimeSync.secret) {
+    const secret = query.secret;
+    if (secret !== config.runtimeSync.secret) {
+      throw createError({ statusCode: 401, message: "Unauthorized" });
+    }
+  }
+  const ttl = query.ttl ? Number(query.ttl) : config.runtimeSync.pruneTtl;
+  if (dry) {
+    const routes = await getStaleRoutes(event, ttl);
+    return { routes, count: routes.length, ttl, dry: true };
+  }
+  const pruned = await pruneStaleRoutes(event, ttl);
+  return { pruned, ttl, dry: false };
+});

package/dist/runtime/server/routes/__ai-ready/status.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Record<string, unknown>>>;
+export default _default;

package/dist/runtime/server/routes/__ai-ready/status.get.js

@@ -0,0 +1,28 @@
+import { eventHandler } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { countPages, countPagesNeedingIndexNowSync, getIndexNowStats } from "../../db/queries.js";
+export default eventHandler(async (event) => {
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  const [total, pending] = await Promise.all([
+    countPages(event),
+    countPages(event, { where: { pending: true } })
+  ]);
+  const result = {
+    total,
+    indexed: total - pending,
+    pending
+  };
+  if (config.indexNow?.enabled) {
+    const [indexNowPending, indexNowStats] = await Promise.all([
+      countPagesNeedingIndexNowSync(event),
+      getIndexNowStats(event)
+    ]);
+    result.indexNow = {
+      pending: indexNowPending,
+      totalSubmitted: indexNowStats.totalSubmitted,
+      lastSubmittedAt: indexNowStats.lastSubmittedAt,
+      lastError: indexNowStats.lastError
+    };
+  }
+  return result;
+});

package/dist/runtime/server/routes/__ai-ready-debug.get.js

@@ -1,6 +1,6 @@
 import { createError, eventHandler, setHeader } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
-import { getErrorRoutes, getPages, getPagesList } from "../utils/pageData.js";
+import { queryPages } from "../db/queries.js";
 export default eventHandler(async (event) => {
   const runtimeConfig = useRuntimeConfig(event)["nuxt-ai-ready"];
   if (!runtimeConfig.debug) {
@@ -19,16 +19,15 @@ export default eventHandler(async (event) => {
   } else {
     mode = "production";
   }
-  const pages = await getPages(event);
-  const pagesList = await getPagesList(event);
-  const errorRoutes = await getErrorRoutes(event);
+  const pages = await queryPages(event);
+  const errorRoutes = await queryPages(event, { where: { hasError: true } });
   let source;
   if (isDev) {
-    source = "empty (dev mode returns empty Map)";
+    source = "empty (dev mode returns empty array)";
   } else if (isPrerender) {
     source = "#ai-ready-virtual/read-page-data.mjs (reads from filesystem)";
   } else {
-    source = "fetch('/__ai-ready/pages.json') (public directory)";
+    source = "database (db0 adapter)";
   }
   let pageDataModuleInfo = { available: false, pagesCount: 0, errorRoutesCount: 0 };
   let readPageDataModuleInfo = { available: false, note: "" };
@@ -79,17 +78,17 @@ export default eventHandler(async (event) => {
   if (mode === "development") {
     issues.push("Development mode: page data is intentionally empty");
     suggestions.push("Run `nuxi generate` or `nuxi build --prerender` to generate page data");
-  } else if (mode === "production" && pages.size === 0) {
+  } else if (mode === "production" && pages.length === 0) {
     if (!jsonFileStatus.available) {
-      issues.push("Production mode with no page data - /__ai-ready/pages.json not found");
+      issues.push("Production mode with no page data - database may be empty");
       suggestions.push("Run `nuxi generate` or `nuxi build --prerender` to generate the page data");
     } else {
-      issues.push("pages.json exists but returned empty page data");
+      issues.push("Database exists but returned empty page data");
       suggestions.push("Check if pages were prerendered correctly");
     }
-  } else if (mode === "prerender" && pages.size === 0) {
+  } else if (mode === "prerender" && pages.length === 0) {
     issues.push("Prerender mode but no pages found");
-    suggestions.push("Check if page-data.jsonl exists in .nuxt/.data/ai-ready/");
+    suggestions.push("Check if pages.db exists in .data/ai-ready/");
   }
   const debugInfo = {
     version: runtimeConfig.version || "unknown",
@@ -105,14 +104,14 @@ export default eventHandler(async (event) => {
     },
     pageData: {
       source,
-      pageCount: pages.size,
-      pages: pagesList.map((p) => ({
+      pageCount: pages.length,
+      pages: pages.map((p) => ({
         route: p.route,
         title: p.title,
         hasDescription: !!p.description,
         hasHeadings: !!p.headings
       })),
-      errorRoutes: Array.from(errorRoutes)
+      errorRoutes: errorRoutes.map((e) => e.route)
     },
     jsonFile: jsonFileStatus,
     virtualModules: {

package/dist/runtime/server/routes/indexnow-key.get.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Key verification endpoint for IndexNow
+ * Returns the API key as plain text for search engine verification
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, string | null>;
+export default _default;

package/dist/runtime/server/routes/indexnow-key.get.js

@@ -0,0 +1,10 @@
+import { eventHandler, setHeader } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+export default eventHandler((event) => {
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  const key = config.indexNow?.key;
+  if (!key)
+    return null;
+  setHeader(event, "Content-Type", "text/plain; charset=utf-8");
+  return key;
+});

package/dist/runtime/server/routes/llms-full.txt.get.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, string>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | void>>;
 export default _default;

package/dist/runtime/server/routes/llms-full.txt.get.js

@@ -1,5 +1,36 @@
-import { eventHandler, setHeader } from "h3";
-export default eventHandler((event) => {
+import { useSiteConfig } from "#imports";
+import { eventHandler, sendIterable, setHeader, setResponseHeader } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { countPages, streamPages } from "../db/queries.js";
+import { buildLlmsFullTxtHeader, formatPageForLlmsFullTxt } from "../utils/llms-full.js";
+export default eventHandler(async (event) => {
+  if (import.meta.prerender) {
+    setHeader(event, "Content-Type", "text/plain; charset=utf-8");
+    return "# llms-full.txt\n\nThis file is generated during prerender.";
+  }
+  const config = useRuntimeConfig()["nuxt-ai-ready"];
+  const siteConfig = useSiteConfig();
+  const header = buildLlmsFullTxtHeader(
+    {
+      name: siteConfig.name,
+      url: siteConfig.url,
+      description: siteConfig.description
+    },
+    config.llmsTxt
+  );
+  const total = await countPages(event);
+  if (total === 0) {
+    setHeader(event, "Content-Type", "text/plain; charset=utf-8");
+    return `${header}No pages indexed. Run \`nuxi generate\` or enable runtime indexing.`;
+  }
   setHeader(event, "Content-Type", "text/plain; charset=utf-8");
-  return "# llms-full.txt\n\nThis file is only available for prerendered routes.\nRun `nuxi generate` to generate this file.";
+  setResponseHeader(event, "Cache-Control", "public, max-age=3600, s-maxage=3600, stale-while-revalidate=86400");
+  const siteUrl = siteConfig.url;
+  async function* generateContent() {
+    yield header;
+    for await (const page of streamPages(event)) {
+      yield formatPageForLlmsFullTxt(page.route, page.title, page.description, page.markdown, siteUrl);
+    }
+  }
+  return sendIterable(event, generateContent());
 });

package/dist/runtime/server/tasks/ai-ready-index.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import("nitropack/types").Task<{
+    indexed: number;
+    remaining: number;
+    errors: string[];
+    complete: boolean;
+    indexNow: {
+        submitted: number;
+        error: any;
+    } | undefined;
+}>;
+export default _default;

package/dist/runtime/server/tasks/ai-ready-index.js

@@ -0,0 +1,39 @@
+import { defineTask, useRuntimeConfig } from "nitropack/runtime";
+import { batchIndexPages } from "../utils/batchIndex.js";
+import { syncToIndexNow } from "../utils/indexnow.js";
+export default defineTask({
+  meta: {
+    name: "ai-ready:index",
+    description: "Index pending pages for AI Ready"
+  },
+  async run({ payload }) {
+    const config = useRuntimeConfig()["nuxt-ai-ready"];
+    const limit = payload?.limit ?? config.runtimeSync.batchSize;
+    const mockEvent = {
+      $fetch: globalThis.$fetch
+    };
+    const result = await batchIndexPages(mockEvent, {
+      limit,
+      all: false
+    });
+    let indexNowResult;
+    if (config.indexNow?.enabled) {
+      indexNowResult = await syncToIndexNow(mockEvent, 100).catch((err) => {
+        console.warn("[ai-ready:index] IndexNow sync failed:", err.message);
+        return { success: false, submitted: 0, error: err.message };
+      });
+    }
+    return {
+      result: {
+        indexed: result.indexed,
+        remaining: result.remaining,
+        errors: result.errors,
+        complete: result.complete,
+        indexNow: indexNowResult ? {
+          submitted: indexNowResult.submitted,
+          error: indexNowResult.error
+        } : void 0
+      }
+    };
+  }
+});

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

@@ -0,0 +1,26 @@
+import type { H3Event } from 'h3';
+export interface BatchIndexOptions {
+    /** Max pages per batch (default: 10, max: 50) */
+    limit?: number;
+    /** Process until complete (ignores limit) */
+    all?: boolean;
+    /** Max ms to run (for all mode, default: 30000) */
+    timeout?: number;
+}
+export interface BatchIndexResult {
+    /** Number of pages indexed */
+    indexed: number;
+    /** Pages remaining to index */
+    remaining: number;
+    /** Routes that failed to index */
+    errors: string[];
+    /** Duration in ms */
+    duration: number;
+    /** True if all pages are indexed */
+    complete: boolean;
+}
+/**
+ * Batch index pending pages (max 50 per batch)
+ * Shared logic used by poll endpoint and scheduled task
+ */
+export declare function batchIndexPages(event: H3Event, options?: BatchIndexOptions): Promise<BatchIndexResult>;

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

@@ -0,0 +1,53 @@
+import { countPages, queryPages } from "../db/queries.js";
+import { logger } from "../logger.js";
+import { indexPageByRoute } from "./indexPage.js";
+export async function batchIndexPages(event, options = {}) {
+  const startTime = Date.now();
+  const limit = Math.min(options.limit ?? 10, 50);
+  const timeout = options.timeout ?? 3e4;
+  const beforeCount = await countPages(event, { where: { pending: true } });
+  if (beforeCount === 0) {
+    return {
+      indexed: 0,
+      remaining: 0,
+      errors: [],
+      duration: Date.now() - startTime,
+      complete: true
+    };
+  }
+  let indexed = 0;
+  const errors = [];
+  let iteration = 0;
+  while (true) {
+    if (options.all && Date.now() - startTime >= timeout) {
+      logger.debug(`[batchIndex] Timeout reached after ${Date.now() - startTime}ms`);
+      break;
+    }
+    if (!options.all && iteration >= limit) {
+      break;
+    }
+    const pages = await queryPages(event, { where: { pending: true }, limit: 1 });
+    const route = pages[0]?.route;
+    if (!route)
+      break;
+    iteration++;
+    const result = await indexPageByRoute(route, event, {
+      markFailedAsError: true,
+      force: true
+    });
+    if (result.success) {
+      indexed++;
+      logger.debug(`[batchIndex] Indexed: ${route}`);
+    } else {
+      errors.push(route);
+    }
+  }
+  const remaining = await countPages(event, { where: { pending: true } });
+  return {
+    indexed,
+    remaining,
+    errors,
+    duration: Date.now() - startTime,
+    complete: remaining === 0
+  };
+}

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

@@ -1,4 +1,5 @@
 import type { H3Event } from 'h3';
+export declare const INDEXING_HEADER = "x-ai-ready-indexing";
 export interface IndexPageOptions {
     /** Skip if page was indexed within TTL (uses config ttl if not specified) */
     ttl?: number;
@@ -6,6 +7,8 @@ export interface IndexPageOptions {
     force?: boolean;
     /** Skip calling the ai-ready:page:indexed hook */
     skipHook?: boolean;
+    /** Mark failed fetches as errors in DB to prevent retry loops */
+    markFailedAsError?: boolean;
 }
 export interface IndexPageResult {
     success: boolean;
@@ -13,6 +16,8 @@ export interface IndexPageResult {
     skipped?: boolean;
     /** True if this was an update vs new index */
     isUpdate?: boolean;
+    /** True if content actually changed (hash differs from previous) */
+    contentChanged?: boolean;
     /** Page data if successful */
     data?: {
         route: string;
@@ -21,6 +26,7 @@ export interface IndexPageResult {
         headings: string;
         keywords: string[];
         markdown: string;
+        contentHash: string;
         updatedAt: string;
     };
     /** Error message if failed */
@@ -30,9 +36,9 @@ export interface IndexPageResult {
  * Manually index a page's HTML content into database
  * Use this from custom plugins or API routes to trigger indexing
  */
-export declare function indexPage(route: string, html: string, options?: IndexPageOptions): Promise<IndexPageResult>;
+export declare function indexPage(route: string, html: string, options?: IndexPageOptions, event?: H3Event): Promise<IndexPageResult>;
 /**
  * Index a page by fetching its HTML first
  * Convenience wrapper around indexPage that handles fetching
  */
-export declare function indexPageByRoute(route: string, event?: H3Event, options?: IndexPageOptions): Promise<IndexPageResult>;
+export declare function indexPageByRoute(route: string, event: H3Event, options?: IndexPageOptions): Promise<IndexPageResult>;