nuxt-ai-ready 1.7.6 → 1.7.8

package/dist/chunks/prerender.mjs

@@ -122,18 +122,7 @@ async function initCrawler(state) {
   if (state.dbPath) {
     logger.debug(`Creating directory for SQLite: ${dirname(state.dbPath)}`);
     await mkdir(dirname(state.dbPath), { recursive: true });
-    const { default: Database } = await import('better-sqlite3');
-    const sqlite = new Database(state.dbPath);
-    const db = {
-      all: async (sql, params = []) => sqlite.prepare(sql).all(...params),
-      first: async (sql, params = []) => sqlite.prepare(sql).get(...params),
-      exec: async (sql, params = []) => {
-        sqlite.prepare(sql).run(...params);
-      },
-      close: async () => {
-        sqlite.close();
-      }
-    };
+    const db = await createPrerenderDatabase(state.dbPath);
     state.db = db;
     await initSchema(db, { ftsTokenizer: state.ftsTokenizer });
     logger.debug(`Crawler initialized with SQLite at ${state.dbPath} (tokenizer: ${state.ftsTokenizer || "default"})`);
@@ -148,6 +137,38 @@ async function initCrawler(state) {
   }
   state.initialized = true;
 }
+async function createPrerenderDatabase(dbPath) {
+  const nodeVersion = Number.parseInt(process.versions.node?.split(".")[0] || "0");
+  if (nodeVersion >= 22) {
+    const { DatabaseSync } = await import('node:sqlite');
+    const sqlite2 = new DatabaseSync(dbPath);
+    return {
+      all: async (sql, params = []) => sqlite2.prepare(sql).all(...params),
+      first: async (sql, params = []) => sqlite2.prepare(sql).get(...params),
+      exec: async (sql, params = []) => {
+        if (params.length)
+          sqlite2.prepare(sql).run(...params);
+        else
+          sqlite2.exec(sql);
+      },
+      close: async () => {
+        sqlite2.close();
+      }
+    };
+  }
+  const { default: Database } = await import('better-sqlite3');
+  const sqlite = new Database(dbPath);
+  return {
+    all: async (sql, params = []) => sqlite.prepare(sql).all(...params),
+    first: async (sql, params = []) => sqlite.prepare(sql).get(...params),
+    exec: async (sql, params = []) => {
+      sqlite.prepare(sql).run(...params);
+    },
+    close: async () => {
+      sqlite.close();
+    }
+  };
+}
 function flattenHeadings(headings) {
   return (headings || []).map((h) => Object.entries(h).map(([tag, text]) => `${tag}:${text}`).join("")).join("|");
 }
@@ -488,4 +509,4 @@ function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, indexNo
   });
 }
 
-export { detectSitemapPrerender, setupPrerenderHandler };
+export { createPrerenderDatabase, detectSitemapPrerender, setupPrerenderHandler };

package/dist/module.json

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

package/dist/runtime/server/utils/cron-plan.d.ts

@@ -0,0 +1,15 @@
+import type { CronFastPathStatus } from '../db/queries.js';
+export interface CronPlanInput {
+    status: CronFastPathStatus;
+    runtimeSyncTtlSeconds: number;
+    indexNowEnabled: boolean;
+    staleCheckNeeded: boolean;
+    now: number;
+}
+export interface CronPlan {
+    hasWork: boolean;
+    runIndexNow: boolean;
+    sitemapIntervalMinutes: number;
+}
+export declare function resolveSitemapIntervalMinutes(runtimeSyncTtlSeconds: number): number;
+export declare function resolveCronPlan(input: CronPlanInput): CronPlan;

package/dist/runtime/server/utils/cron-plan.js

@@ -0,0 +1,13 @@
+export function resolveSitemapIntervalMinutes(runtimeSyncTtlSeconds) {
+  return Math.max(1, Math.ceil(runtimeSyncTtlSeconds / 60));
+}
+export function resolveCronPlan(input) {
+  const { status, indexNowEnabled, staleCheckNeeded, now } = input;
+  const indexNowInBackoff = status.indexNowBackoff !== null && now < status.indexNowBackoff.until;
+  const runIndexNow = indexNowEnabled && status.indexNowPending > 0 && !indexNowInBackoff;
+  return {
+    sitemapIntervalMinutes: resolveSitemapIntervalMinutes(input.runtimeSyncTtlSeconds),
+    runIndexNow,
+    hasWork: staleCheckNeeded || status.pendingPages > 0 || status.sitemapsNeedCrawl > 0 || runIndexNow
+  };
+}

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

