nuxt-ai-ready 2.0.1 → 2.2.0

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

@@ -1,18 +1,41 @@
+import { randomUUID } from "uncrypto";
 import { getRequestURL } from "#nuxtseo/h3";
 import { useEvent, useRuntimeConfig } from "#nuxtseo/nitro";
-import { resolveLocaleFromRoute } from "../utils/i18n.js";
+import { createUniversalContext } from "../utils/context.js";
+import { hostMatchesLocaleDomain, resolveLocaleFromRoute } from "../utils/i18n.js";
 import { parseSitemapCrawlState, serializeSitemapCrawlState } from "../utils/sitemap-crawl-state.js";
 import { initSchema } from "./drizzle/queries.js";
 import { useRawDb } from "./drizzle/raw.js";
-import { normalizeRoute, normalizeRouteKey } from "./shared.js";
-function deriveLocale(event, route, explicit) {
+import { LIKE_ESCAPE, likeSubstring, maxRowsPerInsert, normalizeRoute, normalizeRouteKey } from "./shared.js";
+function hostFromUrl(url) {
+  if (!url)
+    return void 0;
+  try {
+    return new URL(url).host || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function deriveLocale(event, route, explicit, pageUrl) {
   if (explicit !== void 0)
     return explicit;
   const cfg = useRuntimeConfig(event);
   const i18n = cfg["nuxt-ai-ready"]?.i18n;
   if (!i18n)
     return "";
-  return resolveLocaleFromRoute(route, i18n, event ? { host: getRequestURL(event).host } : void 0).locale;
+  const entryHost = hostFromUrl(pageUrl);
+  if (entryHost)
+    return resolveLocaleFromRoute(route, i18n, { host: entryHost }).locale;
+  let requestHost;
+  if (event) {
+    try {
+      requestHost = getRequestURL(event).host;
+    } catch {
+      requestHost = void 0;
+    }
+  }
+  const host = requestHost && hostMatchesLocaleDomain(requestHost, i18n) ? requestHost : hostFromUrl(createUniversalContext(event).siteUrl);
+  return resolveLocaleFromRoute(route, i18n, host ? { host } : void 0).locale;
 }
 function getEventFromContext(providedEvent) {
   if (providedEvent)
@@ -24,7 +47,7 @@ function getEventFromContext(providedEvent) {
   }
 }
 let devWarningShown = false;
-let schemaInitialized = false;
+let schemaInitializationState = { _tag: "Uninitialized" };
 const RE_FTS_CHARS = /[*:^"()]/g;
 const RE_WHITESPACE = /\s+/;
 async function getDb(event) {
@@ -43,10 +66,17 @@ async function getDb(event) {
   if (cfg["nuxt-ai-ready"]?.database?._tag === "Disabled")
     return null;
   const db = await useRawDb(resolvedEvent);
-  if (!schemaInitialized) {
-    await initSchema(resolvedEvent);
-    schemaInitialized = true;
+  if (schemaInitializationState._tag === "Uninitialized") {
+    const promise = initSchema(resolvedEvent).then(() => {
+      schemaInitializationState = { _tag: "Initialized" };
+    }).catch((error) => {
+      schemaInitializationState = { _tag: "Uninitialized" };
+      throw error;
+    });
+    schemaInitializationState = { _tag: "Initializing", promise };
   }
+  if (schemaInitializationState._tag === "Initializing")
+    await schemaInitializationState.promise;
   return db;
 }
 async function getPrerenderDb() {
@@ -149,6 +179,12 @@ function safeJsonParse(json, fallback) {
     return fallback;
   }
 }
+function toNumber(value, fallback = 0) {
+  return value === null || value === void 0 ? fallback : Number(value);
+}
+function toNullableNumber(value) {
+  return value === null || value === void 0 ? null : Number(value);
+}
 function rowToEntry(row) {
   return {
     route: row.route,
@@ -195,7 +231,7 @@ export async function queryPages(event, options = {}) {
     return includeMarkdown ? rowToData(row) : rowToEntry(row);
   }
   const { sql: whereClause, params } = buildWhereClause(where);
-  let sql = `SELECT ${cols} FROM ai_ready_pages ${whereClause}`;
+  let sql = `SELECT ${cols} FROM ai_ready_pages ${whereClause} ORDER BY route`;
   if (limit) {
     sql += ` LIMIT ?`;
     params.push(limit);
@@ -238,7 +274,7 @@ export async function countPages(event, options = {}) {
     `SELECT COUNT(*) as count FROM ai_ready_pages ${whereClause}`,
     params
   );
-  return row?.count || 0;
+  return toNumber(row?.count);
 }
 export async function searchPages(event, query, options = {}) {
   if (import.meta.dev || import.meta.prerender)
@@ -250,6 +286,17 @@ export async function searchPages(event, query, options = {}) {
   const sanitized = query.replace(RE_FTS_CHARS, " ").trim();
   if (!sanitized)
     return [];
+  if (db.dialect === "postgres") {
+    const searchTerm = likeSubstring(sanitized);
+    return db.all(`
+      SELECT route, title, description, 0 AS score
+      FROM ai_ready_pages
+      WHERE is_error = 0
+        AND (title ILIKE ? ESCAPE ? OR description ILIKE ? ESCAPE ? OR markdown ILIKE ? ESCAPE ? OR headings ILIKE ? ESCAPE ?)
+      ORDER BY route
+      LIMIT ?
+    `, [searchTerm, LIKE_ESCAPE, searchTerm, LIKE_ESCAPE, searchTerm, LIKE_ESCAPE, searchTerm, LIKE_ESCAPE, limit]);
+  }
   const terms = sanitized.split(RE_WHITESPACE).map((t) => `${t}*`).join(" ");
   return db.all(`
     SELECT p.route, p.title, p.description, bm25(ai_ready_pages_fts, 5.0, 3.0, 1.0, 0.5, 2.0, 2.0) as score
@@ -271,9 +318,10 @@ export async function upsertPage(event, page) {
   const source = page.source || "runtime";
   const lastSeenAt = source === "runtime" ? indexedAt : null;
   const locale = deriveLocale(event, route, page.locale);
+  const localeTrusted = page.locale !== void 0;
   await db.exec(`
     INSERT INTO ai_ready_pages (route, route_key, title, description, markdown, headings, keywords, content_hash, updated_at, indexed_at, is_error, indexed, source, last_seen_at, locale)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(route) DO UPDATE SET
       title = excluded.title,
       description = excluded.description,
@@ -284,11 +332,11 @@ export async function upsertPage(event, page) {
       updated_at = excluded.updated_at,
       indexed_at = excluded.indexed_at,
       is_error = excluded.is_error,
-      indexed = 1,
+      indexed = excluded.indexed,
       source = excluded.source,
-      last_seen_at = excluded.last_seen_at,
-      locale = excluded.locale
-  `, [route, routeKey, page.title, page.description, page.markdown, page.headings, keywordsJson, page.contentHash || null, page.updatedAt, indexedAt, page.isError ? 1 : 0, source, lastSeenAt, locale]);
+      last_seen_at = excluded.last_seen_at${localeTrusted ? `,
+      locale = excluded.locale` : ""}
+  `, [route, routeKey, page.title, page.description, page.markdown, page.headings, keywordsJson, page.contentHash || null, page.updatedAt, indexedAt, page.isError ? 1 : 0, page.isError ? 0 : 1, source, lastSeenAt, locale]);
 }
 export async function isPageFresh(event, route, ttlSeconds) {
   if (ttlSeconds <= 0)
@@ -299,7 +347,7 @@ export async function isPageFresh(event, route, ttlSeconds) {
   const row = await db.first("SELECT indexed_at FROM ai_ready_pages WHERE route = ?", [route]);
   if (!row)
     return false;
-  const age = (Date.now() - row.indexed_at) / 1e3;
+  const age = (Date.now() - toNumber(row.indexed_at)) / 1e3;
   return age < ttlSeconds;
 }
 export async function getPageIndexState(event, route) {
@@ -310,7 +358,7 @@ export async function getPageIndexState(event, route) {
     "SELECT indexed_at, content_hash FROM ai_ready_pages WHERE route = ?",
     [route]
   );
-  return row ? { indexedAt: row.indexed_at, contentHash: row.content_hash } : void 0;
+  return row ? { indexedAt: toNumber(row.indexed_at), contentHash: row.content_hash } : void 0;
 }
 export async function getPageHash(event, route) {
   const db = await getDb(event);
@@ -335,22 +383,27 @@ export async function seedRoutes(event, routes) {
   for (const entry of routes) {
     const route = normalizeRoute(typeof entry === "string" ? entry : entry.route);
     const explicitLocale = typeof entry === "string" ? void 0 : entry.locale;
+    const entryUrl = typeof entry === "string" ? void 0 : entry.url;
     byRoute.set(route, {
       route,
       routeKey: normalizeRouteKey(route),
-      locale: deriveLocale(event, route, explicitLocale)
+      locale: deriveLocale(event, route, explicitLocale, entryUrl)
     });
   }
-  const ROWS_PER_INSERT = 20;
+  const rowsPerInsert = maxRowsPerInsert(5);
   const stmts = [];
-  for (const batch of chunk([...byRoute.values()], ROWS_PER_INSERT)) {
+  for (const batch of chunk([...byRoute.values()], rowsPerInsert)) {
     const valuesSql = batch.map(() => `(?, ?, '', '', '', '[]', '[]', ?, 0, 0, 0, 'runtime', ?, ?)`).join(", ");
     const params = batch.flatMap((r) => [r.route, r.routeKey, now, nowMs, r.locale]);
     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, locale)
         VALUES ${valuesSql}
-        ON CONFLICT(route) DO UPDATE SET last_seen_at = excluded.last_seen_at, locale = excluded.locale
+        ON CONFLICT(route) DO UPDATE SET
+          last_seen_at = excluded.last_seen_at,
+          locale = excluded.locale,
+          is_error = 0,
+          indexed = CASE WHEN ai_ready_pages.is_error = 1 THEN 0 ELSE ai_ready_pages.indexed END
       `,
       params
     });
@@ -358,19 +411,6 @@ export async function seedRoutes(event, routes) {
   await db.batch(stmts);
   return byRoute.size;
 }
-export async function getSitemapSeededAt(event) {
-  const db = await getDb(event);
-  if (!db)
-    return void 0;
-  const row = await db.first("SELECT value FROM _ai_ready_info WHERE id = ?", ["sitemap_seeded_at"]);
-  return row ? Number.parseInt(row.value, 10) : void 0;
-}
-export async function setSitemapSeededAt(event, timestamp) {
-  const db = await getDb(event);
-  if (!db)
-    return;
-  await db.exec("INSERT OR REPLACE INTO _ai_ready_info (id, value) VALUES (?, ?)", ["sitemap_seeded_at", String(timestamp)]);
-}
 export async function pruneStaleRoutes(event, staleThresholdSeconds, protectedSince) {
   const db = await getDb(event);
   if (!db)
@@ -381,7 +421,7 @@ export async function pruneStaleRoutes(event, staleThresholdSeconds, protectedSi
     "SELECT COUNT(*) as count FROM ai_ready_pages WHERE source = ? AND last_seen_at < ?",
     ["runtime", threshold]
   );
-  const count = countRow?.count || 0;
+  const count = toNumber(countRow?.count);
   if (count > 0) {
     await db.exec("DELETE FROM ai_ready_pages WHERE source = ? AND last_seen_at < ?", ["runtime", threshold]);
   }
@@ -401,11 +441,11 @@ export async function getStaleRoutes(event, staleThresholdSeconds) {
 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,
+    startedAt: toNumber(row.started_at),
+    finishedAt: toNullableNumber(row.finished_at),
+    durationMs: toNullableNumber(row.duration_ms),
+    pagesIndexed: toNumber(row.pages_indexed),
+    pagesRemaining: toNumber(row.pages_remaining),
     errors: safeJsonParse(row.errors, []),
     status: row.status
   };
@@ -415,12 +455,11 @@ export async function startCronRun(event) {
   if (!db)
     return null;
   const now = Date.now();
-  await db.exec(
-    "INSERT INTO ai_ready_cron_runs (started_at, status) VALUES (?, ?)",
+  const row = await db.first(
+    "INSERT INTO ai_ready_cron_runs (started_at, status) VALUES (?, ?) RETURNING id",
     [now, "running"]
   );
-  const row = await db.first("SELECT last_insert_rowid() as id");
-  return row?.id || null;
+  return row ? toNumber(row.id) : null;
 }
 export async function completeCronRun(event, runId, result) {
   const db = await getDb(event);
@@ -428,7 +467,7 @@ export async function completeCronRun(event, runId, result) {
     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 durationMs = row ? now - toNumber(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
@@ -451,22 +490,6 @@ export async function getRecentCronRuns(event, limit = 10) {
   );
   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;
-}
 export async function pruneCronRunsByAge(event, maxAgeMs = 24 * 60 * 60 * 1e3) {
   const db = await getDb(event);
   if (!db)
@@ -476,7 +499,7 @@ export async function pruneCronRunsByAge(event, maxAgeMs = 24 * 60 * 60 * 1e3) {
     "SELECT COUNT(*) as count FROM ai_ready_cron_runs WHERE started_at < ?",
     [threshold]
   );
-  const count = countRow?.count || 0;
+  const count = toNumber(countRow?.count);
   if (count > 0) {
     await db.exec("DELETE FROM ai_ready_cron_runs WHERE started_at < ?", [threshold]);
   }
@@ -498,33 +521,58 @@ export async function getCronFastPathStatus(event, sitemapIntervalMinutes = 5) {
   if (!row)
     return null;
   return {
-    totalPages: row.total_pages,
-    pendingPages: row.pending_pages,
+    totalPages: toNumber(row.total_pages),
+    pendingPages: toNumber(row.pending_pages),
     lastStaleCheck: row.last_stale_check ? Number.parseInt(row.last_stale_check, 10) : null,
     buildId: row.build_id,
-    sitemapsNeedCrawl: row.sitemaps_need_crawl
+    sitemapsNeedCrawl: toNumber(row.sitemaps_need_crawl)
   };
 }
 const CRON_LOCK_TTL_MS = 3e5;
+function cronLockField(db, column, key) {
+  if (db.dialect !== "postgres")
+    return `json_extract(${column}, '$.${key}')`;
+  const jsonb = `${column}::jsonb`;
+  return `CASE WHEN jsonb_typeof(${jsonb}) = 'object' THEN (${jsonb} ->> '${key}') END`;
+}
 export async function tryAcquireCronLock(event) {
+  const token = randomUUID();
   const db = await getDb(event);
   if (!db)
-    return true;
+    return { _tag: "acquired", token };
   const now = Date.now();
-  const staleThreshold = now - CRON_LOCK_TTL_MS;
-  await db.exec(`
-    INSERT INTO _ai_ready_info (id, value) VALUES ('cron_lock', ?)
-    ON CONFLICT(id) DO UPDATE SET value = ?
-    WHERE CAST(value AS INTEGER) < ?
-  `, [String(now), String(now), staleThreshold]);
-  const row = await db.first("SELECT value FROM _ai_ready_info WHERE id = ?", ["cron_lock"]);
-  return row?.value === String(now);
-}
-export async function releaseCronLock(event) {
+  const value = JSON.stringify({ t: token, a: now, e: now + CRON_LOCK_TTL_MS });
+  try {
+    await db.exec(`
+      INSERT INTO _ai_ready_info (id, value) VALUES ('cron_lock', ?)
+      ON CONFLICT(id) DO UPDATE SET value = excluded.value
+      WHERE CAST(coalesce(${cronLockField(db, "_ai_ready_info.value", "e")}, '0') AS BIGINT) < ?
+    `, [value, now]);
+    const row = await db.first(
+      `SELECT value FROM _ai_ready_info WHERE id = 'cron_lock' AND ${cronLockField(db, "value", "t")} = ?`,
+      [token]
+    );
+    return row ? { _tag: "acquired", token } : { _tag: "held" };
+  } catch (error) {
+    await releaseCronLock(event, token).catch(() => {
+    });
+    throw error;
+  }
+}
+export async function releaseCronLock(event, token) {
   const db = await getDb(event);
   if (!db)
     return;
-  await db.exec("DELETE FROM _ai_ready_info WHERE id = ?", ["cron_lock"]);
+  await db.exec(`DELETE FROM _ai_ready_info WHERE id = 'cron_lock' AND ${cronLockField(db, "value", "t")} = ?`, [token]);
+}
+const RE_CRON_LOCK_NUMERIC = /^\d+$/;
+function parseCronLockValue(value) {
+  if (RE_CRON_LOCK_NUMERIC.test(value))
+    return { acquiredAt: Number(value), expiresAt: Number(value) + CRON_LOCK_TTL_MS };
+  const parsed = safeJsonParse(value, null);
+  if (parsed && typeof parsed === "object" && typeof parsed.a === "number" && typeof parsed.e === "number")
+    return { acquiredAt: parsed.a, expiresAt: parsed.e };
+  return null;
 }
 export async function getCronLockStatus(event) {
   const db = await getDb(event);
@@ -536,14 +584,15 @@ export async function getCronLockStatus(event) {
   );
   if (!row)
     return { held: false, since: null, elapsedMs: null, stale: false };
-  const lockTime = Number.parseInt(row.value, 10);
+  const record = parseCronLockValue(row.value);
+  if (!record)
+    return { held: false, since: null, elapsedMs: null, stale: false };
   const now = Date.now();
-  const elapsed = now - lockTime;
-  const stale = elapsed >= CRON_LOCK_TTL_MS;
+  const stale = now >= record.expiresAt;
   return {
     held: !stale,
-    since: lockTime,
-    elapsedMs: elapsed,
+    since: record.acquiredAt,
+    elapsedMs: now - record.acquiredAt,
     stale
   };
 }
@@ -554,9 +603,9 @@ function rowToSitemapEntry(row) {
   return {
     name: row.name,
     route: row.route,
-    lastCrawledAt: row.last_crawled_at,
-    urlCount: row.url_count || 0,
-    errorCount: row.error_count || 0,
+    lastCrawledAt: toNullableNumber(row.last_crawled_at),
+    urlCount: toNumber(row.url_count),
+    errorCount: toNumber(row.error_count),
     lastError: row.last_error,
     crawlState: parsedState.state
   };
@@ -643,7 +692,7 @@ export async function getSitemapLastCrawledAt(event, name) {
     "SELECT last_crawled_at FROM ai_ready_sitemaps WHERE name = ?",
     [name]
   );
-  return row?.last_crawled_at ?? null;
+  return toNullableNumber(row?.last_crawled_at);
 }
 export async function markSitemapCrawled(event, name, urlCount) {
   const db = await getDb(event);
@@ -663,6 +712,8 @@ export async function markSitemapSeeded(event, name, urlCount, expectedLastCrawl
   const db = await getDb(event);
   if (!db)
     return;
+  const expectedClause = expectedLastCrawledAt === null ? "last_crawled_at IS NULL" : "last_crawled_at = ?";
+  const expectedParams = expectedLastCrawledAt === null ? [] : [expectedLastCrawledAt];
   await db.exec(`
     UPDATE ai_ready_sitemaps SET
       last_crawled_at = ?,
@@ -672,8 +723,8 @@ export async function markSitemapSeeded(event, name, urlCount, expectedLastCrawl
     WHERE name = ?
       AND crawl_state IS NULL
       AND error_count = 0
-      AND ((? IS NULL AND last_crawled_at IS NULL) OR last_crawled_at = ?)
-  `, [Date.now(), urlCount, name, expectedLastCrawledAt, expectedLastCrawledAt]);
+      AND ${expectedClause}
+  `, [Date.now(), urlCount, name, ...expectedParams]);
 }
 export async function markSitemapCrawlPartial(event, name, state) {
   const db = await getDb(event);
@@ -709,7 +760,7 @@ export async function resetSitemapErrors(event) {
   const countRow = await db.first(
     "SELECT COUNT(*) as count FROM ai_ready_sitemaps WHERE error_count > 0 OR crawl_state IS NOT NULL"
   );
-  const count = countRow?.count || 0;
+  const count = toNumber(countRow?.count);
   if (count > 0) {
     await db.exec("UPDATE ai_ready_sitemaps SET error_count = 0, last_error = NULL, last_crawled_at = NULL, crawl_state = NULL");
   }
@@ -733,7 +784,7 @@ export async function getRecentlyIndexedPages(event, limit = 10) {
     "SELECT route, title, indexed_at FROM ai_ready_pages WHERE indexed = 1 AND is_error = 0 ORDER BY indexed_at DESC LIMIT ?",
     [limit]
   );
-  return rows.map((r) => ({ route: r.route, title: r.title, indexedAt: r.indexed_at }));
+  return rows.map((r) => ({ route: r.route, title: r.title, indexedAt: toNumber(r.indexed_at) }));
 }
 export async function countRecentlyIndexed(event, sinceMs) {
   const db = await getDb(event);
@@ -744,5 +795,5 @@ export async function countRecentlyIndexed(event, sinceMs) {
     "SELECT COUNT(*) as count FROM ai_ready_pages WHERE indexed = 1 AND indexed_at > ?",
     [threshold]
   );
-  return row?.count || 0;
+  return toNumber(row?.count);
 }

package/dist/runtime/server/db/schema/postgres.d.ts

@@ -152,10 +152,10 @@ export declare const pages: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }>;
-        indexedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_pages", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>, {
+        indexedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_pages", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
             name: string;
             tableName: "ai_ready_pages";
-            dataType: "number int32";
+            dataType: "number int53";
             data: number;
             driverParam: string | number;
             notNull: true;
@@ -212,10 +212,10 @@ export declare const pages: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }>;
-        lastSeenAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_pages", import("drizzle-orm/pg-core").PgIntegerBuilder, {
+        lastSeenAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_pages", import("drizzle-orm/pg-core").PgBigInt53Builder, {
             name: string;
             tableName: "ai_ready_pages";
-            dataType: "number int32";
+            dataType: "number int53";
             data: number;
             driverParam: string | number;
             notNull: false;
@@ -346,10 +346,10 @@ export declare const cronRuns: import("drizzle-orm/pg-core").PgTableWithColumns<
             identity: undefined;
             generated: undefined;
         }>;
-        startedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_cron_runs", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>, {
+        startedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_cron_runs", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
             name: string;
             tableName: "ai_ready_cron_runs";
-            dataType: "number int32";
+            dataType: "number int53";
             data: number;
             driverParam: string | number;
             notNull: true;
@@ -361,10 +361,10 @@ export declare const cronRuns: import("drizzle-orm/pg-core").PgTableWithColumns<
             identity: undefined;
             generated: undefined;
         }>;
-        finishedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_cron_runs", import("drizzle-orm/pg-core").PgIntegerBuilder, {
+        finishedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_cron_runs", import("drizzle-orm/pg-core").PgBigInt53Builder, {
             name: string;
             tableName: "ai_ready_cron_runs";
-            dataType: "number int32";
+            dataType: "number int53";
             data: number;
             driverParam: string | number;
             notNull: false;
@@ -488,10 +488,10 @@ export declare const sitemaps: import("drizzle-orm/pg-core").PgTableWithColumns<
             identity: undefined;
             generated: undefined;
         }>;
-        lastCrawledAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_sitemaps", import("drizzle-orm/pg-core").PgIntegerBuilder, {
+        lastCrawledAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_sitemaps", import("drizzle-orm/pg-core").PgBigInt53Builder, {
             name: string;
             tableName: "ai_ready_sitemaps";
-            dataType: "number int32";
+            dataType: "number int53";
             data: number;
             driverParam: string | number;
             notNull: false;
@@ -721,10 +721,10 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }>;
-            indexedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_pages", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>, {
+            indexedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_pages", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
                 name: string;
                 tableName: "ai_ready_pages";
-                dataType: "number int32";
+                dataType: "number int53";
                 data: number;
                 driverParam: string | number;
                 notNull: true;
@@ -781,10 +781,10 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }>;
-            lastSeenAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_pages", import("drizzle-orm/pg-core").PgIntegerBuilder, {
+            lastSeenAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_pages", import("drizzle-orm/pg-core").PgBigInt53Builder, {
                 name: string;
                 tableName: "ai_ready_pages";
-                dataType: "number int32";
+                dataType: "number int53";
                 data: number;
                 driverParam: string | number;
                 notNull: false;
@@ -915,10 +915,10 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }>;
-            startedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_cron_runs", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>, {
+            startedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_cron_runs", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
                 name: string;
                 tableName: "ai_ready_cron_runs";
-                dataType: "number int32";
+                dataType: "number int53";
                 data: number;
                 driverParam: string | number;
                 notNull: true;
@@ -930,10 +930,10 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }>;
-            finishedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_cron_runs", import("drizzle-orm/pg-core").PgIntegerBuilder, {
+            finishedAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_cron_runs", import("drizzle-orm/pg-core").PgBigInt53Builder, {
                 name: string;
                 tableName: "ai_ready_cron_runs";
-                dataType: "number int32";
+                dataType: "number int53";
                 data: number;
                 driverParam: string | number;
                 notNull: false;
@@ -1057,10 +1057,10 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }>;
-            lastCrawledAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_sitemaps", import("drizzle-orm/pg-core").PgIntegerBuilder, {
+            lastCrawledAt: import("drizzle-orm/pg-core").PgBuildColumn<"ai_ready_sitemaps", import("drizzle-orm/pg-core").PgBigInt53Builder, {
                 name: string;
                 tableName: "ai_ready_sitemaps";
-                dataType: "number int32";
+                dataType: "number int53";
                 data: number;
                 driverParam: string | number;
                 notNull: false;

package/dist/runtime/server/db/schema/postgres.js

@@ -1,4 +1,4 @@
-import { index, integer, pgTable, serial, text } from "drizzle-orm/pg-core";
+import { bigint, index, integer, pgTable, serial, text } from "drizzle-orm/pg-core";
 export const pages = pgTable("ai_ready_pages", {
   id: serial("id").primaryKey(),
   route: text("route").unique().notNull(),
@@ -10,11 +10,11 @@ export const pages = pgTable("ai_ready_pages", {
   keywords: text("keywords").notNull().default("[]"),
   contentHash: text("content_hash"),
   updatedAt: text("updated_at").notNull(),
-  indexedAt: integer("indexed_at").notNull(),
+  indexedAt: bigint("indexed_at", { mode: "number" }).notNull(),
   isError: integer("is_error").notNull().default(0),
   indexed: integer("indexed").notNull().default(0),
   source: text("source").notNull().default("prerender"),
-  lastSeenAt: integer("last_seen_at"),
+  lastSeenAt: bigint("last_seen_at", { mode: "number" }),
   locale: text("locale").notNull().default("")
 }, (table) => [
   index("idx_ai_ready_pages_route").on(table.route),
@@ -33,8 +33,8 @@ export const info = pgTable("_ai_ready_info", {
 });
 export const cronRuns = pgTable("ai_ready_cron_runs", {
   id: serial("id").primaryKey(),
-  startedAt: integer("started_at").notNull(),
-  finishedAt: integer("finished_at"),
+  startedAt: bigint("started_at", { mode: "number" }).notNull(),
+  finishedAt: bigint("finished_at", { mode: "number" }),
   durationMs: integer("duration_ms"),
   pagesIndexed: integer("pages_indexed").default(0),
   pagesRemaining: integer("pages_remaining").default(0),
@@ -46,7 +46,7 @@ export const cronRuns = pgTable("ai_ready_cron_runs", {
 export const sitemaps = pgTable("ai_ready_sitemaps", {
   name: text("name").primaryKey(),
   route: text("route").notNull(),
-  lastCrawledAt: integer("last_crawled_at"),
+  lastCrawledAt: bigint("last_crawled_at", { mode: "number" }),
   urlCount: integer("url_count").default(0),
   errorCount: integer("error_count").default(0),
   lastError: text("last_error"),

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

@@ -44,6 +44,22 @@ export declare function initSchema(db: DatabaseAdapter, options?: InitSchemaOpti
  * one row. Widening it would let both spellings persist and race for the key.
  */
 export declare function normalizeRoute(route: string): string;
+/**
+ * Escape LIKE/ILIKE wildcard characters in a search term so the term matches
+ * literal text. Pair with an `ESCAPE` clause (see `LIKE_ESCAPE`): SQLite has no
+ * default escape character, so without the clause the escaping is inert.
+ */
+export declare function escapeLikeTerm(term: string): string;
+/** Substring LIKE/ILIKE pattern for a term, with wildcards escaped. */
+export declare function likeSubstring(term: string): string;
+/** Escape character to bind next to `likeSubstring` patterns. */
+export declare const LIKE_ESCAPE = "\\";
+/**
+ * Multi-row INSERT chunk size that keeps one statement within the 100-bind
+ * cap shared by SQLite and D1, derived from the row's bind count so an added
+ * column resizes the chunk instead of breaking the insert.
+ */
+export declare function maxRowsPerInsert(paramsPerRow: number): number;
 /**
  * Normalize route to storage key format
  * e.g., '/about/team' -> 'about:team', '/' -> 'index'