nuxt-ai-ready 2.0.1 → 2.1.0

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.D8qbnNrv.mjs';
+import { A as AGENT_SKILLS_SCHEMA } from '../shared/nuxt-ai-ready.BTQAkSYt.mjs';
 import 'node:module';
 import '@nuxt/kit';
 import 'defu';

package/dist/chunks/prerender.mjs

@@ -5,7 +5,7 @@ import { colorize } from 'consola/utils';
 import { resolveLocaleFromRoute } from 'nuxtseo-shared/i18n-runtime';
 import { collectSitemap } from 'sitemapd/parse';
 import { withLeadingSlash, joinURL, withBase } from 'ufo';
-import { l as logger, s as supportsNativeNodeSqlite, M as MARKDOWN_LINK_AVAILABILITY_FILE } from '../shared/nuxt-ai-ready.D8qbnNrv.mjs';
+import { l as logger, s as supportsNativeNodeSqlite, M as MARKDOWN_LINK_AVAILABILITY_FILE } from '../shared/nuxt-ai-ready.BTQAkSYt.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';

package/dist/module.d.mts

@@ -31,7 +31,7 @@ interface ResolvedApiCatalogConfig {
     };
 }
 
-type DatabaseType = 'sqlite' | 'bun' | 'd1' | 'libsql' | 'neon';
+type DatabaseType = 'sqlite' | 'bun' | 'd1' | 'libsql' | 'neon' | 'postgres';
 /**
  * Database state after parsing. Every consumer reads `_tag` first, so a
  * disabled database can never carry a driver, a path, or credentials.

package/dist/module.json

@@ -4,7 +4,7 @@
     "nuxt": ">=4.0.0"
   },
   "configKey": "aiReady",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "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.D8qbnNrv.mjs';
+export { m as default } from './shared/nuxt-ai-ready.BTQAkSYt.mjs';
 import '../dist/runtime/server/utils/discovery-response.js';
 import 'node:url';
 import 'pathe';

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

@@ -1 +1,3 @@
 export declare const DB_CONTEXT_KEY = "_aiReadyDrizzle";
+export declare const DB_PROMISE_CONTEXT_KEY = "_aiReadyDrizzlePromise";
+export declare const DB_WORK_CONTEXT_KEY = "_aiReadyDrizzleWork";

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

@@ -1 +1,3 @@
 export const DB_CONTEXT_KEY = "_aiReadyDrizzle";
+export const DB_PROMISE_CONTEXT_KEY = "_aiReadyDrizzlePromise";
+export const DB_WORK_CONTEXT_KEY = "_aiReadyDrizzleWork";

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

@@ -4,14 +4,19 @@ import type { DrizzleD1Database } from 'drizzle-orm/d1';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import type { NeonHttpDatabase } from 'drizzle-orm/neon-http';
 import type { NodeSQLiteDatabase } from 'drizzle-orm/node-sqlite';
+import type { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 import type { H3Event } from '#nuxtseo/h3';
 export type DatabaseDialect = 'sqlite' | 'postgres';
 type SQLiteDB = BetterSQLite3Database | SQLiteBunDatabase | LibSQLDatabase | DrizzleD1Database | NodeSQLiteDatabase;
-type PostgresDB = NeonHttpDatabase;
+type PostgresDB = NeonHttpDatabase | PostgresJsDatabase;
 export interface DrizzleDatabase {
     dialect: DatabaseDialect;
     db: SQLiteDB | PostgresDB;
 }
+/** Keep request-scoped clients alive until deferred database work finishes. */
+export declare function trackDrizzleWork<T>(event: H3Event, work: Promise<T>): Promise<T>;
+/** Transfer client cleanup to deferred work after the response ends. */
+export declare function finishDrizzleResponse(event: H3Event): Promise<void>;
 /**
  * Get Drizzle database instance
  */

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

@@ -1,29 +1,82 @@
-import { DB_CONTEXT_KEY } from "../context.js";
+import { DB_CONTEXT_KEY, DB_PROMISE_CONTEXT_KEY, DB_WORK_CONTEXT_KEY } from "../context.js";
 import { closeDriver } from "./raw.js";
 let fallbackClient;
