nuxt-ai-ready 0.7.1 → 0.7.3

package/dist/module.json

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

package/dist/module.mjs

@@ -271,8 +271,9 @@ function setupPrerenderHandler(dbPath, siteInfo, llmsTxtConfig) {
       const publicDataDir = join(nitro.options.output.publicDir, "__ai-ready");
       await mkdir(publicDataDir, { recursive: true });
       if (state.db) {
-        const pages = await queryAllPages(state.db);
-        const errorRoutesList = (await queryAllPages(state.db, { includeErrors: true })).filter((p) => p.isError).map((p) => p.route);
+        const allPages = await queryAllPages(state.db, { includeErrors: true, excludeMarkdown: true });
+        const pages = allPages.filter((p) => !p.isError);
+        const errorRoutesList = allPages.filter((p) => p.isError).map((p) => p.route);
         const jsonContent = JSON.stringify({
           pages: pages.map((p) => ({
             route: p.route,

package/dist/runtime/llms-txt-utils.js

@@ -127,20 +127,22 @@ Canonical Origin: ${siteConfig.url}`);
     parts.push(normalizedContent);
     parts.push("");
   }
-  const pages = await queryPages(event);
-  const urls = await fetchSitemapUrls(event);
-  const errorRoutes = await queryPages(event, { where: { hasError: true } });
-  const errorSet = new Set(errorRoutes.map((e) => e.route));
-  const devModeHint = import.meta.dev && pages.length === 0 ? " (dev mode - run `nuxi generate` for page titles)" : "";
-  const prerendered = [];
+  const [pages, errorPages, urls] = await Promise.all([
+    queryPages(event),
+    queryPages(event, { where: { hasError: true } }),
+    fetchSitemapUrls(event)
+  ]);
   const seenPaths = /* @__PURE__ */ new Set();
+  const errorSet = new Set(errorPages.map((p) => p.route));
+  const prerendered = [];
   for (const page of pages) {
-    prerendered.push({ pathname: page.route, title: page.title, description: page.description });
     seenPaths.add(page.route);
+    prerendered.push({ pathname: page.route, title: page.title, description: page.description });
   }
+  const devModeHint = import.meta.dev && prerendered.length === 0 ? " (dev mode - run `nuxi generate` for page titles)" : "";
   const other = [];
   for (const url of urls) {
-    const pathname = url.loc.startsWith("http") ? new URL(url.loc).pathname : url.loc;
+    const pathname = url.loc.startsWith("/") ? url.loc : new URL(url.loc).pathname;
     if (!seenPaths.has(pathname) && !errorSet.has(pathname)) {
       other.push({ pathname });
       seenPaths.add(pathname);

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

@@ -24,6 +24,7 @@ export interface PageEntry {
     headings: string;
     keywords: string[];
     updatedAt: string;
+    isError: boolean;
 }
 export interface PageData extends PageEntry {
     markdown: string;
@@ -162,3 +163,49 @@ export interface IndexNowStats {
  * Get IndexNow stats
  */
 export declare function getIndexNowStats(event: H3Event | undefined): Promise<IndexNowStats>;
+export interface CronRunRow {
+    id: number;
+    started_at: number;
+    finished_at: number | null;
+    duration_ms: number | null;
+    pages_indexed: number;
+    pages_remaining: number;
+    indexnow_submitted: number;
+    indexnow_remaining: number;
+    errors: string;
+    status: 'running' | 'success' | 'partial' | 'error';
+}
+export interface CronRun {
+    id: number;
+    startedAt: number;
+    finishedAt: number | null;
+    durationMs: number | null;
+    pagesIndexed: number;
+    pagesRemaining: number;
+    indexNowSubmitted: number;
+    indexNowRemaining: number;
+    errors: string[];
+    status: 'running' | 'success' | 'partial' | 'error';
+}
+/**
+ * Start a cron run and return its ID
+ */
+export declare function startCronRun(event: H3Event | undefined): Promise<number | null>;
+/**
+ * Complete a cron run with results
+ */
+export declare function completeCronRun(event: H3Event | undefined, runId: number, result: {
+    pagesIndexed: number;
+    pagesRemaining: number;
+    indexNowSubmitted: number;
+    indexNowRemaining: number;
+    errors: string[];
+}): Promise<void>;
+/**
+ * Get recent cron runs
+ */
+export declare function getRecentCronRuns(event: H3Event | undefined, limit?: number): Promise<CronRun[]>;
+/**
+ * Clean up old cron runs (keep last N)
+ */
+export declare function cleanupOldCronRuns(event: H3Event | undefined, keepCount?: number): Promise<number>;

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

@@ -29,13 +29,18 @@ async function getPrerenderDb() {
   const data = await m.readPageDataFromFilesystem();
   const pages = data.pages || [];
   const errorRoutes = new Set(data.errorRoutes || []);
+  const wantsMarkdown = (sql) => sql.includes("SELECT *") || sql.toLowerCase().includes("markdown");
   return {
     all: async (sql, params = []) => {
       const isErrorQuery = sql.includes("is_error = 1") || params.includes(1) && sql.includes("is_error");
       const excludeErrors = sql.includes("is_error = 0");
+      const includeMarkdown = wantsMarkdown(sql);
       if (isErrorQuery) {
         return pages.filter((p) => errorRoutes.has(p.route)).map((p) => ({
-          ...p,
+          route: p.route,
+          title: p.title,
+          description: p.description,
+          ...includeMarkdown ? { markdown: p.markdown } : {},
           headings: p.headings,
           keywords: JSON.stringify(p.keywords),
           updated_at: p.updatedAt,
@@ -48,7 +53,7 @@ async function getPrerenderDb() {
         route: p.route,
         title: p.title,
         description: p.description,
-        markdown: p.markdown,
+        ...includeMarkdown ? { markdown: p.markdown } : {},
         headings: p.headings,
         keywords: JSON.stringify(p.keywords),
         updated_at: p.updatedAt,
@@ -62,11 +67,12 @@ async function getPrerenderDb() {
         const page = pages.find((p) => p.route === route);
         if (!page)
           return void 0;
+        const includeMarkdown = wantsMarkdown(sql);
         return {
           route: page.route,
           title: page.title,
           description: page.description,
-          markdown: page.markdown,
+          ...includeMarkdown ? { markdown: page.markdown } : {},
           headings: page.headings,
           keywords: JSON.stringify(page.keywords),
           updated_at: page.updatedAt,
@@ -110,7 +116,8 @@ function rowToEntry(row) {
     description: row.description,
     headings: row.headings,
     keywords: JSON.parse(row.keywords || "[]"),
-    updatedAt: row.updated_at
+    updatedAt: row.updated_at,
+    isError: row.is_error === 1
   };
 }
 function rowToData(row) {
@@ -374,3 +381,76 @@ export async function getIndexNowStats(event) {
     lastError: stats.indexnow_last_error || null
   };
 }
+function rowToCronRun(row) {
+  return {
+    id: row.id,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    durationMs: row.duration_ms,
+    pagesIndexed: row.pages_indexed,
+    pagesRemaining: row.pages_remaining,
+    indexNowSubmitted: row.indexnow_submitted,
+    indexNowRemaining: row.indexnow_remaining,
+    errors: JSON.parse(row.errors || "[]"),
+    status: row.status
+  };
+}
+export async function startCronRun(event) {
+  const db = await getDb(event);
+  if (!db)
+    return null;
+  const now = Date.now();
+  await db.exec(
+    "INSERT INTO ai_ready_cron_runs (started_at, status) VALUES (?, ?)",
+    [now, "running"]
+  );
+  const row = await db.first("SELECT last_insert_rowid() as id");
+  return row?.id || null;
+}
+export async function completeCronRun(event, runId, result) {
+  const db = await getDb(event);
+  if (!db)
+    return;
+  const now = Date.now();
+  const row = await db.first("SELECT started_at FROM ai_ready_cron_runs WHERE id = ?", [runId]);
+  const durationMs = row ? now - row.started_at : null;
+  const status = result.errors.length > 0 ? result.pagesIndexed > 0 ? "partial" : "error" : "success";
+  await db.exec(`
+    UPDATE ai_ready_cron_runs SET
+      finished_at = ?,
+      duration_ms = ?,
+      pages_indexed = ?,
+      pages_remaining = ?,
+      indexnow_submitted = ?,
+      indexnow_remaining = ?,
+      errors = ?,
+      status = ?
+    WHERE id = ?
+  `, [now, durationMs, result.pagesIndexed, result.pagesRemaining, result.indexNowSubmitted, result.indexNowRemaining, JSON.stringify(result.errors), status, runId]);
+}
+export async function getRecentCronRuns(event, limit = 10) {
+  const db = await getDb(event);
+  if (!db)
+    return [];
+  const rows = await db.all(
+    "SELECT * FROM ai_ready_cron_runs ORDER BY started_at DESC LIMIT ?",
+    [limit]
+  );
+  return rows.map(rowToCronRun);
+}
+export async function cleanupOldCronRuns(event, keepCount = 50) {
+  const db = await getDb(event);
+  if (!db)
+    return 0;
+  const countRow = await db.first("SELECT COUNT(*) as count FROM ai_ready_cron_runs");
+  const total = countRow?.count || 0;
+  if (total <= keepCount)
+    return 0;
+  const deleteCount = total - keepCount;
+  await db.exec(`
+    DELETE FROM ai_ready_cron_runs WHERE id IN (
+      SELECT id FROM ai_ready_cron_runs ORDER BY started_at ASC LIMIT ?
+    )
+  `, [deleteCount]);
+  return deleteCount;
+}

package/dist/runtime/server/db/schema-sql.d.ts

@@ -1,3 +1,3 @@
-export declare const SCHEMA_VERSION = "v1.6.0";
+export declare const SCHEMA_VERSION = "v1.7.0";
 export declare const DROP_TABLES_SQL: string[];
 export declare const ALL_SCHEMA_SQL: string[];

package/dist/runtime/server/db/schema-sql.js

@@ -1,4 +1,4 @@
-export const SCHEMA_VERSION = "v1.6.0";
+export const SCHEMA_VERSION = "v1.7.0";
 const PAGES_TABLE_SQL = `
 CREATE TABLE IF NOT EXISTS ai_ready_pages (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -54,9 +54,24 @@ CREATE TABLE IF NOT EXISTS _ai_ready_info (
   checksum TEXT,
   ready INTEGER DEFAULT 0
 )`;
+const CRON_RUNS_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS ai_ready_cron_runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  started_at INTEGER NOT NULL,
+  finished_at INTEGER,
+  duration_ms INTEGER,
+  pages_indexed INTEGER DEFAULT 0,
+  pages_remaining INTEGER DEFAULT 0,
+  indexnow_submitted INTEGER DEFAULT 0,
+  indexnow_remaining INTEGER DEFAULT 0,
+  errors TEXT DEFAULT '[]',
+  status TEXT DEFAULT 'running'
+)`;
+const CRON_RUNS_INDEX_SQL = "CREATE INDEX IF NOT EXISTS idx_ai_ready_cron_runs_started ON ai_ready_cron_runs(started_at DESC)";
 export const DROP_TABLES_SQL = [
   "DROP TABLE IF EXISTS ai_ready_pages_fts",
   "DROP TABLE IF EXISTS ai_ready_pages",
+  "DROP TABLE IF EXISTS ai_ready_cron_runs",
   "DROP TABLE IF EXISTS _ai_ready_info",
   // Legacy unprefixed tables (migration from v1.0.0)
   "DROP TABLE IF EXISTS pages_fts",
@@ -67,5 +82,7 @@ export const ALL_SCHEMA_SQL = [
   ...PAGES_INDEXES_SQL,
   FTS_TABLE_SQL,
   ...FTS_TRIGGERS_SQL,
-  INFO_TABLE_SQL
+  INFO_TABLE_SQL,
+  CRON_RUNS_TABLE_SQL,
+  CRON_RUNS_INDEX_SQL
 ];

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

@@ -52,16 +52,37 @@ export interface PageOutput {
     updatedAt: string;
     isError: boolean;
 }
+export interface PageMetaOutput {
+    route: string;
+    title: string;
+    description: string;
+    headings: string;
+    keywords: string[];
+    contentHash?: string;
+    updatedAt: string;
+    isError: boolean;
+}
 /**
  * Insert or update a page
  */
 export declare function insertPage(db: DatabaseAdapter, page: PageInput): Promise<void>;
+export interface QueryAllPagesOptions {
+    includeErrors?: boolean;
+    excludeMarkdown?: boolean;
+}
 /**
  * Query all pages from database
+ * @param db - Database adapter
+ * @param options - Query options
+ * @param options.excludeMarkdown - If true, omit markdown field to reduce memory usage
  */
-export declare function queryAllPages(db: DatabaseAdapter, options?: {
-    includeErrors?: boolean;
+export declare function queryAllPages(db: DatabaseAdapter, options?: QueryAllPagesOptions & {
+    excludeMarkdown: true;
+}): Promise<PageMetaOutput[]>;
+export declare function queryAllPages(db: DatabaseAdapter, options?: QueryAllPagesOptions & {
+    excludeMarkdown?: false;
 }): Promise<PageOutput[]>;
+export declare function queryAllPages(db: DatabaseAdapter, options?: QueryAllPagesOptions): Promise<PageOutput[] | PageMetaOutput[]>;
 export interface DumpRow {
     route: string;
     route_key: string;
@@ -79,7 +100,8 @@ export interface DumpRow {
     last_seen_at: number | null;
 }
 /**
- * Export database as compressed dump (base64 gzip)
+ * Export database as compressed dump (base64 gzip) using batched streaming
+ * Processes rows in batches to avoid loading entire database into memory
  */
 export declare function exportDbDump(db: DatabaseAdapter): Promise<string>;
 /**

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

@@ -86,12 +86,13 @@ export async function insertPage(db, page) {
 }
 export async function queryAllPages(db, options) {
   const where = options?.includeErrors ? "" : "WHERE is_error = 0";
-  const rows = await db.all(`SELECT route, title, description, markdown, headings, keywords, content_hash, updated_at, is_error FROM ai_ready_pages ${where}`);
+  const fields = options?.excludeMarkdown ? "route, title, description, headings, keywords, content_hash, updated_at, is_error" : "route, title, description, markdown, headings, keywords, content_hash, updated_at, is_error";
+  const rows = await db.all(`SELECT ${fields} FROM ai_ready_pages ${where}`);
   return rows.map((row) => ({
     route: row.route,
     title: row.title,
     description: row.description,
-    markdown: row.markdown,
+    ...options?.excludeMarkdown ? {} : { markdown: row.markdown },
     headings: row.headings,
     keywords: JSON.parse(row.keywords || "[]"),
     contentHash: row.content_hash || void 0,
@@ -99,12 +100,53 @@ export async function queryAllPages(db, options) {
     isError: row.is_error === 1
   }));
 }
+const DUMP_BATCH_SIZE = 500;
 export async function exportDbDump(db) {
-  const rows = await db.all(`
-    SELECT route, route_key, title, description, markdown, headings, keywords, content_hash, updated_at, indexed_at, is_error, indexed, source, last_seen_at
-    FROM ai_ready_pages
-  `);
-  return compressToBase64(rows);
+  const encoder = new TextEncoder();
+  const chunks = [];
+  const compressionStream = new CompressionStream("gzip");
+  const writer = compressionStream.writable.getWriter();
+  const reader = compressionStream.readable.getReader();
+  const readPromise = (async () => {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      chunks.push(value);
+    }
+  })();
+  await writer.write(encoder.encode("["));
+  let offset = 0;
+  let first = true;
+  while (true) {
+    const rows = await db.all(`
+      SELECT route, route_key, title, description, markdown, headings, keywords, content_hash, updated_at, indexed_at, is_error, indexed, source, last_seen_at
+      FROM ai_ready_pages
+      ORDER BY route
+      LIMIT ${DUMP_BATCH_SIZE} OFFSET ${offset}
+    `);
+    if (rows.length === 0)
+      break;
+    for (const row of rows) {
+      const prefix = first ? "" : ",";
+      first = false;
+      await writer.write(encoder.encode(prefix + JSON.stringify(row)));
+    }
+    if (rows.length < DUMP_BATCH_SIZE)
+      break;
+    offset += DUMP_BATCH_SIZE;
+  }
+  await writer.write(encoder.encode("]"));
+  await writer.close();
+  await readPromise;
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let pos = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, pos);
+    pos += chunk.length;
+  }
+  return Buffer.from(result).toString("base64");
 }
 export async function importDbDump(db, rows) {
   for (const row of rows) {

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

@@ -13,7 +13,8 @@ export default defineEventHandler(async (event) => {
   const { path, isExplicit } = renderInfo;
   const config = useRuntimeConfig(event)["nuxt-ai-ready"];
   const response = await event.fetch(path, {
-    headers: { [INTERNAL_HEADER]: "1" }
+    headers: { [INTERNAL_HEADER]: "1" },
+    redirect: "manual"
   }).catch((e) => {
     logger.error(`Failed to fetch HTML for ${path}`, e);
     return null;
@@ -28,6 +29,17 @@ export default defineEventHandler(async (event) => {
     }
     return;
   }
+  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) {
     if (isExplicit) {
       return createError({

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

@@ -1,3 +1,15 @@
+interface CronRunInfo {
+    id: number;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+    status: string;
+    pagesIndexed: number;
+    pagesRemaining: number;
+    indexNowSubmitted: number;
+    indexNowRemaining: number;
+    errors: string[];
+}
 interface DebugInfo {
     version: string;
     environment: {
@@ -10,6 +22,19 @@ interface DebugInfo {
         cacheMaxAgeSeconds: number;
         mdreamOptions: unknown;
     };
+    runtimeSync?: {
+        total: number;
+        indexed: number;
+        pending: number;
+        sitemapSeededAt: string | null;
+    };
+    indexNow?: {
+        pending: number;
+        totalSubmitted: number;
+        lastSubmittedAt: string | null;
+        lastError: string | null;
+    };
+    cronRuns?: CronRunInfo[];
     pageData: {
         source: string;
         pageCount: number;

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 { queryPages } from "../db/queries.js";
+import { countPages, countPagesNeedingIndexNowSync, getIndexNowStats, getRecentCronRuns, getSitemapSeededAt, queryPages } from "../db/queries.js";
 export default eventHandler(async (event) => {
   const runtimeConfig = useRuntimeConfig(event)["nuxt-ai-ready"];
   if (!runtimeConfig.debug) {
@@ -19,8 +19,10 @@ export default eventHandler(async (event) => {
   } else {
     mode = "production";
   }
-  const pages = await queryPages(event);
-  const errorRoutes = await queryPages(event, { where: { hasError: true } });
+  const [pages, errorRoutes] = await Promise.all([
+    queryPages(event),
+    queryPages(event, { where: { hasError: true } })
+  ]);
   let source;
   if (isDev) {
     source = "empty (dev mode returns empty array)";
@@ -90,6 +92,47 @@ export default eventHandler(async (event) => {
     issues.push("Prerender mode but no pages found");
     suggestions.push("Check if pages.db exists in .data/ai-ready/");
   }
+  let runtimeSyncInfo;
+  let indexNowInfo;
+  let cronRunsInfo;
+  if (!isDev && !isPrerender) {
+    const [total, pending, sitemapSeededAt, cronRuns] = await Promise.all([
+      countPages(event),
+      countPages(event, { where: { pending: true } }),
+      getSitemapSeededAt(event),
+      getRecentCronRuns(event, 20)
+    ]);
+    runtimeSyncInfo = {
+      total,
+      indexed: total - pending,
+      pending,
+      sitemapSeededAt: sitemapSeededAt ? new Date(sitemapSeededAt).toISOString() : null
+    };
+    cronRunsInfo = cronRuns.map((run) => ({
+      id: run.id,
+      startedAt: new Date(run.startedAt).toISOString(),
+      finishedAt: run.finishedAt ? new Date(run.finishedAt).toISOString() : null,
+      durationMs: run.durationMs,
+      status: run.status,
+      pagesIndexed: run.pagesIndexed,
+      pagesRemaining: run.pagesRemaining,
+      indexNowSubmitted: run.indexNowSubmitted,
+      indexNowRemaining: run.indexNowRemaining,
+      errors: run.errors
+    }));
+    if (runtimeConfig.indexNowKey) {
+      const [indexNowPending, indexNowStats] = await Promise.all([
+        countPagesNeedingIndexNowSync(event),
+        getIndexNowStats(event)
+      ]);
+      indexNowInfo = {
+        pending: indexNowPending,
+        totalSubmitted: indexNowStats.totalSubmitted,
+        lastSubmittedAt: indexNowStats.lastSubmittedAt ? new Date(indexNowStats.lastSubmittedAt).toISOString() : null,
+        lastError: indexNowStats.lastError
+      };
+    }
+  }
   const debugInfo = {
     version: runtimeConfig.version || "unknown",
     environment: {
@@ -102,6 +145,9 @@ export default eventHandler(async (event) => {
       cacheMaxAgeSeconds: runtimeConfig.cacheMaxAgeSeconds,
       mdreamOptions: runtimeConfig.mdreamOptions
     },
+    runtimeSync: runtimeSyncInfo,
+    indexNow: indexNowInfo,
+    cronRuns: cronRunsInfo,
     pageData: {
       source,
       pageCount: pages.length,

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

@@ -1,5 +1,6 @@
 import type { H3Event } from 'h3';
 export interface CronResult {
+    runId?: number | null;
     index?: {
         indexed: number;
         remaining: number;

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

@@ -1,9 +1,13 @@
 import { useRuntimeConfig } from "nitropack/runtime";
+import { cleanupOldCronRuns, completeCronRun, startCronRun } from "../db/queries.js";
 import { batchIndexPages } from "./batchIndex.js";
 import { syncToIndexNow } from "./indexnow.js";
 export async function runCron(event, options) {
   const config = useRuntimeConfig()["nuxt-ai-ready"];
   const results = {};
+  const allErrors = [];
+  const runId = await startCronRun(event);
+  results.runId = runId;
   if (config.runtimeSync.enabled) {
     const limit = options?.batchSize ?? config.runtimeSync.batchSize;
     const indexResult = await batchIndexPages(event, {
@@ -16,6 +20,9 @@ export async function runCron(event, options) {
       errors: indexResult.errors.length > 0 ? indexResult.errors : void 0,
       complete: indexResult.complete
     };
+    if (indexResult.errors.length > 0) {
+      allErrors.push(...indexResult.errors);
+    }
   }
   if (config.indexNowKey) {
     const indexNowResult = await syncToIndexNow(event, 100).catch((err) => {
@@ -27,6 +34,19 @@ export async function runCron(event, options) {
       remaining: indexNowResult.remaining,
       error: indexNowResult.error
     };
+    if (indexNowResult.error) {
+      allErrors.push(`IndexNow: ${indexNowResult.error}`);
+    }
+  }
+  if (runId) {
+    await completeCronRun(event, runId, {
+      pagesIndexed: results.index?.indexed || 0,
+      pagesRemaining: results.index?.remaining || 0,
+      indexNowSubmitted: results.indexNow?.submitted || 0,
+      indexNowRemaining: results.indexNow?.remaining || 0,
+      errors: allErrors
+    });
+    await cleanupOldCronRuns(event, 50);
   }
   return results;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",