nuxt-ai-ready 1.7.5 → 1.7.7

package/dist/chunks/agent-skills.mjs

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { realpath, readFile } from 'node:fs/promises';
 import { resolve, isAbsolute, relative, sep } from 'node:path';
 import { parseDocument } from 'yaml';
-import { A as AGENT_SKILLS_SCHEMA } from '../shared/nuxt-ai-ready.CDEc2X7T.mjs';
+import { A as AGENT_SKILLS_SCHEMA } from '../shared/nuxt-ai-ready.DJimiOHi.mjs';
 import 'node:module';
 import '@nuxt/kit';
 import 'defu';

package/dist/chunks/prerender.mjs

@@ -2,9 +2,10 @@ import { mkdir, writeFile, appendFile, stat, readdir } from 'node:fs/promises';
 import { join, dirname, relative, resolve } from 'node:path';
 import { useNuxt, hasNuxtModule, resolveFiles } from '@nuxt/kit';
 import { colorize } from 'consola/utils';
+import { resolveLocaleFromRoute } from 'nuxtseo-shared/i18n-runtime';
 import { collectSitemap } from 'sitemapd/parse';
 import { withLeadingSlash, withBase, joinURL } from 'ufo';
-import { l as logger, M as MARKDOWN_LINK_AVAILABILITY_FILE } from '../shared/nuxt-ai-ready.CDEc2X7T.mjs';
+import { l as logger, M as MARKDOWN_LINK_AVAILABILITY_FILE } from '../shared/nuxt-ai-ready.DJimiOHi.mjs';
 import { normalizePagePath, toMarkdownPath } from '../../dist/runtime/markdown-path.js';
 import { toLogicalRoute, toDeployedRoute } from '../../dist/runtime/route-path.js';
 import { initSchema, computeContentHash, insertPage, queryAllPages, exportDbDump } from '../../dist/runtime/server/db/shared.js';
