nuxt-ai-ready 2.1.0 → 2.2.1

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.BTQAkSYt.mjs';
+import { A as AGENT_SKILLS_SCHEMA } from '../shared/nuxt-ai-ready.BVWXwmUS.mjs';
 import 'node:module';
 import '@nuxt/kit';
 import 'defu';
@@ -10,9 +10,12 @@ import 'nuxt-site-config/kit';
 import 'nuxtseo-shared/kit';
 import 'pkg-types';
 import 'node:url';
+import '../../dist/runtime/markdown-path.js';
+import '../../dist/runtime/server/utils/sitemap-md.js';
 import '../../dist/runtime/server/utils/discovery-response.js';
 import 'pathe';
 import 'nuxtseo-shared/i18n';
+import '../../dist/runtime/route-path.js';
 
 const namePattern = /^(?!.*--)[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
 const digestPattern = /^sha256:[a-f0-9]{64}$/;

package/dist/chunks/prerender.mjs

@@ -5,11 +5,12 @@ 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.BTQAkSYt.mjs';
+import { l as logger, s as supportsNativeNodeSqlite, M as MARKDOWN_LINK_AVAILABILITY_FILE } from '../shared/nuxt-ai-ready.BVWXwmUS.mjs';
 import { normalizePagePath, toMarkdownPath } from '../../dist/runtime/markdown-path.js';
-import { toLogicalRoute, toDeployedRoute } from '../../dist/runtime/route-path.js';
+import { toDeployedRoute, toLogicalRoute } from '../../dist/runtime/route-path.js';
 import { initSchema, computeContentHash, insertPage, queryAllPages, exportDbDump } from '../../dist/runtime/server/db/shared.js';
 import { buildLlmsFullTxtHeader, formatPageForLlmsFullTxt } from '../../dist/runtime/server/utils/llms-full.js';
+import { SITEMAP_MD_ROUTE, appendSitemapSection } from '../../dist/runtime/server/utils/sitemap-md.js';
 import 'node:crypto';
 import 'node:module';
 import 'defu';
@@ -320,6 +321,8 @@ function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, extras
         logger.debug(`Detected error page: ${pageRoute2}`);
         return;
       }
+      if (route.fileName === SITEMAP_MD_ROUTE)
+        return;
       if (!route.fileName?.endsWith(".md"))
         return;
       let pageRoute = route.route.replace(RE_MD_EXT, "");
@@ -331,7 +334,7 @@ function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, extras
       await initPromise;
       const parsed = JSON.parse(route.contents || "{}");
       await processMarkdownRoute(state, nuxt, pageRoute, parsed);
-      route.contents = parsed.markdown;
+      route.contents = options.sitemapMd === false ? parsed.markdown : appendSitemapSection(parsed.markdown, toDeployedRoute(SITEMAP_MD_ROUTE, nitro.options.baseURL));
       route.contentType = "text/markdown; charset=utf-8";
       state.totalProcessingTime += Date.now() - pageStartTime;
     });
@@ -406,6 +409,10 @@ function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, extras
       const llmsStats = await prerenderRoute(nitro, "/llms.txt");
       const llmsFullStats = await stat(state.llmsFullTxtPath);
       nitro._prerenderedRoutes.push({ route: "/llms-full.txt", fileName: "/llms-full.txt" });
+      if (options.sitemapMd !== false) {
+        const sitemapMdStats = await prerenderRoute(nitro, SITEMAP_MD_ROUTE);
+        logger.debug(`Wrote sitemap.md (${(sitemapMdStats.size / 1024).toFixed(1)}kb)`);
+      }
       const kb = (b) => (b / 1024).toFixed(1);
       const totalKb = kb(llmsStats.size + llmsFullStats.size);
       const dim = (s) => colorize("dim", s);

package/dist/cli.mjs

@@ -26,11 +26,22 @@ async function requireSecret(cwd, hint = "") {
   }
   return secret;
 }
