nuxt-ai-ready 0.10.12 → 0.12.0

package/README.md

@@ -33,6 +33,12 @@ Install `nuxt-ai-ready` dependency to your project:
 npx nuxi@latest module add nuxt-ai-ready
 ```
 
+> [!TIP]
+> Generate an Agent Skill for this package using [skilld](https://github.com/harlan-zw/skilld):
+> ```bash
+> npx skilld add nuxt-ai-ready
+> ```
+
 ## Documentation
 
 [📖 Read the full documentation](https://nuxtseo.com/ai-ready) for more information.
@@ -41,7 +47,7 @@ npx nuxi@latest module add nuxt-ai-ready
 
 <p align="center">
   <a href="https://raw.githubusercontent.com/harlan-zw/static/main/sponsors.svg">
-    <img src='https://raw.githubusercontent.com/harlan-zw/static/main/sponsors.svg'/>
+    <img src='https://raw.githubusercontent.com/harlan-zw/static/main/sponsors.svg' alt="Sponsors"/>
   </a>
 </p>
 

package/dist/cli.mjs

@@ -5,6 +5,7 @@ import { defineCommand, runMain } from 'citty';
 import { consola } from 'consola';
 import { colors } from 'consola/utils';
 import { resolve, join } from 'pathe';
+import { readPackageJSON } from 'pkg-types';
 
 async function getSecret(cwd) {
   const secretPath = join(cwd, "node_modules/.cache/nuxt/ai-ready/secret");
@@ -16,10 +17,11 @@ async function getSecret(cwd) {
 const main = defineCommand({
   meta: {
     name: "nuxt-ai-ready",
-    description: "Nuxt AI Ready CLI"
+    description: "Nuxt AI Ready CLI",
+    version: await readPackageJSON(import.meta.url).then((p) => p.version || "0.0.0")
   },
   subCommands: {
-    status: defineCommand({
+    status: () => defineCommand({
       meta: {
         name: "status",
         description: "Show indexing status and IndexNow sync progress"
@@ -71,7 +73,7 @@ const main = defineCommand({
         }
       }
     }),
-    poll: defineCommand({
+    poll: () => defineCommand({
       meta: {
         name: "poll",
         description: "Trigger page indexing"
@@ -131,7 +133,7 @@ const main = defineCommand({
         }
       }
     }),
-    restore: defineCommand({
+    restore: () => defineCommand({
       meta: {
         name: "restore",
         description: "Restore database from prerendered dump"
@@ -145,8 +147,9 @@ const main = defineCommand({
         },
         clear: {
           type: "boolean",
-          description: "Clear existing pages first (default: true)",
-          default: true
+          description: "Clear existing pages first",
+          default: true,
+          negativeDescription: "Restore without clearing existing pages"
         },
         cwd: {
           type: "string",
@@ -179,7 +182,7 @@ const main = defineCommand({
         }
       }
     }),
-    prune: defineCommand({
+    prune: () => defineCommand({
       meta: {
         name: "prune",
         description: "Remove stale routes from database"
@@ -243,7 +246,7 @@ const main = defineCommand({
         }
       }
     }),
-    indexnow: defineCommand({
+    indexnow: () => defineCommand({
       meta: {
         name: "indexnow",
         description: "Trigger IndexNow sync"

package/dist/module.d.mts

@@ -1,5 +1,5 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { ModuleOptions, LlmsTxtConfig } from '../dist/runtime/types.js';
+import { LlmsTxtConfig, ModuleOptions } from '../dist/runtime/types.js';
 export { ModuleOptions } from '../dist/runtime/types.js';
 
 interface ParsedMarkdownResult {
@@ -27,6 +27,12 @@ interface ModuleHooks {
         notes: string[];
     }) => void | Promise<void>;
 }
+declare module '@nuxt/schema' {
+    interface NuxtHooks {
+        'ai-ready:page:markdown': ModuleHooks['ai-ready:page:markdown'];
+        'ai-ready:llms-txt': ModuleHooks['ai-ready:llms-txt'];
+    }
+}
 interface ModulePublicRuntimeConfig {
     debug: boolean;
     debugCron: boolean;

package/dist/module.json

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

package/dist/module.mjs

@@ -1,7 +1,7 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { mkdir, writeFile, appendFile, stat, access } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
-import { useLogger, useNuxt, addTemplate, addTypeTemplate, defineNuxtModule, createResolver, hasNuxtModule, addServerHandler, addPlugin, addServerPlugin } from '@nuxt/kit';
+import { useLogger, useNuxt, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, hasNuxtModule, addServerHandler, addPlugin, addServerPlugin } from '@nuxt/kit';
 import defu from 'defu';
 import { useSiteConfig, installNuxtSiteConfig, withSiteUrl } from 'nuxt-site-config/kit';
 import { readPackageJSON } from 'pkg-types';
@@ -11,7 +11,7 @@ import { isTest, isCI } from 'std-env';
 import { parseSitemapXml } from '@nuxtjs/sitemap/utils';
 import { colorize } from 'consola/utils';
 import { withBase } from 'ufo';
-import { createAdapter, initSchema, computeContentHash, insertPage, queryAllPages, exportDbDump } from '../dist/runtime/server/db/shared.js';
+import { initSchema, computeContentHash, insertPage, queryAllPages, exportDbDump } from '../dist/runtime/server/db/shared.js';
 import { comparePageHashes, submitToIndexNowShared } from '../dist/runtime/server/utils/indexnow-shared.js';
 import { buildLlmsFullTxtHeader, formatPageForLlmsFullTxt } from '../dist/runtime/server/utils/llms-full.js';
 import { join as join$1, isAbsolute } from 'pathe';
@@ -59,12 +59,12 @@ function hookNuxtSeoProLicense() {
         }
       }).catch((err) => {
         if (err?.response?.status === 401) {
-          spinner.stop("\u274C Invalid API key");
+          spinner.error("Invalid API key");
           p.note("Your API key is invalid.\n\nhttps://nuxtseo.com/pro/dashboard", "License Issue");
           throw new Error("Invalid Nuxt SEO Pro API key.");
         }
         if (err?.response?.status === 403) {
-          spinner.stop("\u274C No active subscription");
+          spinner.error("No active subscription");
           p.note("Your subscription has expired or is inactive.\n\nhttps://nuxtseo.com/pro/dashboard", "License Issue");
           throw new Error("No active Nuxt SEO Pro subscription.");
         }
@@ -72,7 +72,7 @@ function hookNuxtSeoProLicense() {
         return null;
       });
       if (!res) {
-        spinner.stop("\u26A0\uFE0F  License verification skipped (network issue)");
+        spinner.cancel("License verification skipped (network issue)");
         return;
       }
       spinner.stop("License verified \u2713");
@@ -140,13 +140,21 @@ async function initCrawler(state) {
   if (state.dbPath) {
     logger.debug(`Creating directory for SQLite: ${dirname(state.dbPath)}`);
     await mkdir(dirname(state.dbPath), { recursive: true });
-    const nodeVersion = Number.parseInt(process.versions.node?.split(".")[0] || "0");
-    const connectorPath = nodeVersion >= 22 ? "db0/connectors/node-sqlite" : "db0/connectors/better-sqlite3";
-    const { default: connectorFn } = await import(connectorPath);
-    const connector = connectorFn({ path: state.dbPath });
-    state.db = createAdapter(connector);
-    await initSchema(state.db);
-    logger.debug(`Crawler initialized with SQLite at ${state.dbPath} using ${connectorPath}`);
+    const { default: Database } = await import('better-sqlite3');
+    const sqlite = new Database(state.dbPath);
+    const db = {
+      all: async (sql, params = []) => sqlite.prepare(sql).all(...params),
+      first: async (sql, params = []) => sqlite.prepare(sql).get(...params),
+      exec: async (sql, params = []) => {
+        sqlite.prepare(sql).run(...params);
+      },
+      close: async () => {
+        sqlite.close();
+      }
+    };
+    state.db = db;
+    await initSchema(db);
+    logger.debug(`Crawler initialized with SQLite at ${state.dbPath}`);
   }
   if (state.llmsFullTxtPath) {
     logger.debug(`Creating directory for llms-full.txt: ${dirname(state.llmsFullTxtPath)}`);
@@ -430,7 +438,7 @@ function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, indexNo
         await writeLlmsFiles();
         state.prerenderedRoutes.clear();
         if (state.db)
-          await state.db.close();
+          await state.db.close?.();
       });
     } else if (usePrerenderHook) {
       nitro.hooks.hook("prerender:done", async () => {
@@ -444,28 +452,17 @@ function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, indexNo
         await writeLlmsFiles();
         state.prerenderedRoutes.clear();
         if (state.db)
-          await state.db.close();
+          await state.db.close?.();
       });
     }
   });
 }
 
 function registerTypeTemplates(_ctx) {
-  addTemplate({
-    filename: "types/ai-ready-adapter.d.ts",
-    getContents: () => `declare module '#ai-ready/adapter' {
-  import type { Connector } from 'db0'
-  const connector: (config: unknown) => Connector
-  export default connector
-}
-`
-  });
   addTypeTemplate({
     filename: "types/nuxt-ai-ready-augments.d.ts",
     getContents: () => `// Generated by nuxt-ai-ready