@@ -3,6 +3,7 @@ import { completeCronRun, getCronFastPathStatus, getNextSitemapToCrawl, markSite
 import { logger } from "../logger.js";
 import { batchIndexPages } from "./batchIndex.js";
 import { checkAndHandleStale, STALE_CHECK_INTERVAL_MS } from "./checkStale.js";
+import { resolveCronPlan, resolveSitemapIntervalMinutes } from "./cron-plan.js";
 import { syncToIndexNow } from "./indexnow.js";
 import { crawlSitemapByRoute, getSitemapsFromConfig, mapSitemapRoutes } from "./sitemap.js";
 export async function runCron(event, options) {
@@ -13,6 +14,8 @@ export async function runCron(event, options) {
   const startTime = Date.now();
   const results = {};
   const allErrors = [];
+  const sitemapIntervalMinutes = resolveSitemapIntervalMinutes(config.runtimeSync.ttl);
+  let runIndexNow = !!config.indexNow;
   const acquired = await tryAcquireCronLock(event);
   if (!acquired) {
     if (debug) {
@@ -25,13 +28,19 @@ export async function runCron(event, options) {
   }
   try {
     if (config.runtimeSync.enabled) {
-      const status = await getCronFastPathStatus(event);
+      const status = await getCronFastPathStatus(event, sitemapIntervalMinutes);
       if (status) {
         const now = Date.now();
         const staleCheckNeeded = !status.lastStaleCheck || now - status.lastStaleCheck >= STALE_CHECK_INTERVAL_MS;
-        const inBackoff = status.indexNowBackoff && now < status.indexNowBackoff.until;
-        const hasWork = staleCheckNeeded || status.pendingPages > 0 || status.sitemapsNeedCrawl > 0 || config.indexNow && status.indexNowPending > 0 && !inBackoff;
-        if (!hasWork) {
+        const plan = resolveCronPlan({
+          status,
+          runtimeSyncTtlSeconds: config.runtimeSync.ttl,
+          indexNowEnabled: !!config.indexNow,
+          staleCheckNeeded,
+          now
+        });
+        runIndexNow = plan.runIndexNow;
+        if (!plan.hasWork) {
           if (debug) {
             const duration = Date.now() - startTime;
             logger.info(`[cron] Fast path: no work needed (${duration}ms)`);
@@ -58,7 +67,7 @@ export async function runCron(event, options) {
       }
     }
     if (config.runtimeSync.enabled) {
-      const sitemapResult = await pingSitemap(event, config, debug).catch((err) => {
+      const sitemapResult = await pingSitemap(event, config, sitemapIntervalMinutes, debug).catch((err) => {
         const msg = err instanceof Error ? err.message : String(err);
         logger.warn("[ai-ready:cron] Sitemap ping failed:", msg);
         allErrors.push(`sitemap: ${msg}`);
@@ -95,7 +104,7 @@ export async function runCron(event, options) {
         logger.info(`[cron] Index: ${indexResult.indexed} pages (${indexResult.remaining} remaining${indexResult.errors.length > 0 ? `, ${indexResult.errors.length} errors` : ""})`);
       }
     }
-    if (config.indexNow) {
+    if (runIndexNow) {
       const indexNowResult = await syncToIndexNow(event, 100).catch((err) => {
         logger.warn("[ai-ready:cron] IndexNow sync failed:", err.message);
         return { success: false, submitted: 0, remaining: 0, error: err.message };
@@ -145,14 +154,14 @@ export async function runCron(event, options) {
     });
   }
 }
-async function pingSitemap(event, config, debug) {
+async function pingSitemap(event, config, sitemapIntervalMinutes, debug) {
   const { pruneTtl } = config.runtimeSync;
   const sitemaps = getSitemapsFromConfig(event);
   if (sitemaps.length === 0) {
     sitemaps.push({ name: "sitemap.xml", route: "/sitemap.xml" });
   }
   await syncSitemaps(event, sitemaps);
-  const nextSitemap = await getNextSitemapToCrawl(event);
+  const nextSitemap = await getNextSitemapToCrawl(event, sitemapIntervalMinutes);
   if (!nextSitemap) {
     if (debug)
       logger.info("[cron] No sitemaps to ping");

package/package.json

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