nuxt-ai-ready 1.7.13 → 1.8.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.DQXoppXw.mjs';
+import { A as AGENT_SKILLS_SCHEMA } from '../shared/nuxt-ai-ready.B6l-68o5.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, withBase, joinURL } from 'ufo';
-import { l as logger, M as MARKDOWN_LINK_AVAILABILITY_FILE } from '../shared/nuxt-ai-ready.DQXoppXw.mjs';
+import { l as logger, M as MARKDOWN_LINK_AVAILABILITY_FILE } from '../shared/nuxt-ai-ready.B6l-68o5.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';
@@ -137,38 +137,52 @@ async function initCrawler(state) {
   }
   state.initialized = true;
 }
-async function createPrerenderDatabase(dbPath) {
-  const nodeVersion = Number.parseInt(process.versions.node?.split(".")[0] || "0");
-  if (nodeVersion >= 22) {
-    const { DatabaseSync } = await import('node:sqlite');
-    const sqlite2 = new DatabaseSync(dbPath);
-    return {
-      all: async (sql, params = []) => sqlite2.prepare(sql).all(...params),
-      first: async (sql, params = []) => sqlite2.prepare(sql).get(...params),
-      exec: async (sql, params = []) => {
-        if (params.length)
-          sqlite2.prepare(sql).run(...params);
-        else
-          sqlite2.exec(sql);
-      },
-      close: async () => {
-        sqlite2.close();
-      }
-    };
+const PRERENDER_PRAGMAS = [
+  "PRAGMA synchronous = OFF",
+  "PRAGMA temp_store = MEMORY"
+];
+function createSqliteAdapter(sqlite) {
+  const statements = /* @__PURE__ */ new Map();
+  function prepare(sql) {
+    let statement = statements.get(sql);
+    if (!statement) {
+      statement = sqlite.prepare(sql);
+      statements.set(sql, statement);
+    }
+    return statement;
   }
-  const { default: Database } = await import('better-sqlite3');
-  const sqlite = new Database(dbPath);
   return {
-    all: async (sql, params = []) => sqlite.prepare(sql).all(...params),
-    first: async (sql, params = []) => sqlite.prepare(sql).get(...params),
+    all: async (sql, params = []) => prepare(sql).all(...params),
+    first: async (sql, params = []) => prepare(sql).get(...params),
     exec: async (sql, params = []) => {
-      sqlite.prepare(sql).run(...params);
+      if (params.length) {
+        prepare(sql).run(...params);
+        return;
+      }
+      statements.clear();
+      sqlite.exec(sql);
     },
     close: async () => {
+      statements.clear();
       sqlite.close();
     }
   };
 }
+async function createPrerenderDatabase(dbPath) {
+  const nodeVersion = Number.parseInt(process.versions.node?.split(".")[0] || "0");
+  if (nodeVersion >= 22) {
+    const { DatabaseSync } = await import('node:sqlite');
+    const sqlite2 = new DatabaseSync(dbPath);
+    for (const pragma of PRERENDER_PRAGMAS)
+      sqlite2.exec(pragma);
+    return createSqliteAdapter(sqlite2);
+  }
+  const { default: Database } = await import('better-sqlite3');
+  const sqlite = new Database(dbPath);
+  for (const pragma of PRERENDER_PRAGMAS)
+    sqlite.exec(pragma);
+  return createSqliteAdapter(sqlite);
+}
 function flattenHeadings(headings) {
   return (headings || []).map((h) => Object.entries(h).map(([tag, text]) => `${tag}:${text}`).join("")).join("|");
 }
@@ -224,6 +238,7 @@ async function processSitemapEntry(state, nuxt, nitro, entry) {
   logger.debug(`Fetching markdown for ${route} \u2192 ${mdUrl}`);
   const res = await globalThis.$fetch(mdUrl, {
     headers: { "x-nitro-prerender": mdRoute },
+    retry: 0,
     signal: AbortSignal.timeout(PRERENDER_PAGE_TIMEOUT)
   }).catch((err) => {
     if (err?.name === "TimeoutError" || err?.name === "AbortError")

package/dist/module.json

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

package/dist/runtime/types.d.ts

@@ -113,6 +113,19 @@ export interface ModuleOptions {
      * @default undefined
      */
     apiCatalog?: false | ApiCatalogConfig;
+    /**
+     * Read a page's Markdown from the installed content module instead of
+     * rendering the page and converting its HTML.
+     *
+     * Supports @nuxt/content v3 and @harlan-zw/comark-content. When a content
+     * module is present this skips one SSR render per route and keeps the source
+     * Markdown intact, so MDC blocks, tables and code fences survive.
+     *
+     * Set to false to convert the rendered HTML instead. Do that when a page's
+     * meaning depends on what its components render rather than on its source.
+     * @default true
+     */
+    contentSource?: boolean;
     /**
      * Options to pass to mdream htmlToMarkdown function
      */

package/dist/shared/{nuxt-ai-ready.DQXoppXw.mjs → nuxt-ai-ready.B6l-68o5.mjs}

@@ -2,11 +2,11 @@ import { createHash, randomBytes } from 'node:crypto';
 import { readFile, mkdir, writeFile, access } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { dirname, basename, join } from 'node:path';
-import { useLogger, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, addServerImports, hasNuxtModule, addServerPlugin, addServerHandler, extendRouteRules, addPlugin, addImports } from '@nuxt/kit';
+import { hasNuxtModule, useNuxt, useLogger, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, addServerImports, addServerPlugin, addServerHandler, extendRouteRules, addPlugin, addImports } from '@nuxt/kit';
 import defu from 'defu';
 import { installNuxtSiteConfig, useSiteConfig, withSiteUrl } from 'nuxt-site-config/kit';
-import { renderNitroTypeAugmentations, setupNitroRuntimeCompatibility, resolveNuxtContentVersion } from 'nuxtseo-shared/kit';
-import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
+import { resolveNuxtContentVersion, renderNitroTypeAugmentations, setupNitroRuntimeCompatibility } from 'nuxtseo-shared/kit';
+import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { MCP_SERVER_CARD_MEDIA_TYPE, AI_CATALOG_MEDIA_TYPE } from '../../dist/runtime/server/utils/discovery-response.js';
 import { isAbsolute, join as join$1 } from 'pathe';
@@ -77,6 +77,93 @@ export async function readPageDataFromFilesystem() {
 `;
 }
 
+const COMARK_MODULE = "@harlan-zw/comark-content";
+const COMARK_MINIMUM = [0, 1, 2];
+async function comarkSatisfiesMinimum() {
+  const url = useNuxt().options.rootDir;
+  const pkg = await readPackageJSON(COMARK_MODULE, { url }).catch(() => {
+    return null;
+  });
+  const parts = pkg?.version?.split(".").map((part) => Number.parseInt(part, 10));
+  if (!parts || parts.length < 3 || parts.some((part) => !Number.isFinite(part)))
+    return false;
+  for (const [index, minimum] of COMARK_MINIMUM.entries()) {
+    if (parts[index] !== minimum)
+      return parts[index] > minimum;
+  }
+  return true;
+}
+async function resolveContentSource(enabled) {
+  if (!enabled)
+    return { _tag: "None" };
+  const contentVersion = await resolveNuxtContentVersion();
+  if (contentVersion && contentVersion.version === 3)
+    return { _tag: "NuxtContentV3" };
+  if (hasNuxtModule(COMARK_MODULE) && await comarkSatisfiesMinimum())
+    return { _tag: "ComarkContent" };
+  return { _tag: "None" };
+}
+const NUXT_CONTENT_V3_LOOKUP = `
+import { queryCollection } from '@nuxt/content/server'
+import manifest from '#content/manifest'
+import { stringify } from 'minimark/stringify'
+
+const pageCollections = Object.entries(manifest)
+  .filter(([, info]) => info.type === 'page')
+  .map(([name]) => name)
+
+export async function lookupContentPage(event, path) {
+  if (!pageCollections.length) return null
+  const candidates = path === '/' ? ['/'] : [path, path.replace(/\\/$/, '')]
+  for (const collection of pageCollections) {
+    for (const candidate of candidates) {
+      const page = await queryCollection(event, collection).path(candidate).first().catch(() => null)
+      if (!page) continue
+      const markdown = stringify({ ...page.body, type: 'minimark' }, { format: 'markdown/html' })
+      return {
+        markdown,
+        title: page.title,
+        description: page.description,
+        updatedAt: page.seo?.articleModifiedTime || page.updatedAt,
+      }
+    }
+  }
+  return null
+}
+`;
+const COMARK_LOOKUP = `
+import { queryCollection, queryCollectionManifest, renderPageMarkdown } from '@harlan-zw/comark-content/server'
+
+let manifestPromise
+
+export async function lookupContentPage(event, path) {
+  manifestPromise ??= queryCollectionManifest(event)
+  const manifest = await manifestPromise
+  for (const { name } of manifest) {
+    const page = await queryCollection(event, name).path(path).first()
+    if (!page) continue
+    return {
+      markdown: await renderPageMarkdown(page.body),
+      title: page.title,
+      description: page.description,
+      updatedAt: page.seo?.articleModifiedTime || page.updatedAt,
+    }
+  }
+  return null
+}
+`;
+const NO_CONTENT_LOOKUP = `export async function lookupContentPage() { return null }`;
+function contentLookupModule(source) {
+  switch (source._tag) {
+    case "NuxtContentV3":
+      return NUXT_CONTENT_V3_LOOKUP;
+    case "ComarkContent":
+      return COMARK_LOOKUP;
+    case "None":
+      return NO_CONTENT_LOOKUP;
+  }
+}
+
 const logger = useLogger("nuxt-ai-ready");
 
 function resolveModuleEntryUrl(url) {
@@ -1043,8 +1130,7 @@ ${details}`);
       if (mcpConfig.resources !== false)
         (paths.resources ||= []).push(`${mcpRuntimeDir}/resources`);
     });
-    const contentVersion = await resolveNuxtContentVersion();
-    const hasNuxtContentV3 = !!(contentVersion && contentVersion.version === 3);
+    const contentSource = await resolveContentSource(config.contentSource !== false);
     if (typeof config.contentSignal === "object") {
       const robotsOpts = nuxt.options.robots || {};
       nuxt.options.robots = robotsOpts;
@@ -1423,34 +1509,7 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
         mcp: { enabled: mcpAvailable, tools: mcpAvailable && config.mcp?.tools !== false && hasMcpSiteTools, resources: mcpAvailable && config.mcp?.resources !== false },
         cron: !!config.cron
       })}`;
-      nitroConfig.virtual["#ai-ready-virtual/content-lookup.mjs"] = hasNuxtContentV3 ? `
-import { queryCollection } from '@nuxt/content/server'
-import manifest from '#content/manifest'
-import { stringify } from 'minimark/stringify'
-
-const pageCollections = Object.entries(manifest)
-  .filter(([, info]) => info.type === 'page')
-  .map(([name]) => name)
-
-export async function lookupContentPage(event, path) {
-  if (!pageCollections.length) return null
-  const candidates = path === '/' ? ['/'] : [path, path.replace(/\\/$/, '')]
-  for (const collection of pageCollections) {
-    for (const candidate of candidates) {
-      const page = await queryCollection(event, collection).path(candidate).first().catch(() => null)
-      if (!page) continue
-      const markdown = stringify({ ...page.body, type: 'minimark' }, { format: 'markdown/html' })
-      return {
-        markdown,
-        title: page.title,
-        description: page.description,
-        updatedAt: page.seo?.articleModifiedTime || page.updatedAt,
-      }
-    }
-  }
-  return null
-}
-` : `export async function lookupContentPage() { return null }`;
+      nitroConfig.virtual["#ai-ready-virtual/content-lookup.mjs"] = contentLookupModule(contentSource);
     });
     const database = refineDatabaseConfig(config.database || {}, nuxt.options.rootDir);
     nuxt.options.runtimeConfig["nuxt-ai-ready"] = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "1.7.13",
+  "version": "1.8.0",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",
@@ -82,6 +82,7 @@
   "devDependencies": {
     "@antfu/eslint-config": "^9.3.0",
     "@arethetypeswrong/cli": "^0.18.5",
+    "@harlan-zw/comark-content": "0.1.2",
     "@libsql/client": "^0.17.4",
     "@nuxt/content": "^3.15.2",
     "@nuxt/module-builder": "^1.0.3",