-/// <reference path="./ai-ready-adapter.d.ts" />
 /// <reference path="./ai-ready-virtual.d.ts" />
-/// <reference path="./ai-ready-db-provider.d.ts" />
 import type { MarkdownContext, PageIndexedContext } from 'nuxt-ai-ready'
 import type { HTMLToMarkdownOptions } from 'mdream'
 
@@ -505,42 +502,26 @@ declare module '#ai-ready-virtual/logger.mjs' {
   import type { ConsolaInstance } from 'consola'
   export const logger: ConsolaInstance
 }
-`
-  });
-  addTemplate({
-    filename: "types/ai-ready-db-provider.d.ts",
-    getContents: () => `declare module '#ai-ready/db-provider' {
+
+declare module '#ai-ready-virtual/db-provider.mjs' {
   import type { H3Event } from 'h3'
-  import type { Connector } from 'db0'
-  export function createConnector(event?: H3Event): Promise<Connector>
+  import type { DrizzleDatabase } from '#ai-ready/server/db/drizzle/client'
+  export function createClient(event?: H3Event): Promise<DrizzleDatabase>
+}
+
+declare module '#ai-ready-virtual/db-schema.mjs' {
+  export * from '#ai-ready/server/db/schema/sqlite'
 }
 `
   });
 }
 
-async function resolveDatabaseAdapter(type) {
-  const connectors = {
-    d1: "db0/connectors/cloudflare-d1",
-    libsql: "db0/connectors/libsql/node"
-  };
-  if (type !== "sqlite" && connectors[type]) {
-    return connectors[type];
-  }
-  if (process.versions.bun) {
-    return "db0/connectors/bun-sqlite";
-  }
-  const nodeVersion = Number.parseInt(process.versions.node?.split(".")[0] || "0");
-  if (nodeVersion >= 22) {
-    return "db0/connectors/node-sqlite";
-  }
-  return "db0/connectors/better-sqlite3";
-}
 function refineDatabaseConfig(config, rootDir) {
   const type = config.type || "sqlite";
-  if (type === "sqlite") {
+  if (type === "sqlite" || type === "bun") {
     const filename = config.filename || ".data/ai-ready/pages.db";
     return {
-      type: "sqlite",
+      type,
       filename: isAbsolute(filename) ? filename : join$1(rootDir, filename)
     };
   }
@@ -550,6 +531,13 @@ function refineDatabaseConfig(config, rootDir) {
       bindingName: config.bindingName || "DB"
     };
   }
+  if (type === "neon") {
+    return {
+      type: "neon",
+      url: config.url
+      // Will fallback to POSTGRES_URL at runtime
+    };
+  }
   return {
     type: "libsql",
     url: config.url,
@@ -610,24 +598,29 @@ const module$1 = defineNuxtModule({
     nuxt.options.alias["#ai-ready"] = resolve("./runtime");
     const preset = String(nuxt.options.nitro.preset || "");
     const isCloudflare = preset.startsWith("cloudflare");
-    const dbType = config.database?.type || (isCloudflare ? "d1" : "sqlite");
-    if (isCloudflare && !config.database?.type) {
-      logger.debug(`Auto-detected Cloudflare preset "${preset}", using D1 database`);
-    }
-    const adapterPath = await resolveDatabaseAdapter(dbType);
-    nuxt.options.alias["#ai-ready/adapter"] = adapterPath;
-    nuxt.options.nitro.alias["#ai-ready/adapter"] = adapterPath;
-    let providerPath = resolve("./runtime/server/db/provider/sqlite-node");
-    if (dbType === "d1") {
-      providerPath = resolve("./runtime/server/db/provider/d1");
-    } else if (dbType === "libsql") {
-      providerPath = resolve("./runtime/server/db/provider/libsql");
-    } else if (process.versions.bun) {
-      providerPath = resolve("./runtime/server/db/provider/sqlite-bun");
+    const isVercel = preset === "vercel" || preset === "vercel-edge";
+    const isVercelEdge = preset === "vercel-edge";
+    const isBun = preset === "bun";
+    const hasPostgresUrl = !!(process.env.POSTGRES_URL || process.env.DATABASE_URL || config.database?.url);
+    let dbType = config.database?.type;
+    if (!dbType) {
+      if (isCloudflare) {
+        dbType = "d1";
+        logger.debug(`Auto-detected Cloudflare preset "${preset}", using D1 database`);
+      } else if (isVercel && hasPostgresUrl) {
+        dbType = "neon";
+        logger.debug(`Auto-detected Vercel preset with POSTGRES_URL, using Neon serverless driver`);
+      } else if (isVercelEdge) {
+        logger.warn(`Vercel Edge has no filesystem. Set POSTGRES_URL (Vercel Postgres) or configure database.type: 'libsql' for full functionality.`);
+        dbType = "neon";
+      } else if (isBun) {
+        dbType = "bun";
+        logger.debug(`Auto-detected Bun preset, using bun:sqlite driver`);
+      } else {
+        dbType = "sqlite";
+      }
     }
-    nuxt.options.alias["#ai-ready/db-provider"] = providerPath;
-    nuxt.options.nitro.alias["#ai-ready/db-provider"] = providerPath;
-    if (!nuxt.options.mcp?.name) {
+    if (nuxt.options.mcp !== false && !nuxt.options.mcp?.name) {
       nuxt.options.mcp = nuxt.options.mcp || {};
       nuxt.options.mcp.name = useSiteConfig().name;
     }
@@ -636,9 +629,11 @@ const module$1 = defineNuxtModule({
       resolve("./runtime/server/utils")
     );
     if (typeof config.contentSignal === "object") {
-      nuxt.options.robots = nuxt.options.robots || {};
-      nuxt.options.robots.groups = nuxt.options.robots.groups || [];
-      nuxt.options.robots.groups.push({
+      const robotsOpts = nuxt.options.robots !== false ? nuxt.options.robots : {};
+      nuxt.options.robots = robotsOpts;
+      const groups = robotsOpts.groups || [];
+      robotsOpts.groups = groups;
+      groups.push({
         userAgent: "*",
         contentUsage: [`train-ai=${config.contentSignal.aiTrain ? "y" : "n"}`],
         contentSignal: [`ai-train=${config.contentSignal.aiTrain ? "yes" : "no"}`, `search=${config.contentSignal.search ? "yes" : "no"}`, `ai-input=${config.contentSignal.aiInput ? "yes" : "no"}`]
@@ -669,7 +664,7 @@ const module$1 = defineNuxtModule({
       });
       const mcpLink = {
         title: "MCP",
-        href: withSiteUrl(nuxt.options.mcp?.route || "/mcp"),
+        href: withSiteUrl(nuxt.options.mcp !== false && nuxt.options.mcp?.route || "/mcp"),
         description: "Model Context Protocol server endpoint for AI agent integration."
       };
       if (defaultLlmsTxtSections[0]) {
@@ -737,11 +732,11 @@ const module$1 = defineNuxtModule({
       if (config.cron && !nuxt.options.dev) {
         const cronSchedule = "*/5 * * * *";
         const preset2 = String(nitroConfig.preset || "");
-        const isVercel = preset2 === "vercel" || preset2 === "vercel-edge";
+        const isVercel2 = preset2 === "vercel" || preset2 === "vercel-edge";
         const isCloudflarePages = preset2 === "cloudflare-pages" || preset2 === "cloudflare_pages";
         if (isCloudflarePages) {
           logger.warn("Cloudflare Pages does not support cron. Use external cron to call /__ai-ready/cron instead.");
-        } else if (isVercel) {
+        } else if (isVercel2) {
           nitroConfig.vercel = nitroConfig.vercel || {};
           nitroConfig.vercel.config = nitroConfig.vercel.config || {};
           nitroConfig.vercel.config.crons = nitroConfig.vercel.config.crons || [];
@@ -824,6 +819,17 @@ export const logger = createConsola({
   level: ${config.debug ? 4 : 3},
 })
 `;
+      const providerMap = {
+        sqlite: "#ai-ready/server/db/drizzle/providers/sqlite",
+        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"
+      };
+      const providerPath = providerMap[dbType] || providerMap.sqlite;
+      nitroConfig.virtual["#ai-ready-virtual/db-provider.mjs"] = `export { createClient } from '${providerPath}'`;
+      const schemaPath = dbType === "neon" ? "#ai-ready/server/db/schema/postgres" : "#ai-ready/server/db/schema/sqlite";
+      nitroConfig.virtual["#ai-ready-virtual/db-schema.mjs"] = `export * from '${schemaPath}'`;
     });
     const database = refineDatabaseConfig(config.database || {}, nuxt.options.rootDir);
     nuxt.options.runtimeConfig["nuxt-ai-ready"] = {

package/dist/runtime/index.d.ts

@@ -1,6 +1,6 @@
-export { useDatabase } from './server/db/index.js';
-export type { DatabaseAdapter } from './server/db/index.js';
-export { countPages, getStaleRoutes, isPageFresh, pruneStaleRoutes, queryPages, searchPages, seedRoutes, streamPages, upsertPage, } from './server/db/queries.js';
+export { closeDrizzle, useDrizzle, useRawDb } from './server/db/index.js';
+export type { DatabaseDialect, DrizzleDatabase, RawExecutor } from './server/db/index.js';
+export { countPages, getPageLastmods, getStaleRoutes, isPageFresh, pruneStaleRoutes, queryPages, searchPages, seedRoutes, streamPages, upsertPage, } from './server/db/queries.js';
 export type { CountPagesOptions, PageData, PageEntry, PageRow, QueryPagesOptions, SearchPagesOptions, SearchResult, StreamPagesOptions, UpsertPageInput, } from './server/db/queries.js';
 export { indexPage, indexPageByRoute } from './server/utils/indexPage.js';
 export type { IndexPageOptions, IndexPageResult } from './server/utils/indexPage.js';

package/dist/runtime/index.js

@@ -1,6 +1,7 @@
-export { useDatabase } from "./server/db/index.js";
+export { closeDrizzle, useDrizzle, useRawDb } from "./server/db/index.js";
 export {
   countPages,
+  getPageLastmods,
   getStaleRoutes,
   isPageFresh,
   pruneStaleRoutes,

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

@@ -0,0 +1,20 @@
+import type * as schema from '#ai-ready-virtual/db-schema.mjs';
+import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+import type { BunSQLiteDatabase } from 'drizzle-orm/bun-sqlite';
+import type { DrizzleD1Database } from 'drizzle-orm/d1';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import type { NeonHttpDatabase } from 'drizzle-orm/neon-http';
+import type { H3Event } from 'h3';
+export type DatabaseDialect = 'sqlite' | 'postgres';
+type SQLiteDB = BetterSQLite3Database<typeof schema> | BunSQLiteDatabase<typeof schema> | LibSQLDatabase<typeof schema> | DrizzleD1Database<typeof schema>;
+type PostgresDB = NeonHttpDatabase<typeof schema>;
+export interface DrizzleDatabase {
+    dialect: DatabaseDialect;
+    db: SQLiteDB | PostgresDB;
+}
+/**
+ * Get Drizzle database instance
+ */
+export declare function useDrizzle(event?: H3Event): Promise<DrizzleDatabase>;
+export declare function closeDrizzle(event?: H3Event): Promise<void>;
+export {};

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

@@ -0,0 +1,29 @@
+import { closeDriver } from "./raw.js";
+const DB_CONTEXT_KEY = "_aiReadyDrizzle";
+let fallbackClient;
+export async function useDrizzle(event) {
+  if (event?.context?.[DB_CONTEXT_KEY]) {
+    return event.context[DB_CONTEXT_KEY];
+  }
+  if (!event && fallbackClient) {
+    return fallbackClient;
+  }
+  const { createClient } = await import("#ai-ready-virtual/db-provider.mjs");
+  const client = await createClient(event);
+  if (event?.context) {
+    event.context[DB_CONTEXT_KEY] = client;
+  } else {
+    fallbackClient = client;
+  }
+  return client;
+}
+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);
+    fallbackClient = void 0;
+  }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Drizzle ORM database layer for nuxt-ai-ready
+ */
+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 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