@@ -151,14 +152,7 @@ function flattenHeadings(headings) {
   return (headings || []).map((h) => Object.entries(h).map(([tag, text]) => `${tag}:${text}`).join("")).join("|");
 }
 function resolveRouteLocale(route, i18n) {
-  if (!i18n)
-    return "";
-  if (i18n.strategy === "no_prefix")
-    return i18n.defaultLocale;
-  const segments = route.split("/").filter(Boolean);
-  const first = segments[0];
-  const matched = first ? i18n.locales.find((l) => l.code === first) : void 0;
-  return matched ? matched.code : i18n.defaultLocale;
+  return i18n ? resolveLocaleFromRoute(route, i18n).locale : "";
 }
 async function processMarkdownRoute(state, nuxt, route, parsed, lastmod, options) {
   route = normalizePagePath(route);

package/dist/module.d.mts

@@ -1,6 +1,7 @@
 import * as _nuxt_schema from '@nuxt/schema';
 import { LlmsTxtConfig, ContentNegotiationPolicy, ModuleOptions } from '../dist/runtime/types.js';
 export { AgentSkillConfig, AgentSkillsConfig, AgentSkillsIndex, AgentSkillsIndexEntry, ApiCatalogConfig, ApiCatalogEntry, ApiCatalogLinkTarget, ApiCatalogLinks, ExternalAgentSkillConfig, LocalAgentSkillConfig, McpServerCardConfig, ModuleOptions } from '../dist/runtime/types.js';
+import { RuntimeI18nConfig } from 'nuxtseo-shared/i18n-runtime';
 import { ResolvedWebMcpToolsConfig } from '../dist/runtime/site-tool-config.js';
 export { GetPageMarkdownToolOptions, ListPagesToolOptions, McpSiteToolAttachmentOptions, SearchPagesToolOptions, SiteToolOptions, SiteToolsConfig, WebMcpSiteToolAttachmentOptions } from '../dist/runtime/site-tool-config.js';
 import { AiCatalog } from '../dist/runtime/server/utils/discovery-response.js';
@@ -86,16 +87,7 @@ interface ModulePublicRuntimeConfig {
     runtimeSyncSecret?: string;
     indexNow?: string;
     sitemapPrerendered: boolean;
-    i18n?: {
-        defaultLocale: string;
-        strategy: 'no_prefix' | 'prefix_except_default' | 'prefix' | 'prefix_and_default';
-        locales: Array<{
-            code: string;
-            hreflang: string;
-            name?: string;
-            nativeName?: string;
-        }>;
-    } | null;
+    i18n?: RuntimeI18nConfig | null;
     ftsTokenizer?: string;
     aiCatalog?: {
         cacheMaxAge: number;

package/dist/module.json

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

package/dist/module.mjs

@@ -7,7 +7,7 @@ import 'defu';
 import 'nuxt-site-config/kit';
 import 'nuxtseo-shared/kit';
 import 'pkg-types';
-export { m as default } from './shared/nuxt-ai-ready.CDEc2X7T.mjs';
+export { m as default } from './shared/nuxt-ai-ready.DJimiOHi.mjs';
 import '../dist/runtime/server/utils/discovery-response.js';
 import 'node:url';
 import 'pathe';

package/dist/runtime/llms-txt-format.d.ts

@@ -1,9 +1,9 @@
 /**
  * Pure formatting functions for llms.txt - no runtime dependencies
  */
-import type { RuntimeI18nConfig } from './server/utils/i18n.js';
+import type { RuntimeI18nConfig, RuntimeRouteContext } from './server/utils/i18n.js';
 import type { LlmsTxtConfig } from './types.js';
-export declare function formatAvailableLanguagesSection(i18n: RuntimeI18nConfig, pageCounts: Map<string, number>, resolveHref?: (pathname: string) => string): string[];
+export declare function formatAvailableLanguagesSection(i18n: RuntimeI18nConfig, pageCounts: Map<string, number>, resolveHref?: (pathname: string) => string, routeContext?: RuntimeRouteContext): string[];
 interface LlmsTxtPageLink {
     pathname: string;
     href?: string;

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

@@ -1,4 +1,4 @@
-import { localePath } from "./server/utils/i18n.js";
+import { computeLocaleAlternates, localePath, resolveLocaleAlternateUrl } from "./server/utils/i18n.js";
 const RE_INLINE_WHITESPACE = /\s+/g;
 const RE_LINK_TITLE_BRACKET = /[[\]]/g;
 const RE_LINK_HREF_UNSAFE = /[\s()]/g;
@@ -62,17 +62,21 @@ function normalizeOptionalSections(sections) {
 function normalizeRequiredSections(sections) {
   return sections.filter((section) => section.links?.length).map(normalizeSection);
 }
-export function formatAvailableLanguagesSection(i18n, pageCounts, resolveHref = (pathname) => pathname) {
+export function formatAvailableLanguagesSection(i18n, pageCounts, resolveHref = (pathname) => pathname, routeContext = {}) {
   const lines = ["## Available Languages on Website", ""];
+  const rootAlternates = new Map(computeLocaleAlternates("/", i18n, routeContext).map((alternate) => [alternate.code, alternate]));
   for (const locale of i18n.locales) {
     const isDefault = locale.code === i18n.defaultLocale;
-    const prefix = localePath("/", locale.code, i18n);
+    const alternate = rootAlternates.get(locale.code);
+    const prefix = alternate?.path ?? localePath("/", locale.code, i18n, routeContext);
+    const resolvedPath = resolveHref(prefix);
+    const href = alternate ? resolveLocaleAlternateUrl({ ...alternate, path: resolvedPath }, (candidate) => candidate) : resolvedPath;
     const count = pageCounts.get(locale.code) ?? 0;
     const display = locale.nativeName ? `${locale.nativeName} (${locale.code})` : locale.name ? `${locale.name} (${locale.code})` : locale.code;
     const suffix = isDefault ? "content included below" : "visit this language for content";
     lines.push(normalizeLink({
       title: display,
-      href: resolveHref(prefix),
+      href,
       description: `${count} pages; ${suffix}.`
     }));
   }

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

@@ -1,4 +1,5 @@
 import { decodePath } from "ufo";
+import { getRequestURL } from "#nuxtseo/h3";
 import { useRuntimeConfig } from "#nuxtseo/nitro";
 import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 import { withSiteTrailingSlash, withSiteUrl } from "#site-config/server/composables/utils";
@@ -122,6 +123,7 @@ export async function buildLlmsTxt(event) {
   const siteConfig = getSiteConfig(event);
   const llmsTxtConfig = aiReadyConfig.llmsTxt;
   const i18n = aiReadyConfig.i18n;
+  const i18nContext = { host: getRequestURL(event).host };
   const baseURL = runtimeConfig.app.baseURL;
   const resolvePath = (path) => withSiteTrailingSlash(event, toDeployedRoute(path, baseURL));
   const resolveUrl = (path) => withSiteUrl(event, toDeployedRoute(path, baseURL));
@@ -192,7 +194,7 @@ Canonical Origin: ${canonicalSiteUrl}`);
   const other = [];
   for (const pathname of sitemapPaths) {
     if (!seenPaths.has(pathname) && !errorSet.has(pathname)) {
-      const locale = i18n ? resolveLocaleFromRoute(pathname, i18n).locale : void 0;
+      const locale = i18n ? resolveLocaleFromRoute(pathname, i18n, i18nContext).locale : void 0;
       other.push({ pathname, locale });
       seenPaths.add(pathname);
     }
@@ -215,16 +217,16 @@ Canonical Origin: ${canonicalSiteUrl}`);
     const pageCounts = /* @__PURE__ */ new Map();
     for (const locale of i18n.locales) pageCounts.set(locale.code, 0);
     for (const p of [...prerendered, ...other]) {
-      const code = p.locale || resolveLocaleFromRoute(p.pathname, i18n).locale;
+      const code = p.locale || resolveLocaleFromRoute(p.pathname, i18n, i18nContext).locale;
       pageCounts.set(code, (pageCounts.get(code) ?? 0) + 1);
     }
-    parts.push(...formatAvailableLanguagesSection(i18n, pageCounts, resolvePageHref));
+    parts.push(...formatAvailableLanguagesSection(i18n, pageCounts, resolvePageHref, i18nContext));
     parts.push("");
   }
   const isDefaultLocale = (item) => {
     if (!i18n)
       return true;
-    const code = item.locale || resolveLocaleFromRoute(item.pathname, i18n).locale;
+    const code = item.locale || resolveLocaleFromRoute(item.pathname, i18n, i18nContext).locale;
     return code === i18n.defaultLocale;
   };
   const filteredPrerendered = i18n ? prerendered.filter(isDefaultLocale) : prerendered;

package/dist/runtime/server/db/drizzle/index.d.ts

@@ -4,7 +4,7 @@
 export * from '#ai-ready-virtual/db-schema.mjs';
 export { closeDrizzle, useDrizzle } from './client.js';
 export type { DatabaseDialect, DrizzleDatabase } from './client.js';
-export { completeCronRun, countPages, countPagesNeedingIndexNowSync, deleteInfoValue, deletePage, getAllPages, getContentHashes, getInfoValue, getNextSitemapToCrawl, getPageByRoute, getPageLastmods, getPagesNeedingIndexNowSync, getPendingPages, getRecentCronRuns, getSitemapStatus, initSchema, markIndexNowSynced, markPageIndexed, markRoutesPending, markSitemapCrawled, markSitemapError, resetSitemapErrors, searchPages, seedRoutes, setInfoValue, startCronRun, syncSitemaps, upsertPage, } from './queries.js';
+export { completeCronRun, countPages, countPagesNeedingIndexNowSync, deleteInfoValue, deletePage, getAllPages, getContentHashes, getInfoValue, getNextSitemapToCrawl, getPageByRoute, getPageLastmods, getPagesNeedingIndexNowSync, getPendingPages, getRecentCronRuns, getSitemapStatus, initSchema, markIndexNowSynced, markPageIndexed, markRoutesPending, markSitemapCrawled, markSitemapCrawlPartial, markSitemapError, markSitemapSeeded, resetSitemapErrors, searchPages, seedRoutes, setInfoValue, startCronRun, syncSitemaps, upsertPage, } from './queries.js';
 export type { CronRunOutput, PageInput, PageMetaOutput, PageOutput, SitemapOutput, } from './queries.js';
 export { useRawDb } from './raw.js';
 export type { RawExecutor } from './raw.js';

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

@@ -21,7 +21,9 @@ export {
   markPageIndexed,
   markRoutesPending,
   markSitemapCrawled,
+  markSitemapCrawlPartial,
   markSitemapError,
+  markSitemapSeeded,
   resetSitemapErrors,
   searchPages,
   seedRoutes,

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

@@ -1,4 +1,5 @@
 import type { H3Event } from '#nuxtseo/h3';
+import type { SitemapCrawlState } from '../../utils/sitemap-crawl-state.js';
 export interface PageInput {
     route: string;
     title: string;
@@ -155,6 +156,10 @@ export interface SitemapOutput {
     urlCount: number;
     errorCount: number;
     lastError: string | null;
+    continuing: boolean;
+}
+interface SitemapEntry extends Omit<SitemapOutput, 'continuing'> {
+    crawlState: SitemapCrawlState | null;
 }
 /**
  * Sync sitemaps from config
@@ -169,11 +174,15 @@ export declare function syncSitemaps(event: H3Event | undefined, sitemapList: Ar
 /**
  * Get next sitemap to crawl
  */
-export declare function getNextSitemapToCrawl(event: H3Event | undefined, minIntervalMinutes?: number): Promise<SitemapOutput | null>;
+export declare function getNextSitemapToCrawl(event: H3Event | undefined, minIntervalMinutes?: number): Promise<SitemapEntry | null>;
 /**
  * Mark sitemap as crawled
  */
 export declare function markSitemapCrawled(event: H3Event | undefined, name: string, urlCount: number): Promise<void>;
+/** Record a deferred sitemap hook seed only when no crawl is in progress. */
+export declare function markSitemapSeeded(event: H3Event | undefined, name: string, urlCount: number, expectedLastCrawledAt: number | null): Promise<void>;
+/** Persist a resumable sitemap crawl without incrementing its error budget. */
+export declare function markSitemapCrawlPartial(event: H3Event | undefined, name: string, state: SitemapCrawlState): Promise<void>;
 /**
  * Mark sitemap error
  */
@@ -190,3 +199,4 @@ export declare function resetSitemapErrors(event: H3Event | undefined): Promise<
  * Seed routes from sitemap
  */
 export declare function seedRoutes(event: H3Event | undefined, routes: string[]): Promise<number>;
+export {};

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

@@ -1,8 +1,10 @@
-import { and, count, desc, eq, gt, isNull, like, lt, or, sql } from "drizzle-orm";
+import { and, count, desc, eq, gt, isNotNull, isNull, like, lt, or, sql } from "drizzle-orm";
 import { cronRuns, info, pages, sitemaps } from "#ai-ready-virtual/db-schema.mjs";
 import { useRuntimeConfig } from "#nuxtseo/nitro";
+import { parseSitemapCrawlState, serializeSitemapCrawlState } from "../../utils/sitemap-crawl-state.js";
 import { resolveFtsTokenizer as validateFtsTokenizer } from "../schema-sql.js";
 import { useDrizzle } from "./client.js";
+import { useRawDb } from "./raw.js";
 function resolveFtsTokenizer(event) {
   const cfg = useRuntimeConfig(event);
   return validateFtsTokenizer(cfg["nuxt-ai-ready"]?.ftsTokenizer);
@@ -76,12 +78,22 @@ export async function upsertPage(event, page) {
 }
 export async function getAllPages(event, options) {
   const client = await useDrizzle(event);
-  let query = client.db.select().from(pages);
+  const cols = options?.excludeMarkdown ? {
+    route: pages.route,
+    title: pages.title,
+    description: pages.description,
+    headings: pages.headings,
+    keywords: pages.keywords,
+    contentHash: pages.contentHash,
+    updatedAt: pages.updatedAt,
+    isError: pages.isError
+  } : void 0;
+  let query = cols ? client.db.select(cols).from(pages) : client.db.select().from(pages);
   if (!options?.includeErrors) {
     query = query.where(eq(pages.isError, 0));
   }
   const rows = await query;
-  return rows.map((row) => options?.excludeMarkdown ? rowToMeta(row) : rowToPage(row));
+  return rows.map((row) => cols ? rowToMeta(row) : rowToPage(row));
 }
 export async function getPageByRoute(event, route) {
   const client = await useDrizzle(event);
@@ -178,8 +190,18 @@ export async function markPageIndexed(event, route) {
 export async function markRoutesPending(event, routes) {
   if (routes.length === 0)
     return;
-  const client = await useDrizzle(event);
-  await client.db.update(pages).set({ indexed: 0 }).where(sql`${pages.route} IN (${sql.join(routes.map((r) => sql`${r}`), sql`, `)})`);
+  const db = await useRawDb(event);
+  const stmts = [];
+  const D1_MAX_IN_ROUTES = 99;
+  for (let i = 0; i < routes.length; i += D1_MAX_IN_ROUTES) {
+    const batch = routes.slice(i, i + D1_MAX_IN_ROUTES);
+    const placeholders = batch.map(() => "?").join(",");
+    stmts.push({
+      sql: `UPDATE ai_ready_pages SET indexed = 0 WHERE route IN (${placeholders})`,
+      params: batch
+    });
+  }
+  await db.batch(stmts);
 }
 export async function getContentHashes(event) {
   const client = await useDrizzle(event);
@@ -202,7 +224,7 @@ export async function deleteInfoValue(event, key) {
   const client = await useDrizzle(event);
   await client.db.delete(info).where(eq(info.id, key));
 }
-const SCHEMA_VERSION = "v2.1.0-drizzle";
+const SCHEMA_VERSION = "v2.2.0-drizzle";
 export async function initSchema(event) {
   const client = await useDrizzle(event);
   const tokenizer = resolveFtsTokenizer(event);
@@ -331,7 +353,8 @@ async function createSQLiteTables(client, ftsTokenizer) {
       last_crawled_at INTEGER,
       url_count INTEGER DEFAULT 0,
       error_count INTEGER DEFAULT 0,
-      last_error TEXT
+      last_error TEXT,
+      crawl_state TEXT
     )`,
     // Indexes
     sql`CREATE INDEX IF NOT EXISTS idx_ai_ready_pages_route ON ai_ready_pages(route)`,
@@ -345,7 +368,9 @@ async function createSQLiteTables(client, ftsTokenizer) {
       route, title, description, markdown, headings, keywords,
       content=ai_ready_pages, content_rowid=id, tokenize='${ftsTokenizer}'
     )`),
-    // FTS triggers
+    // FTS triggers. The UPDATE trigger only fires when a searchable column
+    // actually changed; updates to bookkeeping columns (indexed, indexed_at,
+    // indexnow_synced_at, last_seen_at…) skip the delete+reinsert FTS churn.
     sql`CREATE TRIGGER IF NOT EXISTS ai_ready_pages_ai AFTER INSERT ON ai_ready_pages BEGIN
       INSERT INTO ai_ready_pages_fts(rowid, route, title, description, markdown, headings, keywords)
       VALUES (new.id, new.route, new.title, new.description, new.markdown, new.headings, new.keywords);
@@ -354,7 +379,14 @@ async function createSQLiteTables(client, ftsTokenizer) {
       INSERT INTO ai_ready_pages_fts(ai_ready_pages_fts, rowid, route, title, description, markdown, headings, keywords)
       VALUES('delete', old.id, old.route, old.title, old.description, old.markdown, old.headings, old.keywords);
     END`,
-    sql`CREATE TRIGGER IF NOT EXISTS ai_ready_pages_au AFTER UPDATE ON ai_ready_pages BEGIN
+    sql`CREATE TRIGGER IF NOT EXISTS ai_ready_pages_au AFTER UPDATE ON ai_ready_pages
+      WHEN old.route IS NOT new.route
+        OR old.title IS NOT new.title
+        OR old.description IS NOT new.description
+        OR old.markdown IS NOT new.markdown
+        OR old.headings IS NOT new.headings
+        OR old.keywords IS NOT new.keywords
+      BEGIN
       INSERT INTO ai_ready_pages_fts(ai_ready_pages_fts, rowid, route, title, description, markdown, headings, keywords)
       VALUES('delete', old.id, old.route, old.title, old.description, old.markdown, old.headings, old.keywords);
       INSERT INTO ai_ready_pages_fts(rowid, route, title, description, markdown, headings, keywords)
@@ -418,7 +450,8 @@ async function createPostgresTables(client) {
       last_crawled_at INTEGER,
       url_count INTEGER DEFAULT 0,
       error_count INTEGER DEFAULT 0,
-      last_error TEXT
+      last_error TEXT,
+      crawl_state TEXT
     )`,
     // Indexes
     sql`CREATE INDEX IF NOT EXISTS idx_ai_ready_pages_route ON ai_ready_pages(route)`,
@@ -462,17 +495,19 @@ export async function countPagesNeedingIndexNowSync(event) {
 export async function markIndexNowSynced(event, routes) {
   if (routes.length === 0)
     return;
-  const client = await useDrizzle(event);
   const now = Date.now();
+  const db = await useRawDb(event);
+  const stmts = [];
   const D1_MAX_IN_ROUTES = 99;
   for (let i = 0; i < routes.length; i += D1_MAX_IN_ROUTES) {
     const batch = routes.slice(i, i + D1_MAX_IN_ROUTES);
     const placeholders = batch.map(() => "?").join(",");
-    await client.db.run(
-      sql.raw(`UPDATE ai_ready_pages SET indexnow_synced_at = ? WHERE route IN (${placeholders})`),
-      [now, ...batch]
-    );
+    stmts.push({
+      sql: `UPDATE ai_ready_pages SET indexnow_synced_at = ? WHERE route IN (${placeholders})`,
+      params: [now, ...batch]
+    });
   }
+  await db.batch(stmts);
 }
 function rowToCronRun(row) {
   return {
@@ -517,19 +552,24 @@ export async function getRecentCronRuns(event, limit = 10) {
   return rows.map(rowToCronRun);
 }
 function rowToSitemap(row) {
+  const parsedState = parseSitemapCrawlState(row.crawlState ?? null);
+  if (parsedState._tag === "error")
+    throw new Error(`Invalid crawl state for sitemap ${row.name}: ${parsedState.error}`);
   return {
     name: row.name,
     route: row.route,
     lastCrawledAt: row.lastCrawledAt,
     urlCount: row.urlCount || 0,
     errorCount: row.errorCount || 0,
-    lastError: row.lastError
+    lastError: row.lastError,
+    crawlState: parsedState.state
   };
 }
 export async function syncSitemaps(event, sitemapList) {
   const client = await useDrizzle(event);
-  const existing = await client.db.select({ name: sitemaps.name }).from(sitemaps);
+  const existing = await client.db.select({ name: sitemaps.name, route: sitemaps.route }).from(sitemaps);
   const existingNames = new Set(existing.map((r) => r.name));
+  const existingRoutes = new Map(existing.map((row) => [row.name, row.route]));
   const configNames = new Set(sitemapList.map((s) => s.name));
   let added = 0;
   let removed = 0;
@@ -537,6 +577,15 @@ export async function syncSitemaps(event, sitemapList) {
     if (!existingNames.has(sitemap.name)) {
       await client.db.insert(sitemaps).values({ name: sitemap.name, route: sitemap.route });
       added++;
+    } else if (existingRoutes.get(sitemap.name) !== sitemap.route) {
+      await client.db.update(sitemaps).set({
+        route: sitemap.route,
+        lastCrawledAt: null,
+        urlCount: 0,
+        errorCount: 0,
+        lastError: null,
+        crawlState: null
+      }).where(eq(sitemaps.name, sitemap.name));
     }
   }
   for (const name of existingNames) {
@@ -550,6 +599,12 @@ export async function syncSitemaps(event, sitemapList) {
 export async function getNextSitemapToCrawl(event, minIntervalMinutes = 5) {
   const client = await useDrizzle(event);
   const threshold = Date.now() - minIntervalMinutes * 60 * 1e3;
+  const continuationRow = await client.db.select().from(sitemaps).where(and(
+    isNotNull(sitemaps.crawlState),
+    eq(sitemaps.errorCount, 0)
+  )).orderBy(sitemaps.lastCrawledAt).limit(1);
+  if (continuationRow.length)
+    return rowToSitemap(continuationRow[0]);
   const errorRow = await client.db.select().from(sitemaps).where(
     and(
       gt(sitemaps.errorCount, 0),
@@ -574,12 +629,37 @@ export async function getNextSitemapToCrawl(event, minIntervalMinutes = 5) {
   return row.length ? rowToSitemap(row[0]) : null;
 }
 export async function markSitemapCrawled(event, name, urlCount) {
+  const client = await useDrizzle(event);
+  await client.db.update(sitemaps).set({
+    lastCrawledAt: Date.now(),
+    urlCount,
+    errorCount: 0,
+    lastError: null,
+    crawlState: null
+  }).where(eq(sitemaps.name, name));
+}
+export async function markSitemapSeeded(event, name, urlCount, expectedLastCrawledAt) {
   const client = await useDrizzle(event);
   await client.db.update(sitemaps).set({
     lastCrawledAt: Date.now(),
     urlCount,
     errorCount: 0,
     lastError: null
+  }).where(and(
+    eq(sitemaps.name, name),
+    isNull(sitemaps.crawlState),
+    eq(sitemaps.errorCount, 0),
+    expectedLastCrawledAt === null ? isNull(sitemaps.lastCrawledAt) : eq(sitemaps.lastCrawledAt, expectedLastCrawledAt)
+  ));
+}
+export async function markSitemapCrawlPartial(event, name, state) {
+  const client = await useDrizzle(event);
+  await client.db.update(sitemaps).set({
+    lastCrawledAt: Date.now(),
+    urlCount: state.urlsObserved,
+    errorCount: 0,
+    lastError: null,
+    crawlState: serializeSitemapCrawlState(state)
   }).where(eq(sitemaps.name, name));
 }
 export async function markSitemapError(event, name, error) {
@@ -587,23 +667,31 @@ export async function markSitemapError(event, name, error) {
   await client.db.update(sitemaps).set({
     lastCrawledAt: Date.now(),
     errorCount: sql`${sitemaps.errorCount} + 1`,
-    lastError: error
+    lastError: error,
+    crawlState: null
   }).where(eq(sitemaps.name, name));
 }
 export async function getSitemapStatus(event) {
   const client = await useDrizzle(event);
   const rows = await client.db.select().from(sitemaps).orderBy(sitemaps.name);
-  return rows.map(rowToSitemap);
+  return rows.map((row) => {
+    const { crawlState, ...entry } = rowToSitemap(row);
+    return { ...entry, continuing: crawlState !== null };
+  });
 }
 export async function resetSitemapErrors(event) {
   const client = await useDrizzle(event);
-  const countResult = await client.db.select({ count: count() }).from(sitemaps).where(gt(sitemaps.errorCount, 0));
+  const countResult = await client.db.select({ count: count() }).from(sitemaps).where(or(
+    gt(sitemaps.errorCount, 0),
+    sql`${sitemaps.crawlState} IS NOT NULL`
+  ));
   const errorCount = countResult[0]?.count || 0;
   if (errorCount > 0) {
     await client.db.update(sitemaps).set({
       errorCount: 0,
       lastError: null,
-      lastCrawledAt: null
+      lastCrawledAt: null,
+      crawlState: null
     });
   }
   return errorCount;
@@ -611,29 +699,28 @@ export async function resetSitemapErrors(event) {
 export async function seedRoutes(event, routes) {
   if (routes.length === 0)
     return 0;
-  const client = await useDrizzle(event);
+  const byRoute = /* @__PURE__ */ new Map();
+  for (const route of routes)
+    byRoute.set(route, normalizeRouteKey(route));
+  const ROWS_PER_INSERT = 20;
+  const db = await useRawDb(event);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const nowMs = Date.now();
-  for (const route of routes) {
-    const values = {
-      route,
-      routeKey: normalizeRouteKey(route),
-      title: "",
-      description: "",
-      markdown: "",
-      headings: "[]",
-      keywords: "[]",
-      updatedAt: now,
-      indexedAt: 0,
-      isError: 0,
-      indexed: 0,
-      source: "runtime",
-      lastSeenAt: nowMs
-    };
-    await client.db.insert(pages).values(values).onConflictDoUpdate({
-      target: pages.route,
-      set: { lastSeenAt: nowMs }
+  const entries = [...byRoute.entries()];
+  const stmts = [];
+  for (let i = 0; i < entries.length; i += ROWS_PER_INSERT) {
+    const batch = entries.slice(i, i + ROWS_PER_INSERT);
+    const valuesSql = batch.map(() => `(?, ?, '', '', '', '[]', '[]', ?, 0, 0, 0, 'runtime', ?)`).join(", ");
+    const params = batch.flatMap(([route, routeKey]) => [route, routeKey, now, nowMs]);
+    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)
+        VALUES ${valuesSql}
+        ON CONFLICT(route) DO UPDATE SET last_seen_at = excluded.last_seen_at
+      `,
+      params
     });
   }
-  return routes.length;
+  await db.batch(stmts);
+  return byRoute.size;
 }

package/dist/runtime/server/db/drizzle/raw.d.ts

@@ -16,6 +16,14 @@ export declare function getRawExecutor(client: DrizzleDatabase): {
     all<T = Record<string, unknown>>(query: string, params?: unknown[]): Promise<T[]>;
     first<T = Record<string, unknown>>(query: string, params?: unknown[]): Promise<T | undefined>;
     exec(query: string, params?: unknown[]): Promise<void>;
+    /**
+     * Execute many statements in as few round-trips as the driver allows.
+     * Statements run in order; on a remote driver each chunk is one request.
+     */
+    batch(queries: {
+        sql: string;
+        params?: unknown[];
+    }[]): Promise<void>;
 };
 export type RawExecutor = ReturnType<typeof getRawExecutor>;
 /**

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

@@ -4,6 +4,7 @@ export function registerDriver(db, type, driver) {
   driverCache.set(db, { type, driver });
 }
 const RE_PARAM_PLACEHOLDER = /\?/g;
+const MAX_BATCH_STATEMENTS = 100;
 export function getRawExecutor(client) {
   const cached = driverCache.get(client.db);
   if (!cached) {
@@ -66,6 +67,54 @@ export function getRawExecutor(client) {
           break;
         }
       }
+    },
+    /**
+     * Execute many statements in as few round-trips as the driver allows.
+     * Statements run in order; on a remote driver each chunk is one request.
+     */
+    async batch(queries) {
+      if (queries.length === 0)
+        return;
+      switch (type) {
+        case "better-sqlite3": {
+          const sqlite = driver;
+          const tx = sqlite.transaction(() => {
+            for (const q of queries)
+              sqlite.prepare(q.sql).run(...q.params || []);
+          });
+          tx();
+          break;
+        }
+        case "libsql": {
+          const client2 = driver;
+          for (let i = 0; i < queries.length; i += MAX_BATCH_STATEMENTS) {
+            const chunk = queries.slice(i, i + MAX_BATCH_STATEMENTS);
+            await client2.batch(chunk.map((q) => ({ sql: q.sql, args: q.params || [] })));
+          }
+          break;
+        }
+        case "d1": {
+          const db = driver;
+          for (let i = 0; i < queries.length; i += MAX_BATCH_STATEMENTS) {
+            const chunk = queries.slice(i, i + MAX_BATCH_STATEMENTS);
+            await db.batch(chunk.map((q) => db.prepare(q.sql).bind(...q.params || [])));
+          }
+          break;
+        }
+        case "neon": {
+          const sqlFn = driver;
+          for (let i = 0; i < queries.length; i += MAX_BATCH_STATEMENTS) {
+            const chunk = queries.slice(i, i + MAX_BATCH_STATEMENTS);
+            const pgQueries = chunk.map((q) => {
+              let idx = 0;
+              const pgQuery = q.sql.replace(RE_PARAM_PLACEHOLDER, () => `$${++idx}`);
+              return sqlFn.query(pgQuery, q.params || []);
+            });
+            await sqlFn.transaction(pgQueries);
+          }
+          break;
+        }
+      }
     }
   };
 }