nuxt-ai-ready 0.6.2 → 0.7.0

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

@@ -1,5 +1,107 @@
-function normalizeRouteKey(route) {
-  return route.replace(/^\//, "").replace(/\//g, ":") || "index";
+import { useEvent } from "nitropack/runtime";
+import { useDatabase } from "./index.js";
+import { normalizeRouteKey } from "./shared.js";
+function getEventFromContext(providedEvent) {
+  if (providedEvent)
+    return providedEvent;
+  try {
+    return useEvent();
+  } catch {
+    return void 0;
+  }
+}
+let devWarningShown = false;
+async function getDb(event) {
+  if (import.meta.dev) {
+    if (!devWarningShown) {
+      console.warn("[nuxt-ai-ready] Page data unavailable in dev. Run `nuxi generate` for full metadata.");
+      devWarningShown = true;
+    }
+    return null;
+  }
+  if (import.meta.prerender) {
+    return getPrerenderDb();
+  }
+  return useDatabase(getEventFromContext(event));
+}
+async function getPrerenderDb() {
+  const m = await import("#ai-ready-virtual/read-page-data.mjs");
+  const data = await m.readPageDataFromFilesystem();
+  const pages = data.pages || [];
+  const errorRoutes = new Set(data.errorRoutes || []);
+  return {
+    all: async (sql, params = []) => {
+      const isErrorQuery = sql.includes("is_error = 1") || params.includes(1) && sql.includes("is_error");
+      const excludeErrors = sql.includes("is_error = 0");
+      if (isErrorQuery) {
+        return pages.filter((p) => errorRoutes.has(p.route)).map((p) => ({
+          ...p,
+          headings: p.headings,
+          keywords: JSON.stringify(p.keywords),
+          updated_at: p.updatedAt,
+          is_error: 1,
+          indexed: 0
+        }));
+      }
+      const filtered = excludeErrors ? pages.filter((p) => !errorRoutes.has(p.route)) : pages;
+      return filtered.map((p) => ({
+        route: p.route,
+        title: p.title,
+        description: p.description,
+        markdown: p.markdown,
+        headings: p.headings,
+        keywords: JSON.stringify(p.keywords),
+        updated_at: p.updatedAt,
+        is_error: errorRoutes.has(p.route) ? 1 : 0,
+        indexed: 1
+      }));
+    },
+    first: async (sql, params = []) => {
+      if (sql.includes("WHERE route = ?")) {
+        const route = params[0];
+        const page = pages.find((p) => p.route === route);
+        if (!page)
+          return void 0;
+        return {
+          route: page.route,
+          title: page.title,
+          description: page.description,
+          markdown: page.markdown,
+          headings: page.headings,
+          keywords: JSON.stringify(page.keywords),
+          updated_at: page.updatedAt,
+          is_error: errorRoutes.has(page.route) ? 1 : 0,
+          indexed: 1
+        };
+      }
+      return void 0;
+    },
+    exec: async () => {
+    }
+  };
+}
+function buildWhereClause(where) {
+  const conditions = [];
+  const params = [];
+  if (where?.pending !== void 0) {
+    conditions.push("indexed = ?");
+    params.push(where.pending ? 0 : 1);
+  }
+  if (where?.hasError !== void 0) {
+    conditions.push("is_error = ?");
+    params.push(where.hasError ? 1 : 0);
+  }
+  if (where?.source) {
+    conditions.push("source = ?");
+    params.push(where.source);
+  }
+  if (where?.hasError === void 0) {
+    conditions.push("is_error = 0");
+  }
+  return {
+    sql: conditions.length ? `WHERE ${conditions.join(" AND ")}` : "",
+    params
+  };
 }
 function rowToEntry(row) {
   return {
@@ -11,22 +113,78 @@ function rowToEntry(row) {
     updatedAt: row.updated_at
   };
 }
-export async function getAllPages(db) {
-  const rows = await db.all("SELECT * FROM ai_ready_pages WHERE is_error = 0");
-  return rows.map(rowToEntry);
+function rowToData(row) {
+  return {
+    ...rowToEntry(row),
+    markdown: row.markdown
+  };
+}
+export async function queryPages(event, options = {}) {
+  const { route, includeMarkdown, where, limit, offset } = options;
+  const db = await getDb(event);
+  if (!db)
+    return route ? void 0 : [];
+  if (route) {
+    const row = await db.first("SELECT * FROM ai_ready_pages WHERE route = ?", [route]);
+    if (!row)
+      return void 0;
+    return includeMarkdown ? rowToData(row) : rowToEntry(row);
+  }
+  const { sql: whereClause, params } = buildWhereClause(where);
+  let sql = `SELECT * FROM ai_ready_pages ${whereClause}`;
+  if (limit) {
+    sql += ` LIMIT ?`;
+    params.push(limit);
+    if (offset) {
+      sql += ` OFFSET ?`;
+      params.push(offset);
+    }
+  }
+  const rows = await db.all(sql, params);
+  return includeMarkdown ? rows.map(rowToData) : rows.map(rowToEntry);
 }
-export async function getPage(db, route) {
-  const row = await db.first("SELECT * FROM ai_ready_pages WHERE route = ?", [route]);
-  return row ? rowToEntry(row) : void 0;
+export async function* streamPages(event, options = {}) {
+  const db = await getDb(event);
+  if (!db)
+    return;
+  const batchSize = options.batchSize || 50;
+  let offset = 0;
+  while (true) {
+    const rows = await db.all(
+      `SELECT * FROM ai_ready_pages WHERE is_error = 0 ORDER BY route LIMIT ? OFFSET ?`,
+      [batchSize, offset]
+    );
+    if (rows.length === 0)
+      break;
+    for (const row of rows) {
+      yield rowToData(row);
+    }
+    if (rows.length < batchSize)
+      break;
+    offset += batchSize;
+  }
 }
-export async function getPageWithMarkdown(db, route) {
-  const row = await db.first("SELECT * FROM ai_ready_pages WHERE route = ?", [route]);
-  return row ? { ...rowToEntry(row), markdown: row.markdown } : void 0;
+export async function countPages(event, options = {}) {
+  const db = await getDb(event);
+  if (!db)
+    return 0;
+  const { sql: whereClause, params } = buildWhereClause(options.where);
+  const row = await db.first(
+    `SELECT COUNT(*) as count FROM ai_ready_pages ${whereClause}`,
+    params
+  );
+  return row?.count || 0;
 }
-export async function searchPages(db, query, opts = {}) {
-  const { limit = 10 } = opts;
+export async function searchPages(event, query, options = {}) {
+  if (import.meta.dev || import.meta.prerender)
+    return [];
+  const db = await getDb(event);
+  if (!db)
+    return [];
+  const { limit = 10 } = options;
   const sanitized = query.replace(/[*:^"()]/g, " ").trim();
-  if (!sanitized) return [];
+  if (!sanitized)
+    return [];
   const terms = sanitized.split(/\s+/).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
@@ -37,43 +195,182 @@ export async function searchPages(db, query, opts = {}) {
     LIMIT ?
   `, [terms, limit]);
 }
-export async function upsertPage(db, page) {
+export async function upsertPage(event, page) {
+  const db = await getDb(event);
+  if (!db)
+    return;
   const routeKey = normalizeRouteKey(page.route);
   const keywordsJson = JSON.stringify(page.keywords);
   const indexedAt = Date.now();
+  const source = page.source || "runtime";
+  const lastSeenAt = source === "runtime" ? indexedAt : null;
   await db.exec(`
-    INSERT INTO ai_ready_pages (route, route_key, title, description, markdown, headings, keywords, updated_at, indexed_at, is_error)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    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)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
     ON CONFLICT(route) DO UPDATE SET
       title = excluded.title,
       description = excluded.description,
       markdown = excluded.markdown,
       headings = excluded.headings,
       keywords = excluded.keywords,
+      content_hash = excluded.content_hash,
       updated_at = excluded.updated_at,
       indexed_at = excluded.indexed_at,
-      is_error = excluded.is_error
-  `, [page.route, routeKey, page.title, page.description, page.markdown, page.headings, keywordsJson, page.updatedAt, indexedAt, page.isError ? 1 : 0]);
-}
-export async function getErrorRoutes(db) {
-  const rows = await db.all("SELECT route FROM ai_ready_pages WHERE is_error = 1");
-  return rows.map((r) => r.route);
+      is_error = excluded.is_error,
+      indexed = 1,
+      source = excluded.source,
+      last_seen_at = excluded.last_seen_at
+  `, [page.route, routeKey, page.title, page.description, page.markdown, page.headings, keywordsJson, page.contentHash || null, page.updatedAt, indexedAt, page.isError ? 1 : 0, source, lastSeenAt]);
 }
-export async function isPageFresh(db, route, ttlSeconds) {
-  if (ttlSeconds <= 0) return false;
+export async function isPageFresh(event, route, ttlSeconds) {
+  if (ttlSeconds <= 0)
+    return false;
+  const db = await getDb(event);
+  if (!db)
+    return false;
   const row = await db.first("SELECT indexed_at FROM ai_ready_pages WHERE route = ?", [route]);
-  if (!row) return false;
+  if (!row)
+    return false;
   const age = (Date.now() - row.indexed_at) / 1e3;
   return age < ttlSeconds;
 }
-export async function deletePage(db, route) {
-  await db.exec("DELETE FROM ai_ready_pages WHERE route = ?", [route]);
+export async function getPageHash(event, route) {
+  const db = await getDb(event);
+  if (!db)
+    return null;
+  const row = await db.first("SELECT content_hash FROM ai_ready_pages WHERE route = ?", [route]);
+  return row?.content_hash || null;
 }
-export async function getPageCount(db) {
-  const row = await db.first("SELECT COUNT(*) as count FROM ai_ready_pages WHERE is_error = 0");
+export async function seedRoutes(event, routes) {
+  const db = await getDb(event);
+  if (!db)
+    return 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const nowMs = Date.now();
+  for (const route of routes) {
+    const routeKey = normalizeRouteKey(route);
+    await db.exec(`
+      INSERT INTO ai_ready_pages (route, route_key, title, description, markdown, headings, keywords, updated_at, indexed_at, is_error, indexed, source, last_seen_at)
+      VALUES (?, ?, '', '', '', '[]', '[]', ?, 0, 0, 0, 'runtime', ?)
+      ON CONFLICT(route) DO UPDATE SET last_seen_at = excluded.last_seen_at
+    `, [route, routeKey, now, nowMs]);
+  }
+  return routes.length;
+}
+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) {
+  const db = await getDb(event);
+  if (!db)
+    return 0;
+  const threshold = Date.now() - staleThresholdSeconds * 1e3;
+  const countRow = await db.first(
+    "SELECT COUNT(*) as count FROM ai_ready_pages WHERE source = ? AND last_seen_at < ?",
+    ["runtime", threshold]
+  );
+  const count = countRow?.count || 0;
+  if (count > 0) {
+    await db.exec("DELETE FROM ai_ready_pages WHERE source = ? AND last_seen_at < ?", ["runtime", threshold]);
+  }
+  return count;
+}
+export async function getStaleRoutes(event, staleThresholdSeconds) {
+  const db = await getDb(event);
+  if (!db)
+    return [];
+  const threshold = Date.now() - staleThresholdSeconds * 1e3;
+  const rows = await db.all(
+    "SELECT route FROM ai_ready_pages WHERE source = ? AND last_seen_at < ?",
+    ["runtime", threshold]
+  );
+  return rows.map((r) => r.route);
+}
+export async function getPagesNeedingIndexNowSync(event, limit = 100) {
+  const db = await getDb(event);
+  if (!db)
+    return [];
+  return db.all(`
+    SELECT route FROM ai_ready_pages
+    WHERE indexed = 1
+      AND is_error = 0
+      AND (indexnow_synced_at IS NULL OR indexnow_synced_at < indexed_at)
+    LIMIT ?
+  `, [limit]);
+}
+export async function countPagesNeedingIndexNowSync(event) {
+  const db = await getDb(event);
+  if (!db)
+    return 0;
+  const row = await db.first(`
+    SELECT COUNT(*) as count FROM ai_ready_pages
+    WHERE indexed = 1
+      AND is_error = 0
+      AND (indexnow_synced_at IS NULL OR indexnow_synced_at < indexed_at)
+  `);
   return row?.count || 0;
 }
-export async function hasPages(db) {
-  const count = await getPageCount(db);
-  return count > 0;
+export async function markIndexNowSynced(event, routes) {
+  const db = await getDb(event);
+  if (!db || routes.length === 0)
+    return;
+  const now = Date.now();
+  const placeholders = routes.map(() => "?").join(",");
+  await db.exec(
+    `UPDATE ai_ready_pages SET indexnow_synced_at = ? WHERE route IN (${placeholders})`,
+    [now, ...routes]
+  );
+}
+export async function updateIndexNowStats(event, submitted, error) {
+  const db = await getDb(event);
+  if (!db)
+    return;
+  const now = Date.now();
+  if (error) {
+    await db.exec(
+      "INSERT OR REPLACE INTO _ai_ready_info (id, value) VALUES (?, ?)",
+      ["indexnow_last_error", error]
+    );
+  } else {
+    await db.exec(`
+      INSERT INTO _ai_ready_info (id, value) VALUES (?, ?)
+      ON CONFLICT(id) DO UPDATE SET value = CAST((CAST(value AS INTEGER) + ?) AS TEXT)
+    `, ["indexnow_total_submitted", String(submitted), submitted]);
+    await db.exec(
+      "INSERT OR REPLACE INTO _ai_ready_info (id, value) VALUES (?, ?)",
+      ["indexnow_last_submitted_at", String(now)]
+    );
+    await db.exec(
+      "DELETE FROM _ai_ready_info WHERE id = ?",
+      ["indexnow_last_error"]
+    );
+  }
+}
+export async function getIndexNowStats(event) {
+  const db = await getDb(event);
+  if (!db)
+    return { totalSubmitted: 0, lastSubmittedAt: null, lastError: null };
+  const rows = await db.all(
+    "SELECT id, value FROM _ai_ready_info WHERE id LIKE ?",
+    ["indexnow_%"]
+  );
+  const stats = {};
+  for (const row of rows) {
+    stats[row.id] = row.value;
+  }
+  return {
+    totalSubmitted: Number.parseInt(stats.indexnow_total_submitted || "0", 10) || 0,
+    lastSubmittedAt: stats.indexnow_last_submitted_at ? Number.parseInt(stats.indexnow_last_submitted_at, 10) : null,
+    lastError: stats.indexnow_last_error || null
+  };
 }

package/dist/runtime/server/db/schema-sql.d.ts

@@ -0,0 +1,3 @@
+export declare const SCHEMA_VERSION = "v1.6.0";
+export declare const DROP_TABLES_SQL: string[];
+export declare const ALL_SCHEMA_SQL: string[];

package/dist/runtime/server/db/schema-sql.js

@@ -0,0 +1,71 @@
+export const SCHEMA_VERSION = "v1.6.0";
+const PAGES_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS ai_ready_pages (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  route TEXT UNIQUE NOT NULL,
+  route_key TEXT UNIQUE NOT NULL,
+  title TEXT NOT NULL DEFAULT '',
+  description TEXT NOT NULL DEFAULT '',
+  markdown TEXT NOT NULL DEFAULT '',
+  headings TEXT NOT NULL DEFAULT '[]',
+  keywords TEXT NOT NULL DEFAULT '[]',
+  content_hash TEXT,
+  updated_at TEXT NOT NULL,
+  indexed_at INTEGER 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,
+  indexnow_synced_at INTEGER
+)`;
+const PAGES_INDEXES_SQL = [
+  "CREATE INDEX IF NOT EXISTS idx_ai_ready_pages_route ON ai_ready_pages(route)",
+  "CREATE INDEX IF NOT EXISTS idx_ai_ready_pages_is_error ON ai_ready_pages(is_error)",
+  "CREATE INDEX IF NOT EXISTS idx_ai_ready_pages_indexed ON ai_ready_pages(indexed)",
+  "CREATE INDEX IF NOT EXISTS idx_ai_ready_pages_source ON ai_ready_pages(source)",
+  "CREATE INDEX IF NOT EXISTS idx_ai_ready_pages_last_seen ON ai_ready_pages(last_seen_at)"
+];
+const FTS_TABLE_SQL = `
+CREATE VIRTUAL TABLE IF NOT EXISTS ai_ready_pages_fts USING fts5(
+  route, title, description, markdown, headings, keywords,
+  content=ai_ready_pages, content_rowid=id
+)`;
+const FTS_TRIGGERS_SQL = [
+  `CREATE TRIGGER IF NOT EXISTS ai_ready_pages_ai AFTER INSERT ON ai_ready_pages BEGIN
+    INSERT INTO ai_ready_pages_fts(rowid, route, title, description, markdown, headings, keywords)
+    VALUES (new.id, new.route, new.title, new.description, new.markdown, new.headings, new.keywords);
+  END`,
+  `CREATE TRIGGER IF NOT EXISTS ai_ready_pages_ad AFTER DELETE ON ai_ready_pages BEGIN
+    INSERT INTO ai_ready_pages_fts(ai_ready_pages_fts, rowid, route, title, description, markdown, headings, keywords)
+    VALUES('delete', old.id, old.route, old.title, old.description, old.markdown, old.headings, old.keywords);
+  END`,
+  `CREATE TRIGGER IF NOT EXISTS ai_ready_pages_au AFTER UPDATE ON ai_ready_pages BEGIN
+    INSERT INTO ai_ready_pages_fts(ai_ready_pages_fts, rowid, route, title, description, markdown, headings, keywords)
+    VALUES('delete', old.id, old.route, old.title, old.description, old.markdown, old.headings, old.keywords);
+    INSERT INTO ai_ready_pages_fts(rowid, route, title, description, markdown, headings, keywords)
+    VALUES (new.id, new.route, new.title, new.description, new.markdown, new.headings, new.keywords);
+  END`
+];
+const INFO_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS _ai_ready_info (
+  id TEXT PRIMARY KEY,
+  value TEXT,
+  version TEXT,
+  checksum TEXT,
+  ready INTEGER DEFAULT 0
+)`;
+export const DROP_TABLES_SQL = [
+  "DROP TABLE IF EXISTS ai_ready_pages_fts",
+  "DROP TABLE IF EXISTS ai_ready_pages",
+  "DROP TABLE IF EXISTS _ai_ready_info",
+  // Legacy unprefixed tables (migration from v1.0.0)
+  "DROP TABLE IF EXISTS pages_fts",
+  "DROP TABLE IF EXISTS pages"
+];
+export const ALL_SCHEMA_SQL = [
+  PAGES_TABLE_SQL,
+  ...PAGES_INDEXES_SQL,
+  FTS_TABLE_SQL,
+  ...FTS_TRIGGERS_SQL,
+  INFO_TABLE_SQL
+];

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

@@ -0,0 +1,88 @@
+import type { Connector } from 'db0';
+/**
+ * Compute content hash for change detection (first 16 chars of SHA-256)
+ */
+export declare function computeContentHash(markdown: string): Promise<string>;
+export interface DatabaseAdapter {
+    all: <T>(sql: string, params?: unknown[]) => Promise<T[]>;
+    first: <T>(sql: string, params?: unknown[]) => Promise<T | undefined>;
+    exec: (sql: string, params?: unknown[]) => Promise<void>;
+}
+/**
+ * Create a DatabaseAdapter from a db0 Connector
+ */
+export declare function createAdapter(connector: Connector): DatabaseAdapter;
+/**
+ * Initialize database schema with version checking
+ */
+export declare function initSchema(db: DatabaseAdapter): Promise<void>;
+/**
+ * Normalize route to storage key format
+ * e.g., '/about/team' -> 'about:team', '/' -> 'index'
+ */
+export declare function normalizeRouteKey(route: string): string;
+/**
+ * Compress data to base64 gzip
+ */
+export declare function compressToBase64(data: unknown): Promise<string>;
+/**
+ * Decompress from base64 gzip
+ */
+export declare function decompressFromBase64<T>(base64: string): Promise<T>;
+export interface PageInput {
+    route: string;
+    title: string;
+    description: string;
+    markdown: string;
+    headings: string;
+    keywords: string[];
+    contentHash?: string;
+    updatedAt: string;
+    isError?: boolean;
+    source?: 'prerender' | 'runtime';
+}
+export interface PageOutput {
+    route: string;
+    title: string;
+    description: string;
+    markdown: string;
+    headings: string;
+    keywords: string[];
+    contentHash?: string;
+    updatedAt: string;
+    isError: boolean;
+}
+/**
+ * Insert or update a page
+ */
+export declare function insertPage(db: DatabaseAdapter, page: PageInput): Promise<void>;
+/**
+ * Query all pages from database
+ */
+export declare function queryAllPages(db: DatabaseAdapter, options?: {
+    includeErrors?: boolean;
+}): Promise<PageOutput[]>;
+export interface DumpRow {
+    route: string;
+    route_key: string;
+    title: string;
+    description: string;
+    markdown: string;
+    headings: string;
+    keywords: string;
+    content_hash: string | null;
+    updated_at: string;
+    indexed_at: number;
+    is_error: number;
+    indexed: number;
+    source: string;
+    last_seen_at: number | null;
+}
+/**
+ * Export database as compressed dump (base64 gzip)
+ */
+export declare function exportDbDump(db: DatabaseAdapter): Promise<string>;
+/**
+ * Import dump into database
+ */
+export declare function importDbDump(db: DatabaseAdapter, rows: DumpRow[]): Promise<void>;

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

@@ -0,0 +1,117 @@
+import { subtle } from "uncrypto";
+import { ALL_SCHEMA_SQL, DROP_TABLES_SQL, SCHEMA_VERSION } from "./schema-sql.js";
+export async function computeContentHash(markdown) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(markdown);
+  const hashBuffer = await subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);
+}
+export function createAdapter(connector) {
+  return {
+    all: async (sql, params = []) => {
+      const result = await connector.prepare(sql).all(...params);
+      return result || [];
+    },
+    first: async (sql, params = []) => {
+      return connector.prepare(sql).get(...params);
+    },
+    exec: async (sql, params = []) => {
+      await connector.prepare(sql).run(...params);
+    }
+  };
+}
+export async function initSchema(db) {
+  const needsRebuild = await checkSchemaVersion(db);
+  if (needsRebuild) {
+    for (const sql of DROP_TABLES_SQL) {
+      await db.exec(sql);
+    }
+  }
+  for (const sql of ALL_SCHEMA_SQL) {
+    await db.exec(sql);
+  }
+  await db.exec(
+    "INSERT OR REPLACE INTO _ai_ready_info (id, version) VALUES (?, ?)",
+    ["schema", SCHEMA_VERSION]
+  );
+}
+async function checkSchemaVersion(db) {
+  const info = await db.first(
+    "SELECT version FROM _ai_ready_info WHERE id = ?",
+    ["schema"]
+  ).catch(() => null);
+  return !info || info.version !== SCHEMA_VERSION;
+}
+export function normalizeRouteKey(route) {
+  return route.replace(/^\//, "").replace(/\//g, ":") || "index";
+}
+export async function compressToBase64(data) {
+  const json = JSON.stringify(data);
+  const encoder = new TextEncoder();
+  const stream = new Blob([encoder.encode(json)]).stream();
+  const compressed = stream.pipeThrough(new CompressionStream("gzip"));
+  const buffer = await new Response(compressed).arrayBuffer();
+  return Buffer.from(buffer).toString("base64");
+}
+export async function decompressFromBase64(base64) {
+  const buffer = Buffer.from(base64, "base64");
+  const stream = new Blob([buffer]).stream();
+  const decompressed = stream.pipeThrough(new DecompressionStream("gzip"));
+  const text = await new Response(decompressed).text();
+  return JSON.parse(text);
+}
+export async function insertPage(db, page) {
+  const now = Date.now();
+  const source = page.source || "prerender";
+  await db.exec(`
+    INSERT OR REPLACE 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)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `, [
+    page.route,
+    normalizeRouteKey(page.route),
+    page.title,
+    page.description,
+    page.markdown,
+    page.headings,
+    JSON.stringify(page.keywords),
+    page.contentHash || null,
+    page.updatedAt,
+    now,
+    page.isError ? 1 : 0,
+    page.isError ? 0 : 1,
+    source,
+    now
+  ]);
+}
+export async function queryAllPages(db, options) {
+  const where = options?.includeErrors ? "" : "WHERE is_error = 0";
+  const rows = await db.all(`SELECT route, title, description, markdown, headings, keywords, content_hash, updated_at, is_error FROM ai_ready_pages ${where}`);
+  return rows.map((row) => ({
+    route: row.route,
+    title: row.title,
+    description: row.description,
+    markdown: row.markdown,
+    headings: row.headings,
+    keywords: JSON.parse(row.keywords || "[]"),
+    contentHash: row.content_hash || void 0,
+    updatedAt: row.updated_at,
+    isError: row.is_error === 1
+  }));
+}
+export async function exportDbDump(db) {
+  const rows = await db.all(`
+    SELECT route, route_key, title, description, markdown, headings, keywords, content_hash, updated_at, indexed_at, is_error, indexed, source, last_seen_at
+    FROM ai_ready_pages
+  `);
+  return compressToBase64(rows);
+}
+export async function importDbDump(db, rows) {
+  for (const row of rows) {
+    const source = row.source || "prerender";
+    await db.exec(`
+      INSERT OR REPLACE 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)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, NULL)
+    `, [row.route, row.route_key, row.title, row.description, row.markdown, row.headings, row.keywords, row.content_hash || null, row.updated_at, row.indexed_at, row.is_error, source]);
+  }
+}