+let fallbackClientPromise;
+function createDrizzleClient(event) {
+  return import("#ai-ready-virtual/db-provider.mjs").then(({ createClient }) => createClient(event));
+}
+function getDrizzleWorkState(event) {
+  const context = event.context;
+  return context[DB_WORK_CONTEXT_KEY] ??= {
+    _tag: "ResponseOpen",
+    pending: /* @__PURE__ */ new Set()
+  };
+}
+export function trackDrizzleWork(event, work) {
+  const state = getDrizzleWorkState(event);
+  const tracked = work.finally(async () => {
+    state.pending.delete(tracked);
+    if (state._tag === "ResponseEnded" && state.pending.size === 0)
+      await closeDrizzle(event);
+  });
+  state.pending.add(tracked);
+  return tracked;
+}
+export async function finishDrizzleResponse(event) {
+  const state = getDrizzleWorkState(event);
+  state._tag = "ResponseEnded";
+  if (state.pending.size === 0)
+    await closeDrizzle(event);
+}
 export async function useDrizzle(event) {
   if (event?.context?.[DB_CONTEXT_KEY]) {
     return event.context[DB_CONTEXT_KEY];
   }
+  if (event?.context?.[DB_PROMISE_CONTEXT_KEY]) {
+    return event.context[DB_PROMISE_CONTEXT_KEY];
+  }
   if (!event && fallbackClient) {
     return fallbackClient;
   }
-  const { createClient } = await import("#ai-ready-virtual/db-provider.mjs");
-  const client = await createClient(event);
+  if (!event && fallbackClientPromise)
+    return fallbackClientPromise;
   if (event?.context) {
-    event.context[DB_CONTEXT_KEY] = client;
-  } else {
-    fallbackClient = client;
+    const context = event.context;
+    const promise2 = createDrizzleClient(event).then((client) => {
+      context[DB_CONTEXT_KEY] = client;
+      return client;
+    }).finally(() => {
+      if (context[DB_PROMISE_CONTEXT_KEY] === promise2)
+        delete context[DB_PROMISE_CONTEXT_KEY];
+    });
+    context[DB_PROMISE_CONTEXT_KEY] = promise2;
+    return promise2;
   }
-  return client;
+  const promise = createDrizzleClient().then((client) => {
+    fallbackClient = client;
+    return client;
+  }).finally(() => {
+    if (fallbackClientPromise === promise)
+      fallbackClientPromise = void 0;
+  });
+  fallbackClientPromise = promise;
+  return promise;
 }
 export async function closeDrizzle(event) {
-  if (event?.context?.[DB_CONTEXT_KEY]) {
-    const client = event.context[DB_CONTEXT_KEY];
-    closeDriver(client.db);
-    delete event.context[DB_CONTEXT_KEY];
-  } else if (!event && fallbackClient) {
-    closeDriver(fallbackClient.db);
+  if (event?.context) {
+    const context = event.context;
+    const client = context[DB_CONTEXT_KEY] ?? await context[DB_PROMISE_CONTEXT_KEY];
+    if (!client)
+      return;
+    await closeDriver(client.db);
+    delete context[DB_CONTEXT_KEY];
+    delete context[DB_PROMISE_CONTEXT_KEY];
+  } else if (!event) {
+    const client = fallbackClient ?? await fallbackClientPromise;
+    if (!client)
+      return;
+    await closeDriver(client.db);
     fallbackClient = void 0;
+    fallbackClientPromise = void 0;
   }
 }

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

@@ -2,7 +2,7 @@
  * Drizzle ORM database layer for nuxt-ai-ready
  */
 export * from '#ai-ready-virtual/db-schema.mjs';
-export { closeDrizzle, useDrizzle } from './client.js';
+export { closeDrizzle, finishDrizzleResponse, trackDrizzleWork, useDrizzle } from './client.js';
 export type { DatabaseDialect, DrizzleDatabase } from './client.js';
 export { completeCronRun, countPages, deleteInfoValue, deletePage, getAllPages, getContentHashes, getInfoValue, getNextSitemapToCrawl, getPageByRoute, getPageLastmods, getPendingPages, getRecentCronRuns, getSitemapStatus, initSchema, 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';

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

@@ -1,5 +1,5 @@
 export * from "#ai-ready-virtual/db-schema.mjs";
-export { closeDrizzle, useDrizzle } from "./client.js";
+export { closeDrizzle, finishDrizzleResponse, trackDrizzleWork, useDrizzle } from "./client.js";
 export {
   completeCronRun,
   countPages,

package/dist/runtime/server/db/drizzle/providers/dbPath.js

@@ -36,7 +36,7 @@ export async function resolveWritableDbPath(dbPath) {
   const fallbackErr = await ensureWritableDir(fallbackDir);
   if (fallbackErr) {
     throw new Error(
-      `[ai-ready] Database directory '${dir}' is not writable (${err.code}) and the temp dir fallback ('${fallbackDir}') also failed: ${fallbackErr.message}. Set database.filename to a writable path, or use a serverless driver: database.type 'd1' (Cloudflare), 'neon' (Vercel/Postgres), or 'libsql' (Turso).`
+      `[ai-ready] Database directory '${dir}' is not writable (${err.code}) and the temp dir fallback ('${fallbackDir}') also failed: ${fallbackErr.message}. Set database.filename to a writable path, or use a remote driver: database.type 'd1' (Cloudflare), 'neon' (Vercel), 'postgres' (PostgreSQL), or 'libsql' (Turso).`
     );
   }
   const fallback = join(fallbackDir, "pages.db");

package/dist/runtime/server/db/drizzle/providers/postgres.d.ts

@@ -0,0 +1,8 @@
+import type { H3Event } from '#nuxtseo/h3';
+import postgres from 'postgres';
+export declare function createClient(event?: H3Event): Promise<{
+    dialect: "postgres";
+    db: import("drizzle-orm/postgres-js").PostgresJsDatabase<import("drizzle-orm").EmptyRelations> & {
+        $client: postgres.Sql<{}>;
+    };
+}>;

package/dist/runtime/server/db/drizzle/providers/postgres.js

@@ -0,0 +1,17 @@
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import { useRuntimeConfig } from "#nuxtseo/nitro";
+import { logger } from "../../../logger.js";
+import { registerDriver } from "../raw.js";
+export async function createClient(event) {
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  const connectionString = config.database.url || process.env.POSTGRES_URL || process.env.DATABASE_URL;
+  if (!connectionString) {
+    throw new Error("[ai-ready] Missing database URL. Set DATABASE_URL or configure database.url");
+  }
+  logger.debug("[drizzle] Connecting to PostgreSQL");
+  const sqlClient = postgres(connectionString, { prepare: false });
+  const db = drizzle({ client: sqlClient });
+  registerDriver(db, "postgres", sqlClient);
+  return { dialect: "postgres", db };
+}

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

@@ -100,7 +100,7 @@ export declare function setInfoValue(event: H3Event | undefined, key: string, va
  */
 export declare function deleteInfoValue(event: H3Event | undefined, key: string): Promise<void>;
 /**
- * Initialize database schema. Rebuilds on SCHEMA_VERSION change or when the
+ * Initialize database schema. Rebuilds on a schema version change or when the
  * SQLite FTS5 tokenizer differs from the one baked into the existing virtual
  * table (Postgres has no FTS5; tokenizer comparison is SQLite-only).
  */

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

@@ -4,7 +4,7 @@ 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";
+import { getRawExecutor, useRawDb } from "./raw.js";
 function resolveFtsTokenizer(event) {
   const cfg = useRuntimeConfig(event);
   return validateFtsTokenizer(cfg["nuxt-ai-ready"]?.ftsTokenizer);
@@ -229,16 +229,23 @@ 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.3.0-drizzle";
+const SQLITE_SCHEMA_VERSION = "v2.3.0-drizzle";
+const LEGACY_POSTGRES_INTEGER_SCHEMA_VERSION = "v2.3.0-drizzle";
+const POSTGRES_SCHEMA_VERSION = "v2.3.0-drizzle-postgres-bigint";
 export async function initSchema(event) {
   const client = await useDrizzle(event);
   const tokenizer = resolveFtsTokenizer(event);
+  const schemaVersion = client.dialect === "postgres" ? POSTGRES_SCHEMA_VERSION : SQLITE_SCHEMA_VERSION;
   const currentVersion = await getSchemaVersion(client);
   const currentTokenizer = client.dialect === "postgres" ? null : await getStoredTokenizer(client);
-  const versionMatches = currentVersion === SCHEMA_VERSION;
+  const versionMatches = currentVersion === schemaVersion;
   const tokenizerMatches = client.dialect === "postgres" || !currentTokenizer || currentTokenizer === tokenizer;
   if (versionMatches && tokenizerMatches)
     return;
+  if (client.dialect === "postgres" && currentVersion === LEGACY_POSTGRES_INTEGER_SCHEMA_VERSION) {
+    await migratePostgresIntegerTimestamps(client);
+    return;
+  }
   if (currentVersion) {
     if (client.dialect === "postgres") {
       await dropPostgresTables(client);
@@ -251,9 +258,9 @@ export async function initSchema(event) {
   } else {
     await createSQLiteTables(client, tokenizer);
   }
-  await client.db.insert(info).values({ id: "schema", version: SCHEMA_VERSION }).onConflictDoUpdate({
+  await client.db.insert(info).values({ id: "schema", version: schemaVersion }).onConflictDoUpdate({
     target: info.id,
-    set: { version: SCHEMA_VERSION }
+    set: { version: schemaVersion }
   });
   if (client.dialect !== "postgres") {
     await client.db.insert(info).values({ id: "fts_tokenizer", value: tokenizer }).onConflictDoUpdate({
@@ -264,23 +271,38 @@ export async function initSchema(event) {
 }
 async function getSchemaVersion(client) {
   try {
-    const result = await client.db.all(
-      sql`SELECT version FROM _ai_ready_info WHERE id = 'schema'`
-    );
-    return result?.[0]?.version || null;
-  } catch {
-    return null;
+    const [row] = await client.db.select({ version: info.version }).from(info).where(eq(info.id, "schema")).limit(1);
+    return row?.version || null;
+  } catch (error) {
+    if (isMissingInfoTableError(error))
+      return null;
+    throw error;
   }
 }
 async function getStoredTokenizer(client) {
   try {
-    const result = await client.db.all(
-      sql`SELECT value FROM _ai_ready_info WHERE id = 'fts_tokenizer'`
-    );
-    return result?.[0]?.value || null;
-  } catch {
-    return null;
+    const [row] = await client.db.select({ value: info.value }).from(info).where(eq(info.id, "fts_tokenizer")).limit(1);
+    return row?.value || null;
+  } catch (error) {
+    if (isMissingInfoTableError(error))
+      return null;
+    throw error;
+  }
+}
+function isMissingInfoTableError(error) {
+  let current = error;
+  const seen = /* @__PURE__ */ new Set();
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const candidate = current;
+    if (candidate.code === "42P01")
+      return true;
+    if (typeof candidate.message === "string" && candidate.message.includes("no such table") && candidate.message.includes("_ai_ready_info")) {
+      return true;
+    }
+    current = candidate.cause;
   }
+  return false;
 }
 const SQLITE_DROP_STATEMENTS = [
   sql`DROP TABLE IF EXISTS ai_ready_pages_fts`,
@@ -305,6 +327,19 @@ async function dropPostgresTables(client) {
   for (const stmt of POSTGRES_DROP_STATEMENTS)
     await client.db.execute(stmt);
 }
+async function migratePostgresIntegerTimestamps(client) {
+  await getRawExecutor(client).batch([
+    { sql: "ALTER TABLE ai_ready_pages ALTER COLUMN indexed_at TYPE BIGINT USING indexed_at::BIGINT" },
+    { sql: "ALTER TABLE ai_ready_pages ALTER COLUMN last_seen_at TYPE BIGINT USING last_seen_at::BIGINT" },
+    { sql: "ALTER TABLE ai_ready_cron_runs ALTER COLUMN started_at TYPE BIGINT USING started_at::BIGINT" },
+    { sql: "ALTER TABLE ai_ready_cron_runs ALTER COLUMN finished_at TYPE BIGINT USING finished_at::BIGINT" },
+    { sql: "ALTER TABLE ai_ready_sitemaps ALTER COLUMN last_crawled_at TYPE BIGINT USING last_crawled_at::BIGINT" },
+    {
+      sql: "UPDATE _ai_ready_info SET version = ? WHERE id = 'schema'",
+      params: [POSTGRES_SCHEMA_VERSION]
+    }
+  ]);
+}
 async function createSQLiteTables(client, ftsTokenizer) {
   const statements = [
     sql`CREATE TABLE IF NOT EXISTS ai_ready_pages (
@@ -404,11 +439,11 @@ async function createPostgresTables(client) {
       keywords TEXT NOT NULL DEFAULT '[]',
       content_hash TEXT,
       updated_at TEXT NOT NULL,
-      indexed_at INTEGER NOT NULL,
+      indexed_at BIGINT NOT NULL,
       is_error INTEGER NOT NULL DEFAULT 0,
       indexed INTEGER NOT NULL DEFAULT 0,
       source TEXT NOT NULL DEFAULT 'prerender',
-      last_seen_at INTEGER,
+      last_seen_at BIGINT,
       locale TEXT NOT NULL DEFAULT ''
     )`,
     sql`CREATE TABLE IF NOT EXISTS _ai_ready_info (
@@ -420,8 +455,8 @@ async function createPostgresTables(client) {
     )`,
     sql`CREATE TABLE IF NOT EXISTS ai_ready_cron_runs (
       id SERIAL PRIMARY KEY,
-      started_at INTEGER NOT NULL,
-      finished_at INTEGER,
+      started_at BIGINT NOT NULL,
+      finished_at BIGINT,
       duration_ms INTEGER,
       pages_indexed INTEGER DEFAULT 0,
       pages_remaining INTEGER DEFAULT 0,
@@ -431,7 +466,7 @@ async function createPostgresTables(client) {
     sql`CREATE TABLE IF NOT EXISTS ai_ready_sitemaps (
       name TEXT PRIMARY KEY,
       route TEXT NOT NULL,
-      last_crawled_at INTEGER,
+      last_crawled_at BIGINT,
       url_count INTEGER DEFAULT 0,
       error_count INTEGER DEFAULT 0,
       last_error TEXT,

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

@@ -7,7 +7,7 @@ import type { DrizzleDatabase } from './client.js';
 /**
  * Register the underlying driver for raw SQL access
  */
-export declare function registerDriver(db: DrizzleDatabase['db'], type: 'better-sqlite3' | 'node-sqlite' | 'libsql' | 'neon' | 'd1', driver: unknown): void;
+export declare function registerDriver(db: DrizzleDatabase['db'], type: 'better-sqlite3' | 'node-sqlite' | 'libsql' | 'neon' | 'postgres' | 'd1', driver: unknown): void;
 /**
  * Get raw SQL executor for a Drizzle client
  */
@@ -33,4 +33,4 @@ export declare function useRawDb(event?: H3Event): Promise<RawExecutor>;
 /**
  * Close underlying database driver connection
  */
-export declare function closeDriver(db: DrizzleDatabase['db']): void;
+export declare function closeDriver(db: DrizzleDatabase['db']): Promise<void>;

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

@@ -5,6 +5,10 @@ export function registerDriver(db, type, driver) {
 }
 const RE_PARAM_PLACEHOLDER = /\?/g;
 const MAX_BATCH_STATEMENTS = 100;
+function toPostgresQuery(query) {
+  let index = 0;
+  return query.replace(RE_PARAM_PLACEHOLDER, () => `$${++index}`);
+}
 export function getRawExecutor(client) {
   const cached = driverCache.get(client.db);
   if (!cached) {
@@ -35,11 +39,13 @@ export function getRawExecutor(client) {
         }
         case "neon": {
           const sqlFn = driver;
-          let idx = 0;
-          const pgQuery = query.replace(RE_PARAM_PLACEHOLDER, () => `$${++idx}`);
-          const result = await sqlFn.query(pgQuery, params);
+          const result = await sqlFn.query(toPostgresQuery(query), params);
           return result.rows || result;
         }
+        case "postgres": {
+          const sqlClient = driver;
+          return await sqlClient.unsafe(toPostgresQuery(query), params);
+        }
       }
     },
     async first(query, params = []) {
@@ -70,9 +76,12 @@ export function getRawExecutor(client) {
         }
         case "neon": {
           const sqlFn = driver;
-          let idx = 0;
-          const pgQuery = query.replace(RE_PARAM_PLACEHOLDER, () => `$${++idx}`);
-          await sqlFn.query(pgQuery, params);
+          await sqlFn.query(toPostgresQuery(query), params);
+          break;
+        }
+        case "postgres": {
+          const sqlClient = driver;
+          await sqlClient.unsafe(toPostgresQuery(query), params);
           break;
         }
       }
@@ -128,14 +137,22 @@ export function getRawExecutor(client) {
           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 || []);
+              return sqlFn.query(toPostgresQuery(q.sql), q.params || []);
             });
             await sqlFn.transaction(pgQueries);
           }
           break;
         }
+        case "postgres": {
+          const sqlClient = driver;
+          for (let i = 0; i < queries.length; i += MAX_BATCH_STATEMENTS) {
+            const chunk = queries.slice(i, i + MAX_BATCH_STATEMENTS);
+            await sqlClient.begin((transaction) => Promise.all(chunk.map(
+              (q) => transaction.unsafe(toPostgresQuery(q.sql), q.params || [])
+            )));
+          }
+          break;
+        }
       }
     }
   };
@@ -144,7 +161,7 @@ export async function useRawDb(event) {
   const client = await useDrizzle(event);
   return getRawExecutor(client);
 }
-export function closeDriver(db) {
+export async function closeDriver(db) {
   const cached = driverCache.get(db);
   if (!cached)
     return;
@@ -165,6 +182,11 @@ export function closeDriver(db) {
       client.close?.();
       break;
     }
+    case "postgres": {
+      const sqlClient = driver;
+      await sqlClient.end();
+      break;
+    }
   }
   driverCache.delete(db);
 }

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

@@ -48,6 +48,7 @@ export interface QueryPagesOptions {
     limit?: number;
     offset?: number;
 }
+type DatabaseNumber = number | string | bigint;
 /**
  * Get lastmod (updatedAt) for all indexed pages
  * Returns a Map for O(1) lookup when enriching sitemaps
@@ -92,7 +93,7 @@ export interface SearchPagesOptions {
     limit?: number;
 }
 /**
- * Full-text search using FTS5
+ * Full-text search using FTS5 or PostgreSQL ILIKE
  * Note: FTS is only available at runtime, not during prerender
  */
 export declare function searchPages(event: H3Event | undefined, query: string, options?: SearchPagesOptions): Promise<SearchResult[]>;
@@ -159,11 +160,11 @@ export declare function pruneStaleRoutes(event: H3Event | undefined, staleThresh
 export declare function getStaleRoutes(event: H3Event | undefined, staleThresholdSeconds: number): Promise<string[]>;
 export interface CronRunRow {
     id: number;
-    started_at: number;
-    finished_at: number | null;
-    duration_ms: number | null;
-    pages_indexed: number;
-    pages_remaining: number;
+    started_at: DatabaseNumber;
+    finished_at: DatabaseNumber | null;
+    duration_ms: DatabaseNumber | null;
+    pages_indexed: DatabaseNumber;
+    pages_remaining: DatabaseNumber;
     errors: string;
     status: 'running' | 'success' | 'partial' | 'error';
 }
@@ -303,3 +304,4 @@ export declare function getRecentlyIndexedPages(event: H3Event | undefined, limi
  * Count pages indexed in a time window
  */
 export declare function countRecentlyIndexed(event: H3Event | undefined, sinceMs: number): Promise<number>;
+export {};

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

@@ -24,7 +24,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 +43,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 +156,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,
@@ -238,7 +251,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 +263,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 = `%${sanitized}%`;
+    return db.all(`
+      SELECT route, title, description, 0 AS score
+      FROM ai_ready_pages
+      WHERE is_error = 0
+        AND (title ILIKE ? OR description ILIKE ? OR markdown ILIKE ? OR headings ILIKE ?)
+      ORDER BY route
+      LIMIT ?
+    `, [searchTerm, searchTerm, searchTerm, searchTerm, 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
@@ -299,7 +323,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 +334,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);
@@ -369,7 +393,10 @@ 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)]);
+  await db.exec(`
+    INSERT INTO _ai_ready_info (id, value) VALUES (?, ?)
+    ON CONFLICT(id) DO UPDATE SET value = excluded.value
+  `, ["sitemap_seeded_at", String(timestamp)]);
 }
 export async function pruneStaleRoutes(event, staleThresholdSeconds, protectedSince) {
   const db = await getDb(event);
@@ -381,7 +408,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 +428,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 +442,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 +454,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
@@ -456,7 +482,7 @@ export async function cleanupOldCronRuns(event, keepCount = 50) {
   if (!db)
     return 0;
   const countRow = await db.first("SELECT COUNT(*) as count FROM ai_ready_cron_runs");
-  const total = countRow?.count || 0;
+  const total = toNumber(countRow?.count);
   if (total <= keepCount)
     return 0;
   const deleteCount = total - keepCount;
@@ -476,7 +502,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,11 +524,11 @@ 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;
@@ -515,7 +541,7 @@ export async function tryAcquireCronLock(event) {
   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) < ?
+    WHERE CAST(_ai_ready_info.value AS BIGINT) < ?
   `, [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);
@@ -554,9 +580,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 +669,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 +689,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 +700,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 +737,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 +761,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 +772,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/plugins/db-lifecycle.js

@@ -1,10 +1,11 @@
-import { DB_CONTEXT_KEY } from "../db/context.js";
+import { DB_CONTEXT_KEY, DB_PROMISE_CONTEXT_KEY, DB_WORK_CONTEXT_KEY } from "../db/context.js";
 export default function dbLifecyclePlugin(nitroApp) {
   nitroApp.hooks.hook("afterResponse", async (event) => {
-    if (!event.context?.[DB_CONTEXT_KEY])
+    if (!event.context?.[DB_CONTEXT_KEY] && !event.context?.[DB_PROMISE_CONTEXT_KEY] && !event.context?.[DB_WORK_CONTEXT_KEY]) {
       return;
-    const { closeDrizzle } = await import("../db/index.js");
-    await closeDrizzle(event);
+    }
+    const { finishDrizzleResponse } = await import("../db/index.js");
+    await finishDrizzleResponse(event);
   });
   nitroApp.hooks.hook("close", async () => {
     const { closeDrizzle } = await import("../db/index.js");

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

@@ -1,4 +1,5 @@
 import { useRuntimeConfig } from "#nuxtseo/nitro";
+import { trackDrizzleWork } from "../db/drizzle/client.js";
 import { getPageLastmods, getSitemapLastCrawledAt, markSitemapSeeded, seedRoutes } from "../db/queries.js";
 import { logger } from "../logger.js";
 import { mapSitemapRoutes } from "../utils/sitemap-routes.js";
@@ -106,9 +107,10 @@ export default function sitemapSeederPlugin(nitroApp) {
         logger.debug(`[sitemap-seeder] Seeded ${seeded} routes from ${sitemapName} in ${seedMs}ms`);
     };
     if (event.waitUntil) {
-      event.waitUntil(seed().catch(
+      const backgroundSeed = trackDrizzleWork(event, seed()).catch(
         (err) => logger.error(`[sitemap-seeder] Background seed failed: ${err.message}`)
-      ));
+      );
+      event.waitUntil(backgroundSeed);
     } else {
       await seed();
     }

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

@@ -1,5 +1,4 @@
 import type { H3Event } from '#nuxtseo/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;

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

@@ -5,7 +5,7 @@ import { logger } from "../logger.js";
 import { convertHtmlToMarkdown } from "../utils.js";
 import { createUniversalContext } from "./context.js";
 import { extractKeywords } from "./keywords.js";
-export const INDEXING_HEADER = "x-ai-ready-indexing";
+import { INTERNAL_HEADER } from "./negotiation-decision.js";
 export async function indexPage(route, html, options = {}, event) {
   const config = useRuntimeConfig()["nuxt-ai-ready"];
   const ttl = options.ttl ?? config.runtimeSync.ttl;
@@ -70,10 +70,10 @@ export async function indexPage(route, html, options = {}, event) {
 export async function indexPageByRoute(route, event, options = {}) {
   logger.debug(`[indexPageByRoute] Fetching HTML for ${route} (timeout: 10000ms)`);
   const html = await (event ? fetchWithEvent(event, route, {
-    headers: { [INDEXING_HEADER]: "1" },
+    headers: { accept: "text/html", [INTERNAL_HEADER]: "1" },
     timeout: 1e4
   }) : globalThis.$fetch(route, {
-    headers: { [INDEXING_HEADER]: "1" },
+    headers: { accept: "text/html", [INTERNAL_HEADER]: "1" },
     timeout: 1e4
     // 10s timeout per page (must fit within CF worker limit)
   })).catch((err) => {

package/dist/runtime/server/utils/negotiation-decision.d.ts

@@ -1,7 +1,7 @@
 import type { ContentNegotiationPolicy } from '../../types.js';
 import type { ContentNegotiationResolution, NegotiationRouteRule } from './content-negotiation.js';
 import type { MarkdownRequest } from './markdown-request.js';
-/** Marks the internal HTML fetch that the explicit `.md` handler makes. */
+/** Marks an internal HTML fetch that must bypass content negotiation. */
 export declare const INTERNAL_HEADER = "x-ai-ready-internal";
 /**
  * Where the decision runs. The early stage sits in front of the Nitro static

package/dist/runtime/types.d.ts

@@ -231,7 +231,7 @@ export interface ModuleOptions {
     llmsTxtCacheSeconds?: number;
     /**
      * Database configuration for page storage
-     * Supports SQLite, LibSQL/Turso, Cloudflare D1, and Neon Postgres
+     * Supports SQLite, LibSQL/Turso, Cloudflare D1, Neon, and PostgreSQL
      *
      * Storage stays off until a runtime feature or page tool needs it.
      * Set to `false` (or `{ type: 'none' }`) to force it off.
@@ -247,9 +247,10 @@ export interface ModuleOptions {
          * - 'bun': Bun SQLite via bun:sqlite (auto-detected on Bun) [experimental]
          * - 'libsql': Turso/LibSQL [experimental]
          * - 'neon': Vercel Postgres via Neon serverless (auto-detected on Vercel with POSTGRES_URL) [experimental]
+         * - 'postgres': PostgreSQL via Postgres.js [experimental]
          * @default 'sqlite' when a requested feature needs storage
          */
-        type?: 'none' | 'sqlite' | 'bun' | 'd1' | 'libsql' | 'neon';
+        type?: 'none' | 'sqlite' | 'bun' | 'd1' | 'libsql' | 'neon' | 'postgres';
         /**
          * SQLite filename (relative to rootDir or absolute)
          * @default '.data/ai-ready/pages.db'
@@ -261,8 +262,8 @@ export interface ModuleOptions {
          */
         bindingName?: string;
         /**
-         * Database URL for LibSQL/Turso or Neon/Vercel Postgres
-         * For Vercel: auto-reads from POSTGRES_URL env var
+         * Database URL for LibSQL/Turso, Neon, or PostgreSQL
+         * PostgreSQL drivers also read POSTGRES_URL or DATABASE_URL.
          */
         url?: string;
         /**

package/dist/shared/{nuxt-ai-ready.D8qbnNrv.mjs → nuxt-ai-ready.BTQAkSYt.mjs}

@@ -598,7 +598,7 @@ function resolveDatabaseConfig(input) {
       database: { _tag: "Enabled", type, bindingName: config.bindingName || "DB" }
     };
   }
-  if (type === "neon") {
+  if (type === "neon" || type === "postgres") {
     return {
       _tag: "Resolved",
       logs,
@@ -1579,12 +1579,13 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
         bun: "#ai-ready/server/db/drizzle/providers/bun",
         d1: "#ai-ready/server/db/drizzle/providers/d1",
         libsql: "#ai-ready/server/db/drizzle/providers/libsql",
-        neon: "#ai-ready/server/db/drizzle/providers/neon"
+        neon: "#ai-ready/server/db/drizzle/providers/neon",
+        postgres: "#ai-ready/server/db/drizzle/providers/postgres"
       };
       nitroConfig.virtual["#ai-ready-virtual/db-provider.mjs"] = database._tag === "Enabled" ? `export { createClient } from '${providerMap[database.type] || providerMap.sqlite}'` : `export function createClient() {
   throw new Error('[nuxt-ai-ready] The database is disabled. Set \`aiReady.database\` to store pages at runtime.')
 }`;
-      const schemaPath = database._tag === "Enabled" && database.type === "neon" ? "#ai-ready/server/db/schema/postgres" : "#ai-ready/server/db/schema/sqlite";
+      const schemaPath = database._tag === "Enabled" && (database.type === "neon" || database.type === "postgres") ? "#ai-ready/server/db/schema/postgres" : "#ai-ready/server/db/schema/sqlite";
       nitroConfig.virtual["#ai-ready-virtual/db-schema.mjs"] = `export * from '${schemaPath}'`;
       nitroConfig.virtual["#ai-ready-virtual/devtools-meta.mjs"] = `export const devtoolsMeta = ${JSON.stringify({
         contentSignal: config.contentSignal || false,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",
@@ -48,7 +48,8 @@
     "@libsql/client": "^0.14.0",
     "@neondatabase/serverless": "^1.0.0",
     "@nuxtjs/sitemap": ">=8.3.1",
-    "better-sqlite3": "^11.0.0 || ^12.0.0 || ^13.0.0"
+    "better-sqlite3": "^11.0.0 || ^12.0.0 || ^13.0.0",
+    "postgres": "^3.4.9"
   },
   "peerDependenciesMeta": {
     "@libsql/client": {
@@ -59,6 +60,9 @@
     },
     "better-sqlite3": {
       "optional": true
+    },
+    "postgres": {
+      "optional": true
     }
   },
   "dependencies": {
@@ -67,7 +71,7 @@
     "citty": "^0.2.2",
     "consola": "^3.4.2",
     "defu": "^6.1.7",
-    "drizzle-orm": "1.0.0-rc.4",
+    "drizzle-orm": "^1.0.0-rc.4",
     "mdream": "^1.7.0",
     "nuxt-site-config": "^4.2.3",
     "nuxtseo-shared": "^5.3.14",
@@ -82,41 +86,42 @@
   "devDependencies": {
     "@antfu/eslint-config": "^9.3.0",
     "@arethetypeswrong/cli": "^0.18.5",
-    "@harlan-zw/comark-content": "0.1.4",
+    "@harlan-zw/comark-content": "^0.1.5",
     "@libsql/client": "^0.17.4",
-    "@nuxt/content": "^3.15.2",
+    "@nuxt/content": "^3.16.0",
     "@nuxt/module-builder": "^1.0.3",
-    "@nuxt/test-utils": "^4.1.0",
+    "@nuxt/test-utils": "^4.2.0",
     "@nuxtjs/eslint-config-typescript": "^12.1.0",
     "@nuxtjs/mcp-toolkit": "^0.19.0",
-    "@nuxtjs/robots": "^6.1.5",
-    "@nuxtjs/sitemap": "^8.4.0",
+    "@nuxtjs/robots": "^6.2.0",
+    "@nuxtjs/sitemap": "^8.5.0",
     "@types/better-sqlite3": "^9.6.0",
     "@vitest/coverage-v8": "^4.1.11",
-    "@vue/test-utils": "^2.4.11",
+    "@vue/test-utils": "^2.5.0",
     "@vueuse/nuxt": "^14.4.0",
     "better-sqlite3": "^13.0.3",
-    "bumpp": "^12.2.1",
-    "eslint": "^10.8.1",
-    "eslint-plugin-harlanzw": "^0.20.0",
+    "bumpp": "^12.2.2",
+    "eslint": "^10.9.1",
+    "eslint-plugin-harlanzw": "^0.21.0",
     "execa": "^10.0.1",
     "h3": "^1.15.11",
-    "happy-dom": "^20.11.2",
+    "happy-dom": "^20.12.0",
     "nitropack": "^2.13.4",
     "nuxt": "^4.5.2",
     "nuxt-site-config": "^4.2.3",
     "nuxtseo-layer-devtools": "^5.3.14",
     "playwright": "^1.62.1",
     "playwright-core": "^1.62.1",
+    "postgres": "^3.4.9",
     "tinyglobby": "^0.2.17",
     "typescript": "6.0.3",
     "unbuild": "^3.6.1",
     "vitest": "^4.1.11",
-    "vue": "^3.5.41",
-    "vue-router": "^5.2.0",
-    "vue-tsc": "^3.3.10",
-    "wrangler": "^4.124.0",
-    "zod": "^4.4.3"
+    "vue": "^3.5.42",
+    "vue-router": "^5.3.0",
+    "vue-tsc": "^3.3.11",
+    "wrangler": "^4.127.1",
+    "zod": "^4.5.4"
   },
   "scripts": {
     "lint": "eslint .",