@@ -0,0 +1,33 @@
+export * from "#ai-ready-virtual/db-schema.mjs";
+export { closeDrizzle, useDrizzle } 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 { useRawDb } from "./raw.js";

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

@@ -0,0 +1,7 @@
+import type { H3Event } from 'h3';
+export declare function createClient(event?: H3Event): Promise<{
+    dialect: "sqlite";
+    db: import("drizzle-orm/bun-sqlite").BunSQLiteDatabase<any> & {
+        $client: any;
+    };
+}>;

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

@@ -0,0 +1,25 @@
+import { mkdir } from "node:fs/promises";
+import * as schema from "#ai-ready-virtual/db-schema.mjs";
+import { Database } from "bun:sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { dirname } from "pathe";
+import { logger } from "../../../logger.js";
+import { registerDriver } from "../raw.js";
+export async function createClient(event) {
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  const dbPath = config.database.filename || ".data/ai-ready/pages.db";
+  logger.debug(`[drizzle] Opening Bun SQLite database: ${dbPath}`);
+  await mkdir(dirname(dbPath), { recursive: true }).catch((err) => {
+    if (err.code === "EROFS" || err.code === "EACCES") {
+      throw new Error(
+        `[ai-ready] Cannot create database directory (read-only filesystem). On Vercel, set database.type: 'neon'. On Cloudflare, use 'd1'. Or configure database.url for LibSQL/Turso.`
+      );
+    }
+    throw err;
+  });
+  const sqlite = new Database(dbPath);
+  const db = drizzle(sqlite, { schema });
+  registerDriver(db, "better-sqlite3", sqlite);
+  return { dialect: "sqlite", db };
+}

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