+function describeHttpError(status, body) {
+  const error = body;
+  const message = typeof error?.message === "string" && error.message ? error.message : typeof error?.statusMessage === "string" && error.statusMessage ? error.statusMessage : typeof error?.error === "string" && error.error ? error.error : null;
+  return message ? `${status}: ${message}` : `request failed with status ${status}`;
+}
 async function fetchJson(url, init, errorLabel = "Failed") {
-  return fetch(url, init).then((r) => r.json()).catch((err) => {
-    consola.error(`${errorLabel}: ${err.message}`);
-    return null;
+  const r = await fetch(url, init).catch((err) => {
+    throw new Error(`${errorLabel}: ${err instanceof Error ? err.message : String(err)}`);
   });
+  if (!r.ok) {
+    const body = await r.json().catch(() => {
+      return null;
+    });
+    throw new Error(`${errorLabel}: ${describeHttpError(r.status, body)}`);
+  }
+  return r.json();
 }
 const main = defineCommand({
   meta: {
@@ -65,8 +76,6 @@ const main = defineCommand({
         const url = `${args.url}/__ai-ready/status`;
         consola.info(`Fetching status from ${args.url}...`);
         const res = await fetchJson(url, { headers: authHeaders(secret) }, "Failed to connect");
-        if (!res)
-          return;
         consola.box("AI Ready Status");
         consola.info(`Total pages: ${colors.cyan(res.total?.toString() || "0")}`);
         consola.info(`Indexed: ${colors.green(res.indexed?.toString() || "0")}`);
@@ -151,8 +160,6 @@ const main = defineCommand({
         const url = `${args.url}/__ai-ready/poll?${params}`;
         consola.info(`Triggering poll at ${args.url}...`);
         const res = await fetchJson(url, { method: "POST", headers: authHeaders(secret) });
-        if (!res)
-          return;
         consola.success(`Indexed: ${colors.green(res.indexed?.toString() || "0")} pages`);
         consola.info(`Remaining: ${colors.yellow(res.remaining?.toString() || "0")}`);
         if (res.errors?.length) {
@@ -199,8 +206,6 @@ const main = defineCommand({
         const url = `${args.url}/__ai-ready/restore?${params}`;
         consola.info(`Restoring database at ${args.url}...`);
         const res = await fetchJson(url, { method: "POST", headers: authHeaders(secret) });
-        if (!res)
-          return;
         consola.success(`Restored: ${colors.green(res.restored?.toString() || "0")} pages`);
         if (res.cleared) {
           consola.info(`Cleared: ${colors.yellow(res.cleared?.toString() || "0")} existing pages`);
@@ -252,8 +257,6 @@ const main = defineCommand({
           method: "POST",
           headers: secret ? authHeaders(secret) : void 0
         });
-        if (!res)
-          return;
         if (args.dry) {
           consola.info(`Would prune: ${colors.yellow(res.count?.toString() || "0")} routes`);
           if (res.routes?.length) {
@@ -268,6 +271,59 @@ const main = defineCommand({
           consola.success(`Pruned: ${colors.green(res.pruned?.toString() || "0")} routes`);
         }
       }
+    }),
+    reindex: () => defineCommand({
+      meta: {
+        name: "reindex",
+        description: "Reindex a single route"
+      },
+      args: {
+        route: {
+          type: "positional",
+          description: "Route to reindex (e.g. /about)",
+          required: true
+        },
+        url: {
+          type: "string",
+          alias: "u",
+          description: "Site URL (default: http://localhost:3000)",
+          default: "http://localhost:3000"
+        },
+        force: {
+          type: "boolean",
+          description: "Index even when the page is still fresh",
+          default: true,
+          negativeDescription: "Skip indexing when the page is still fresh"
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory",
+          default: "."
+        }
+      },
+      async run({ args }) {
+        const cwd = resolve(args.cwd || ".");
+        const secret = await requireSecret(cwd);
+        if (!secret)
+          return;
+        const params = new URLSearchParams();
+        params.set("route", args.route);
+        if (!args.force)
+          params.set("force", "false");
+        const url = `${args.url}/__ai-ready/reindex?${params}`;
+        consola.info(`Reindexing ${args.route} at ${args.url}...`);
+        const res = await fetchJson(url, { method: "POST", headers: authHeaders(secret) });
+        if (res.indexed) {
+          consola.success(`Indexed: ${colors.green(res.route)}`);
+          if (res.contentChanged !== void 0) {
+            consola.info(`Content changed: ${res.contentChanged ? colors.green("yes") : colors.yellow("no")}`);
+          }
+        } else if (res.skipped) {
+          consola.info(`Skipped: ${colors.yellow(res.route)} (still fresh)`);
+        } else {
+          throw new Error(`Failed to reindex ${res.route ?? args.route}${res.error ? `: ${res.error}` : ""}`);
+        }
+      }
     })
   }
 });

package/dist/module.d.mts

@@ -85,6 +85,8 @@ interface ModulePublicRuntimeConfig {
     debugCron: boolean;
     contentNegotiation: ContentNegotiationPolicy;
     version: string;
+    sitemapMd: boolean;
+    describedby: boolean;
     mdreamOptions: ModuleOptions['mdreamOptions'];
     markdownCacheHeaders: Required<NonNullable<ModuleOptions['markdownCacheHeaders']>>;
     database: ResolvedDatabase;

package/dist/module.json

@@ -4,7 +4,7 @@
     "nuxt": ">=4.0.0"
   },
   "configKey": "aiReady",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -7,8 +7,11 @@ import 'defu';
 import 'nuxt-site-config/kit';
 import 'nuxtseo-shared/kit';
 import 'pkg-types';
-export { m as default } from './shared/nuxt-ai-ready.BTQAkSYt.mjs';
+export { m as default } from './shared/nuxt-ai-ready.BVWXwmUS.mjs';
+import '../dist/runtime/markdown-path.js';
+import '../dist/runtime/server/utils/sitemap-md.js';
 import '../dist/runtime/server/utils/discovery-response.js';
 import 'node:url';
 import 'pathe';
 import 'nuxtseo-shared/i18n';
+import '../dist/runtime/route-path.js';

package/dist/runtime/app/plugins/md-alternate.server.js

@@ -1,4 +1,5 @@
-import { defineNuxtPlugin, useHead, useRequestURL } from "nuxt/app";
+import { defineNuxtPlugin, useHead, useRequestURL, useRuntimeConfig } from "nuxt/app";
+import { joinURL } from "ufo";
 import { toMarkdownPath } from "../../markdown-path.js";
 export default defineNuxtPlugin({
   setup() {
@@ -7,9 +8,12 @@ export default defineNuxtPlugin({
     const lastSegment = path.split("/").pop() || "";
     if (lastSegment.includes("."))
       return;
+    const runtimeConfig = useRuntimeConfig();
+    const describedby = runtimeConfig["nuxt-ai-ready"]?.describedby !== false;
     useHead({
       link: [
-        { rel: "alternate", type: "text/markdown", href: toMarkdownPath(path) }
+        { rel: "alternate", type: "text/markdown", href: toMarkdownPath(path) },
+        ...describedby ? [{ rel: "describedby", href: joinURL(runtimeConfig.app.baseURL, "llms.txt") }] : []
       ]
     });
   }

package/dist/runtime/llms-txt-utils.js

@@ -4,7 +4,7 @@ import { useRuntimeConfig } from "#nuxtseo/nitro";
 import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 import { withSiteTrailingSlash, withSiteUrl } from "#site-config/server/composables/utils";
 import { formatLlmsTxtPageLink, normalizeLlmsTxtConfig } from "./llms-txt-format.js";
-import { toMarkdownPath } from "./markdown-path.js";
+import { isReservedPath, toMarkdownPath } from "./markdown-path.js";
 import { normalizePersistedRoute, toDeployedRoute, toLogicalRoute } from "./route-path.js";
 import { queryPages } from "./server/db/queries.js";
 import { logger } from "./server/logger.js";
@@ -12,7 +12,7 @@ import { fetchSitemapUrls } from "./server/utils/sitemap.js";
 export { normalizeLlmsTxtConfig };
 function hasRuntimeMarkdownHandler(pathname) {
   const lastSegment = pathname.split("/").pop() || "";
-  return !pathname.startsWith("/api") && !pathname.startsWith("/_") && !pathname.startsWith("/@") && !lastSegment.includes(".");
+  return !isReservedPath(pathname) && !lastSegment.includes(".");
 }
 async function findMarkdownLinkAvailability() {
   if (!import.meta.prerender) {

package/dist/runtime/markdown-path.d.ts

@@ -1,2 +1,4 @@
+/** True for the `/api` namespace and Nitro's `/_*` and `/@*` internal paths. */
+export declare function isReservedPath(path: string): boolean;
 export declare function normalizePagePath(path: string): string;
 export declare function toMarkdownPath(path: string): string;

package/dist/runtime/markdown-path.js

@@ -1,4 +1,8 @@
 const RE_TRAILING_SLASHES = /\/+$/;
+const RE_RESERVED_PATH = /^\/(?:api(?:\/|$)|_|@)/;
+export function isReservedPath(path) {
+  return RE_RESERVED_PATH.test(path);
+}
 export function normalizePagePath(path) {
   return path.replace(RE_TRAILING_SLASHES, "") || "/";
 }

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

@@ -4,7 +4,7 @@
 export * from '#ai-ready-virtual/db-schema.mjs';
 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 { completeCronRun, countPages, deleteInfoValue, 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';
 export { useRawDb } from './raw.js';
 export type { RawExecutor } from './raw.js';

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

@@ -4,7 +4,6 @@ export {
   completeCronRun,
   countPages,
   deleteInfoValue,
-  deletePage,
   getAllPages,
   getContentHashes,
   getInfoValue,

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

@@ -65,10 +65,6 @@ export declare function countPages(event: H3Event | undefined, options?: {
     indexed?: boolean;
     errors?: boolean;
 }): Promise<number>;
-/**
- * Delete a page by route
- */
-export declare function deletePage(event: H3Event | undefined, route: string): Promise<void>;
 /**
  * Get pending pages (not yet indexed)
  */

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

@@ -1,8 +1,9 @@
-import { and, count, desc, eq, gt, isNotNull, isNull, like, lt, or, sql } from "drizzle-orm";
+import { and, count, desc, eq, gt, isNotNull, isNull, lt, or, sql } from "drizzle-orm";
 import { cronRuns, info, pages, sitemaps } from "#ai-ready-virtual/db-schema.mjs";
 import { useRuntimeConfig } from "#nuxtseo/nitro";
 import { parseSitemapCrawlState, serializeSitemapCrawlState } from "../../utils/sitemap-crawl-state.js";
 import { resolveFtsTokenizer as validateFtsTokenizer } from "../schema-sql.js";
+import { LIKE_ESCAPE, likeSubstring, maxRowsPerInsert } from "../shared.js";
 import { useDrizzle } from "./client.js";
 import { getRawExecutor, useRawDb } from "./raw.js";
 function resolveFtsTokenizer(event) {
@@ -127,7 +128,8 @@ export async function getPageLastmods(event) {
 export async function searchPages(event, query, options) {
   const client = await useDrizzle(event);
   const limitNum = options?.limit || 20;
-  const searchTerm = `%${query}%`;
+  const searchTerm = likeSubstring(query);
+  const matches = (col) => sql`${col} LIKE ${searchTerm} ESCAPE ${LIKE_ESCAPE}`;
   if (client.dialect === "sqlite") {
     try {
       const ftsResult = await client.db.all(sql`
@@ -155,10 +157,10 @@ export async function searchPages(event, query, options) {
     and(
       eq(pages.isError, 0),
       or(
-        like(pages.title, searchTerm),
-        like(pages.description, searchTerm),
-        like(pages.markdown, searchTerm),
-        like(pages.headings, searchTerm)
+        matches(pages.title),
+        matches(pages.description),
+        matches(pages.markdown),
+        matches(pages.headings)
       )
     )
   ).limit(limitNum);
@@ -172,6 +174,8 @@ export async function countPages(event, options) {
   }
   if (options?.errors !== void 0) {
     conditions.push(eq(pages.isError, options.errors ? 1 : 0));
+  } else {
+    conditions.push(eq(pages.isError, 0));
   }
   let query = client.db.select({ count: count() }).from(pages);
   if (conditions.length > 0) {
@@ -180,13 +184,12 @@ export async function countPages(event, options) {
   const result = await query;
   return Number(result[0]?.count || 0);
 }
-export async function deletePage(event, route) {
-  const client = await useDrizzle(event);
-  await client.db.delete(pages).where(eq(pages.route, route));
-}
 export async function getPendingPages(event, limit = 10) {
   const client = await useDrizzle(event);
-  return client.db.select({ route: pages.route }).from(pages).where(eq(pages.indexed, 0)).limit(limit);
+  return client.db.select({ route: pages.route }).from(pages).where(and(
+    eq(pages.indexed, 0),
+    eq(pages.isError, 0)
+  )).orderBy(pages.route).limit(limit);
 }
 export async function markPageIndexed(event, route) {
   const client = await useDrizzle(event);
@@ -202,7 +205,7 @@ export async function markRoutesPending(event, routes) {
     const batch = routes.slice(i, i + D1_MAX_IN_ROUTES);
     const placeholders = batch.map(() => "?").join(",");
     stmts.push({
-      sql: `UPDATE ai_ready_pages SET indexed = 0 WHERE route IN (${placeholders})`,
+      sql: `UPDATE ai_ready_pages SET indexed = 0, is_error = 0 WHERE route IN (${placeholders})`,
       params: batch
     });
   }
@@ -675,21 +678,24 @@ export async function seedRoutes(event, routes) {
     const route = normalizeRoute(raw);
     byRoute.set(route, normalizeRouteKey(route));
   }
-  const ROWS_PER_INSERT = 20;
+  const rowsPerInsert = maxRowsPerInsert(4);
   const db = await useRawDb(event);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const nowMs = Date.now();
   const entries = [...byRoute.entries()];
   const stmts = [];
-  for (let i = 0; i < entries.length; i += ROWS_PER_INSERT) {
-    const batch = entries.slice(i, i + ROWS_PER_INSERT);
+  for (let i = 0; i < entries.length; i += rowsPerInsert) {
+    const batch = entries.slice(i, i + rowsPerInsert);
     const valuesSql = batch.map(() => `(?, ?, '', '', '', '[]', '[]', ?, 0, 0, 0, 'runtime', ?)`).join(", ");
     const params = batch.flatMap(([route, routeKey]) => [route, routeKey, now, nowMs]);
     stmts.push({
       sql: `
         INSERT INTO ai_ready_pages (route, route_key, title, description, markdown, headings, keywords, updated_at, indexed_at, is_error, indexed, source, last_seen_at)
         VALUES ${valuesSql}
-        ON CONFLICT(route) DO UPDATE SET last_seen_at = excluded.last_seen_at
+        ON CONFLICT(route) DO UPDATE SET
+          last_seen_at = excluded.last_seen_at,
+          is_error = 0,
+          indexed = CASE WHEN ai_ready_pages.is_error = 1 THEN 0 ELSE ai_ready_pages.indexed END
       `,
       params
     });

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

@@ -136,10 +136,7 @@ export function getRawExecutor(client) {
           const sqlFn = driver;
           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) => {
-              return sqlFn.query(toPostgresQuery(q.sql), q.params || []);
-            });
-            await sqlFn.transaction(pgQueries);
+            await sqlFn.transaction((tx) => chunk.map((q) => tx.query(toPostgresQuery(q.sql), q.params || [])));
           }
           break;
         }

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

@@ -140,15 +140,8 @@ export declare function getPageHash(event: H3Event | undefined, route: string):
 export declare function seedRoutes(event: H3Event | undefined, routes: Array<string | {
     route: string;
     locale?: string;
+    url?: string;
 }>): Promise<number>;
-/**
- * Get sitemap seeded timestamp from _ai_ready_info
- */
-export declare function getSitemapSeededAt(event: H3Event | undefined): Promise<number | undefined>;
-/**
- * Set sitemap seeded timestamp
- */
-export declare function setSitemapSeededAt(event: H3Event | undefined, timestamp: number): Promise<void>;
 /**
  * Prune routes not seen in sitemap for longer than threshold
  * Only prunes routes with source='runtime' (never prerendered pages)
@@ -194,10 +187,6 @@ export declare function completeCronRun(event: H3Event | undefined, runId: numbe
  * Get recent cron runs
  */
 export declare function getRecentCronRuns(event: H3Event | undefined, limit?: number): Promise<CronRun[]>;
-/**
- * Clean up old cron runs (keep last N)
- */
-export declare function cleanupOldCronRuns(event: H3Event | undefined, keepCount?: number): Promise<number>;
 /**
  * Clean up cron runs older than specified age
  */
@@ -214,15 +203,27 @@ export interface CronFastPathStatus {
  * Reduces 6+ sequential DB calls to 1
  */
 export declare function getCronFastPathStatus(event: H3Event | undefined, sitemapIntervalMinutes?: number): Promise<CronFastPathStatus | null>;
-/**
- * Try to acquire cron lock. Returns true if acquired, false if another run is active.
- * Uses atomic INSERT OR REPLACE with conditional check to prevent race conditions.
- */
-export declare function tryAcquireCronLock(event: H3Event | undefined): Promise<boolean>;
-/**
- * Release cron lock
- */
-export declare function releaseCronLock(event: H3Event | undefined): Promise<void>;
+export type CronLockAcquire = {
+    _tag: 'acquired';
+    token: string;
+} | {
+    _tag: 'held';
+};
+/**
+ * Try to acquire cron lock. Returns the ownership token on success, `held`
+ * when a live lock belongs to another run.
+ *
+ * The value carries a random token plus expiry in one row, so the
+ * compare-expired-then-set upsert is atomic and ownership is unique even for
+ * two isolates that start in the same millisecond. A legacy value that
+ * predates tokens parses as no expiry, so it is treated as expired.
+ */
+export declare function tryAcquireCronLock(event: H3Event | undefined): Promise<CronLockAcquire>;
+/**
+ * Release cron lock. Only deletes the row when its token is ours, so a run
+ * that outlived the lock TTL cannot delete the new owner's lock.
+ */
+export declare function releaseCronLock(event: H3Event | undefined, token: string): Promise<void>;
 export interface CronLockStatus {
     held: boolean;
     since: number | null;