@@ -0,0 +1,7 @@
+import type { H3Event } from 'h3';
+export declare function createClient(event?: H3Event): Promise<{
+    dialect: "sqlite";
+    db: import("drizzle-orm/d1").DrizzleD1Database<any> & {
+        $client: any;
+    };
+}>;

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

@@ -0,0 +1,19 @@
+import * as schema from "#ai-ready-virtual/db-schema.mjs";
+import { drizzle } from "drizzle-orm/d1";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { logger } from "../../../logger.js";
+import { registerDriver } from "../raw.js";
+export async function createClient(event) {
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  const bindingName = config.database.bindingName || "DB";
+  logger.debug(`[drizzle] Using D1 binding: ${bindingName}`);
+  const cfEnv = event?.context?.cloudflare?.env;
+  const globalEnv = globalThis.__env__;
+  const d1 = cfEnv?.[bindingName] || globalEnv?.[bindingName];
+  if (!d1) {
+    throw new Error(`[ai-ready] D1 binding "${bindingName}" not found`);
+  }
+  const db = drizzle(d1, { schema });
+  registerDriver(db, "d1", d1);
+  return { dialect: "sqlite", db };
+}

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

@@ -0,0 +1,7 @@
+import type { H3Event } from 'h3';
+export declare function createClient(event?: H3Event): Promise<{
+    dialect: "sqlite";
+    db: import("drizzle-orm/libsql").LibSQLDatabase<any> & {
+        $client: import("@libsql/client").Client;
+    };
+}>;

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

@@ -0,0 +1,15 @@
+import * as schema from "#ai-ready-virtual/db-schema.mjs";
+import { createClient as createLibSQLClient } from "@libsql/client";
+import { drizzle } from "drizzle-orm/libsql";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { logger } from "../../../logger.js";
+import { registerDriver } from "../raw.js";
+export async function createClient(event) {
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  const dbUrl = config.database.url || `file:${config.database.filename || ".data/ai-ready/pages.db"}`;
+  logger.debug(`[drizzle] Connecting to LibSQL: ${dbUrl}`);
+  const client = createLibSQLClient({ url: dbUrl, authToken: config.database.authToken });
+  const db = drizzle(client, { schema });
+  registerDriver(db, "libsql", client);
+  return { dialect: "sqlite", db };
+}

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

@@ -0,0 +1,7 @@
+import type { H3Event } from 'h3';
+export declare function createClient(event?: H3Event): Promise<{
+    dialect: "postgres";
+    db: import("drizzle-orm/neon-http").NeonHttpDatabase<any> & {
+        $client: import("@neondatabase/serverless").NeonQueryFunction<false, false>;
+    };
+}>;

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

@@ -0,0 +1,18 @@
+import * as schema from "#ai-ready-virtual/db-schema.mjs";
+import { neon } from "@neondatabase/serverless";
+import { drizzle } from "drizzle-orm/neon-http";
+import { useRuntimeConfig } from "nitropack/runtime";
+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 POSTGRES_URL or configure database.url");
+  }
+  logger.debug(`[drizzle] Connecting to Neon Postgres`);
+  const sqlFn = neon(connectionString);
+  const db = drizzle(sqlFn, { schema });
+  registerDriver(db, "neon", sqlFn);
+  return { dialect: "postgres", db };
+}

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

@@ -0,0 +1,8 @@
+import type { H3Event } from 'h3';
+import Database from 'better-sqlite3';
+export declare function createClient(event?: H3Event): Promise<{
+    dialect: "sqlite";
+    db: import("drizzle-orm/better-sqlite3").BetterSQLite3Database<any> & {
+        $client: Database.Database;
+    };
+}>;