qarpeo 0.0.0-alpha.10

package/dist/runtime/server/utils/cache.mjs

@@ -0,0 +1,128 @@
+import { useStorage } from "nitro/storage";
+export function useCacheStorage() {
+  return useStorage("cache");
+}
+export function parseDurationSeconds(duration) {
+  if (typeof duration === "number") return duration;
+  const match = duration.trim().match(/^(\d+(?:\.\d+)?)\s*(s|m|h|d|w)?$/i);
+  if (!match) return Number(duration) || 3600;
+  const num = parseFloat(match[1]);
+  const unit = (match[2] || "s").toLowerCase();
+  const multipliers = {
+    s: 1,
+    m: 60,
+    h: 3600,
+    d: 86400,
+    w: 604800
+  };
+  return Math.round(num * (multipliers[unit] || 1));
+}
+function matchesCachePattern(pattern, targetKey) {
+  if (pattern === targetKey) return true;
+  let norm = pattern.replace(/^\/+/, "");
+  if (!norm.includes("*")) {
+    norm = `*${norm}*`;
+  }
+  const escaped = norm.replace(/[.+^$(){}|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, ".*").replace(/\//g, "[:/]");
+  const re = new RegExp(escaped, "i");
+  return re.test(targetKey);
+}
+export async function purgeCache(pattern) {
+  const storage = useCacheStorage();
+  if (!storage) return [];
+  if (!pattern) {
+    const allKeys2 = await storage.getKeys() || [];
+    await storage.clear();
+    return allKeys2;
+  }
+  if (await storage.hasItem(pattern)) {
+    await storage.removeItem(pattern);
+    return [pattern];
+  }
+  const allKeys = await storage.getKeys() || [];
+  const matchedKeys = allKeys.filter((k) => matchesCachePattern(pattern, k));
+  if (matchedKeys.length > 0) {
+    await Promise.all(matchedKeys.map((k) => storage.removeItem(k)));
+  }
+  return matchedKeys;
+}
+export async function rememberCache(key, ttl, fetcher) {
+  const storage = useCacheStorage();
+  if (!storage) {
+    return await fetcher();
+  }
+  const durationSec = parseDurationSeconds(ttl);
+  const cleanKey = key.replace(/^\/+/, "");
+  try {
+    const raw = await storage.getItem(cleanKey);
+    if (raw !== null && typeof raw === "object" && "value" in raw && "expiresAt" in raw) {
+      const entry = raw;
+      if (Date.now() < entry.expiresAt) {
+        return entry.value;
+      }
+    } else if (raw !== null && raw !== void 0) {
+      return raw;
+    }
+  } catch {
+  }
+  const value = await fetcher();
+  try {
+    const entry = {
+      value,
+      expiresAt: Date.now() + durationSec * 1e3
+    };
+    await storage.setItem(cleanKey, entry);
+  } catch {
+  }
+  return value;
+}
+export async function getCacheItem(key) {
+  const storage = useCacheStorage();
+  if (!storage) return null;
+  const cleanKey = key.replace(/^\/+/, "");
+  try {
+    const raw = await storage.getItem(cleanKey);
+    if (raw !== null && typeof raw === "object" && "value" in raw && "expiresAt" in raw) {
+      const entry = raw;
+      if (Date.now() < entry.expiresAt) {
+        return entry.value;
+      }
+      await storage.removeItem(cleanKey);
+      return null;
+    }
+    return raw;
+  } catch {
+    return null;
+  }
+}
+export async function setCacheItem(key, value, ttl) {
+  const storage = useCacheStorage();
+  if (!storage) return;
+  const cleanKey = key.replace(/^\/+/, "");
+  const durationSec = ttl ? parseDurationSeconds(ttl) : 3600;
+  const entry = {
+    value,
+    expiresAt: Date.now() + durationSec * 1e3
+  };
+  await storage.setItem(cleanKey, entry);
+}
+export async function removeCacheItem(key) {
+  const storage = useCacheStorage();
+  if (!storage) return;
+  const cleanKey = key.replace(/^\/+/, "");
+  await storage.removeItem(cleanKey);
+}
+export async function hasCacheItem(key) {
+  const storage = useCacheStorage();
+  if (!storage) return false;
+  const cleanKey = key.replace(/^\/+/, "");
+  try {
+    const raw = await storage.getItem(cleanKey);
+    if (raw !== null && typeof raw === "object" && "value" in raw && "expiresAt" in raw) {
+      return Date.now() < raw.expiresAt;
+    }
+    return await storage.hasItem(cleanKey);
+  } catch {
+    return false;
+  }
+}

package/dist/runtime/server/utils/cms-events.d.ts

@@ -0,0 +1,17 @@
+import type { CMSEntry } from "../../../types";
+import type { getCMSConfig } from "./cms";
+type CMSConfig = ReturnType<typeof getCMSConfig>;
+type CMSWebhookEvent = "create" | "update" | "delete" | "publish" | "unpublish";
+/**
+ * Fires all configured webhooks for a CMS event (non-blocking). Merges global webhooks with
+ * per-collection webhooks. Each webhook filtered by its `events` list (default: ["publish",
+ * "unpublish"]). Signs payload with HMAC-SHA256 if `secret` is configured.
+ */
+export declare function fireCMSWebhooks(config: CMSConfig, collectionId: string, event: CMSWebhookEvent, entry: CMSEntry | Record<string, any>): Promise<void>;
+/**
+ * Fires a deploy hook or GitHub Actions workflow dispatch (non-blocking). Only fires when trigger
+ * === "on-publish" (default) and event is "publish" or "unpublish". Merges global deploy config
+ * with per-collection deploy config (collection config wins).
+ */
+export declare function fireCMSDeployTrigger(config: CMSConfig, collectionId: string, event: "publish" | "unpublish"): Promise<void>;
+export {};

package/dist/runtime/server/utils/cms-events.mjs

@@ -0,0 +1,80 @@
+export async function fireCMSWebhooks(config, collectionId, event, entry) {
+  const globalWebhooks = config.webhooks || [];
+  const colConfig = config.collections?.[collectionId] || {};
+  const colWebhooks = colConfig.webhooks || [];
+  const allWebhooks = [...globalWebhooks, ...colWebhooks];
+  if (allWebhooks.length === 0) return;
+  const payload = {
+    event,
+    collection: collectionId,
+    entry: {
+      id: entry.id,
+      slug: entry.slug,
+      title: entry.title,
+      status: entry.status,
+      updatedAt: entry.updatedAt ?? entry.updated_at
+    },
+    timestamp: Date.now()
+  };
+  const bodyStr = JSON.stringify(payload);
+  for (const hook of allWebhooks) {
+    const hookEvents = hook.events ?? ["publish", "unpublish"];
+    if (!hookEvents.includes(event)) continue;
+    const headers = {
+      "Content-Type": "application/json",
+      ...hook.headers || {}
+    };
+    if (hook.secret) {
+      try {
+        const key = await crypto.subtle.importKey(
+          "raw",
+          new TextEncoder().encode(hook.secret),
+          { name: "HMAC", hash: "SHA-256" },
+          false,
+          ["sign"]
+        );
+        const sig = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(bodyStr));
+        headers["X-Qarpeo-Signature"] = "sha256=" + Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+      } catch (e) {
+        console.warn("[qarpeo] webhook signature error:", e);
+      }
+    }
+    fetch(hook.url, { method: "POST", headers, body: bodyStr }).catch((e) => {
+      console.warn(`[qarpeo] webhook POST to ${hook.url} failed:`, e);
+    });
+  }
+}
+export async function fireCMSDeployTrigger(config, collectionId, event) {
+  const colConfig = config.collections?.[collectionId] || {};
+  const deploy = colConfig.deploy || config.deploy;
+  if (!deploy) return;
+  const trigger = deploy.trigger ?? "on-publish";
+  if (trigger !== "on-publish") return;
+  if (deploy.hookUrl) {
+    fetch(deploy.hookUrl, { method: "POST" }).catch((e) => {
+      console.warn("[qarpeo] deploy hook POST failed:", e);
+    });
+  }
+  if (deploy.github?.workflow) {
+    const gh = deploy.github;
+    const token = gh.token || process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    if (!token) {
+      console.warn("[qarpeo] deploy trigger: no GitHub token for workflow dispatch");
+      return;
+    }
+    const ref = gh.ref || "main";
+    const apiUrl = `https://api.github.com/repos/${gh.repo}/actions/workflows/${gh.workflow}/dispatches`;
+    fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `token ${token}`,
+        Accept: "application/vnd.github.v3+json",
+        "Content-Type": "application/json",
+        "User-Agent": "qarpeo-cms"
+      },
+      body: JSON.stringify({ ref })
+    }).catch((e) => {
+      console.warn("[qarpeo] GitHub workflow dispatch failed:", e);
+    });
+  }
+}

package/dist/runtime/server/utils/cms-filter.d.ts

@@ -0,0 +1,3 @@
+/** Checks if a relative file path matches the include / exclude glob filters. */
+export declare function matchesSourceFilters(relPath: string, include?: string | string[], exclude?: string | string[]): boolean;
+export declare const matchesGlobFilter: typeof matchesSourceFilters;

package/dist/runtime/server/utils/cms-filter.mjs

@@ -0,0 +1,34 @@
+export function matchesSourceFilters(relPath, include, exclude) {
+  const p = relPath.replace(/\\/g, "/");
+  if (exclude) {
+    const list = Array.isArray(exclude) ? exclude : [exclude];
+    for (const raw of list) {
+      if (!raw) continue;
+      try {
+        const pattern = raw.replace(/\\/g, "/").replace(/[.+^$\{\}\|\[\]\\]/g, (m) => "\\" + m).replace(/\*\*/g, ".*").replace(/(?<!\.)\*/g, "[^/]*").replace(/\?/g, "[^/]");
+        const exRegex = new RegExp(pattern);
+        if (exRegex.test(p)) return false;
+      } catch {
+      }
+    }
+  }
+  if (include) {
+    const list = Array.isArray(include) ? include : [include];
+    let matched = false;
+    for (const raw of list) {
+      if (!raw) continue;
+      try {
+        const pattern = raw.replace(/\\/g, "/").replace(/[.+^$\{\}\|\[\]\\]/g, (m) => "\\" + m).replace(/\*\*/g, ".*").replace(/(?<!\.)\*/g, "[^/]*").replace(/\?/g, "[^/]");
+        const incRegex = new RegExp(pattern);
+        if (incRegex.test(p)) {
+          matched = true;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!matched) return false;
+  }
+  return p.endsWith(".md");
+}
+export const matchesGlobFilter = matchesSourceFilters;

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

@@ -0,0 +1,278 @@
+import type { CMSComponentDefinition, CMSOptions, CMSEntry, CMSEntryStatus, CMSCollection, CMSCollectionConfig, CMSGitHubConfig, CMSDeployTriggerConfig, CMSApprovalConfig, CMSCreateInput, CMSUpdateInput, CMSQueryOptions, CMSFieldDefinition, CMSHeadingLink, CMSNavigationItem, CMSNavigationOptions, DocsSearchOptions, DocsSearchResponse } from "../../../types";
+/** Converts a heading text to a URL-safe slug ID. e.g. "Getting Started" → "getting-started" */
+export declare function slugifyHeading(text: string): string;
+/**
+ * Strips number-sort prefixes from path segments used for ordering. e.g. "1.docs" → "docs",
+ * "01.index" → "index", "2.getting-started" → "getting-started"
+ */
+export declare function stripOrderPrefix(segment: string): string;
+/**
+ * Checks whether a path segment is a route group enclosed in parentheses. e.g. "(overview)" → true,
+ * "1.(overview)" → true, "01.(setup)" → true, "guide" → false
+ */
+export declare function isGroupSegment(segment: string): boolean;
+/**
+ * Extracts a clean human-readable title from a group segment. e.g. "(overview)" → "Overview",
+ * "1.(quick-start)" → "Quick Start", "02.(faq)" → "FAQ"
+ */
+export declare function extractGroupTitle(segment: string): string;
+/**
+ * Extracts the numeric order prefix from a directory/file name. e.g. "1.docs" → 1,
+ * "01.getting-started" → 1, "docs" → undefined
+ */
+export declare function extractOrderPrefix(segment: string): number | undefined;
+/**
+ * Computes a clean URL path from a file path relative to contentDir. Strips numeric order prefixes
+ * and route groups like `(overview)`. e.g. "1.docs/1.getting-started/(overview)/01.index.md" →
+ * "/docs/getting-started" "1.docs/1.getting-started/(overview)/02.intro.md" →
+ * "/docs/getting-started/intro" "1.docs/2.installation.md" → "/docs/installation"
+ * "blog/hello-world.md" → "/blog/hello-world"
+ */
+export declare function computeEntryPath(filePathRelative: string, collectionId?: string): string;
+/**
+ * Tests whether an entry path matches one or more glob patterns. Supports:
+ *
+ * - Glob paths: `"/docs/**"`, `"/blog/*"`
+ * - Arrays: `["/docs/**", "/guides/**"]`
+ * - Negative excludes: `"!/docs/internal/**"`
+ */
+export declare function matchPathPatterns(entryPath: string, patterns?: string | string[]): boolean;
+/**
+ * Resolves which collection an entryPath belongs to, checking configured collections' `path`
+ * patterns first, then falling back to fallbackId.
+ */
+export declare function resolveCollectionForPath(entryPath: string, collectionsConfig?: Record<string, any>, fallbackId?: string): string;
+/**
+ * Extracts a table-of-contents array from raw markdown. Only processes ATX headings (## Foo, ###
+ * Bar — not h1).
+ */
+export declare function extractTOC(md: string): CMSHeadingLink[];
+/** Pre-processes MDC (Markdown Components) syntax to HTML before passing to micromark. */
+export declare function preprocessMDC(md: string): string;
+export declare function getCMSConfig(event?: any): Omit<Required<CMSOptions>, "github" | "deploy" | "approval" | "exclude" | "webhookSecret"> & {
+    collections: Record<string, CMSCollectionConfig>;
+    github?: CMSGitHubConfig;
+    deploy?: CMSDeployTriggerConfig;
+    approval?: boolean | CMSApprovalConfig;
+    exclude?: string | string[];
+    webhookSecret?: string;
+};
+/**
+ * Resolves the effective approval workflow configuration for a collection. Returns null if approval
+ * is disabled for the collection.
+ */
+export declare function resolveCollectionApproval(collectionConfig?: CMSCollectionConfig, globalApproval?: boolean | CMSApprovalConfig): CMSApprovalConfig | null;
+/** Parses markdown to Comark AST document ({ nodes, frontmatter, meta }). */
+export declare function parseMarkdownAST(md: string, event?: any): Promise<any>;
+/** Parses markdown and renders to both AST and HTML in a single pass. */
+export declare function processMarkdown(md: string, event?: any): Promise<{
+    ast: any;
+    html: string;
+}>;
+/** Renders markdown with Comark to HTML string. */
+export declare function renderMarkdown(md: string, event?: any): Promise<string>;
+/** Renders page markdown with Comark to HTML string. */
+export declare function renderPageMarkdown(md: string): Promise<string>;
+/**
+ * Parses a raw markdown file string with YAML frontmatter. Returns `{ data, content }` where `data`
+ * is the frontmatter key-value map and `content` is the body markdown text.
+ */
+export declare function parseFrontmatter(raw: string): {
+    data: Record<string, unknown>;
+    content: string;
+};
+/** Serialises entry data back to a markdown file with YAML frontmatter. */
+export declare function formatFrontmatter(data: Record<string, unknown>, body: string): string;
+/**
+ * Formats a CMSEntry into standard markdown with YAML frontmatter. Omits internal system fields
+ * starting with `_`.
+ */
+export declare function formatEntryAsMarkdown(entry: CMSEntry | Record<string, any>): string;
+export interface GitSyncResult {
+    filePath?: string;
+    contentHash?: string;
+    localFs?: boolean;
+    github?: {
+        ok: boolean;
+        commitSha?: string;
+        prUrl?: string;
+        error?: string;
+    };
+}
+/**
+ * Synchronizes a CMS entry modification back to Git / filesystem when mode is 'git-sync'.
+ *
+ * - In local dev (Node.js): Writes or deletes the markdown file on local disk and updates D1
+ *   content_hash.
+ * - In production (or when GitHub repo is configured): Commits directly or opens a PR via GitHub API.
+ */
+export declare function syncEntryToGit(event: any, collectionId: string, entry: CMSEntry | Record<string, any>, action: "create" | "update" | "delete" | "publish"): Promise<GitSyncResult | null>;
+/**
+ * Computes a hex SHA-256 digest of the given text using Web Crypto. Used for deterministic change
+ * detection in the hybrid sync engine.
+ */
+export declare function computeContentHash(text: string): Promise<string>;
+/** Resolves the active tenant ID for CMS scoping from the current event context. */
+export declare function getCMSTenantId(event: any): string | null;
+/** Returns the tenant key prefix (e.g. 'tenant_123:') for namespacing KV caches. */
+export declare function getCMSTenantPrefix(event: any): string;
+/** Returns a single collection by ID. Reads from KV (TTL 5 min) with D1 fallback. */
+export declare function getCMSCollection(event: any, collectionId: string): Promise<CMSCollection | null>;
+/** Lists all collections from D1. */
+export declare function listCMSCollections(event: any): Promise<CMSCollection[]>;
+/** Creates a new collection in D1 (from CMS Admin, source: 'db'). */
+export declare function createCMSCollection(event: any, data: {
+    id: string;
+    name: string;
+    description?: string;
+    fields?: Record<string, CMSFieldDefinition>;
+}): Promise<CMSCollection>;
+/** Updates a collection schema in D1. Invalidates KV cache. */
+export declare function updateCMSCollection(event: any, id: string, data: {
+    name?: string;
+    description?: string;
+    fields?: Record<string, CMSFieldDefinition>;
+}): Promise<void>;
+/** Deletes a collection from D1. Only source: 'db' collections can be deleted. Invalidates KV cache. */
+export declare function deleteCMSCollection(event: any, id: string): Promise<void>;
+/**
+ * Resolves the effective field definitions for a collection, merging config-seeded fields with any
+ * schema stored in D1 (DB-created collections take precedence for overlapping keys).
+ */
+export declare function getCollectionFields(event: any, collectionId: string): Promise<Record<string, CMSFieldDefinition>>;
+/**
+ * Returns a typed component definition from the CMS config by name, or null if not found.
+ * @public
+ */
+export declare function defineCMSComponent(def: CMSComponentDefinition): CMSComponentDefinition;
+/**
+ * Resolves a stored reference object into the full referenced {@link CMSEntry}. Used to populate
+ * references on read.
+ */
+export declare function resolveReference(event: any, ref: {
+    id?: string;
+    collectionId?: string;
+    slug?: string;
+}): Promise<CMSEntry | null>;
+export declare function invalidateCMSEntryCache(event: any, collectionId: string, slug?: string): Promise<void>;
+/**
+ * Verifies an incoming GitHub webhook HMAC-SHA256 signature (`X-Hub-Signature-256`)
+ * using Web Crypto subtle API in constant time.
+ */
+export declare function verifyGitHubSignature(rawBody: string, signatureHeader: string | null | undefined, secret: string): Promise<boolean>;
+/** Queries entries for a collection with filtering, pagination, and sorting. */
+export declare function queryCMSEntries(event: any, collectionId: string, opts?: CMSQueryOptions): Promise<{
+    entries: CMSEntry[];
+    total: number;
+    page: number;
+    limit: number;
+}>;
+/**
+ * Fetches a single entry by slug or ID. Supports draft preview via authenticated session or HMAC
+ * preview token.
+ */
+export declare function getCMSEntry(event: any, collectionId: string, slugOrId: string, opts?: {
+    preview?: boolean;
+    previewToken?: string;
+    previewExpires?: string;
+    populate?: boolean | string[];
+}): Promise<CMSEntry | null>;
+/** Creates a new entry in D1. Renders contentHtml from contentMd on write. */
+export declare function createCMSEntry(event: any, collectionId: string, data: CMSCreateInput): Promise<CMSEntry>;
+/**
+ * Updates an existing entry. Re-renders contentHtml if contentMd changed. Saves a revision and
+ * prunes beyond max.
+ */
+export declare function updateCMSEntry(event: any, entryId: string, data: CMSUpdateInput): Promise<CMSEntry>;
+/** Deletes an entry and all its revisions. */
+export declare function deleteCMSEntry(event: any, entryId: string): Promise<void>;
+/**
+ * Toggles entry status between `draft`, `pending_review`, `scheduled`, `published`, or `archived`.
+ * Validates approval policies if approval workflow is enabled for the collection.
+ */
+export declare function publishCMSEntry(event: any, entryId: string, targetStatus: CMSEntryStatus, targetPublishedAt?: number | null): Promise<void>;
+/**
+ * Scans for entries with status = 'scheduled' and published_at <= Date.now(). Transitions them to
+ * 'published' and triggers git-sync, webhooks, and deploy hooks. Returns the list of entries
+ * published.
+ */
+export declare function publishDueScheduledEntries(event?: any): Promise<CMSEntry[]>;
+/** Submits an entry for editorial review (transitions status from draft to pending_review). */
+export declare function submitCMSEntryForReview(event: any, entryId: string, note?: string): Promise<CMSEntry>;
+/** Rejects a pending review entry and reverts its status back to draft with reviewer feedback. */
+export declare function rejectCMSEntryReview(event: any, entryId: string, reason?: string): Promise<CMSEntry>;
+export declare function pruneRevisions(event: any, entryId: string, max: number): Promise<void>;
+/** Generates a 24-hour (or custom TTL) HMAC-SHA256 preview token for a draft entry. */
+export declare function generatePreviewToken(event: any, collection: string, slugOrId: string, ttlMs?: number): Promise<{
+    token: string;
+    expires: number;
+}>;
+/**
+ * Verifies an HMAC-SHA256 preview token.
+ * Tests against both `slugOrId` and alternate identifier (id vs slug) if available in D1.
+ */
+export declare function verifyPreviewToken(event: any, collection: string, slugOrId: string, token: string, expiresStr: string | number): Promise<boolean>;
+export declare function ensureCMSTables(event?: any): Promise<void>;
+export declare function ensureCMSSynced(event?: any): Promise<void>;
+/**
+ * Seeds config-defined collections into _qarpeo_cms_collections.
+ *
+ * - Source: 'config' rows are upserted when the config schema changes.
+ * - Source: 'db' rows (created from CMS Admin) are never touched.
+ */
+export declare function seedCollectionsFromConfig(event: any, collectionsConfig: Record<string, CMSCollectionConfig>): Promise<void>;
+/**
+ * Scans local markdown files in contentDir and seeds them into D1. Auto-discovers collection
+ * folders (e.g. content/posts/ -> 'posts' collection). For "page" type collections, recursively
+ * scans nested directories, reads .navigation.yml files for nav metadata, computes URL paths, and
+ * extracts TOC from headings. Uses SHA-256 content hashing to detect real changes (immune to
+ * timestamp drift). source: 'db' entries created by editors are never overwritten.
+ */
+import { matchesSourceFilters, matchesGlobFilter } from "./cms-filter";
+export { matchesSourceFilters, matchesGlobFilter };
+export declare function syncLocalContentFiles(event: any, contentDir: string, collectionsConfig?: Record<string, CMSCollectionConfig>, sources?: any[]): Promise<{
+    synced: number;
+    skipped: number;
+    inserted: number;
+}>;
+/**
+ * Fetches a single "page" collection entry by its computed URL path. e.g. path =
+ * "/docs/getting-started". Supports draft preview via editor session, HMAC preview token,
+ * or preview cookie.
+ */
+export declare function getCMSEntryByPath(event: any, collectionId: string, path: string, locale?: string, options?: {
+    preview?: boolean;
+    previewToken?: string;
+    previewExpires?: string | number;
+}): Promise<CMSEntry | null>;
+/**
+ * Returns [prev, next] entries surrounding the given path, sorted by `order` ASC. Fields can be
+ * restricted to a subset (e.g. ["description"]).
+ */
+export declare function getCMSEntrySurroundings(event: any, collectionId: string, path: string, fields?: string[]): Promise<[CMSEntry | null, CMSEntry | null]>;
+/**
+ * Builds a recursive navigation tree for a "page" collection from D1 entries. Uses the `path`,
+ * `order`, `navigation` metadata stored at sync time. Returns an array compatible with @nuxt/ui's
+ * <UContentNavigation>.
+ */
+export declare function getCMSNavigationTree(event: any, collectionId: string, options?: CMSNavigationOptions): Promise<CMSNavigationItem[]>;
+/**
+ * Sanitizes and formats an input search query for SQLite FTS5 MATCH expressions.
+ * Strips special operator characters that would otherwise trigger FTS5 syntax errors,
+ * cleans whitespace, and formats tokens with prefix matching ("token"*).
+ */
+export declare function buildFtsQuery(query: string, operator?: "AND" | "OR"): string;
+/**
+ * Rebuilds the FTS5 virtual table from current `_qarpeo_cms_entries` records.
+ * Can be used after schema migrations or to re-index all content.
+ */
+export declare function rebuildCMSFTS(event?: any): Promise<{
+    total: number;
+}>;
+/**
+ * High-performance edge search engine for documentation content.
+ * Queries the SQLite FTS5 full-text index with automatic fallback to LIKE search,
+ * splits markdown documents into heading-anchored sections, scores matches,
+ * and extracts highlighted context excerpts.
+ */
+export declare function searchDocs(event: any, options?: DocsSearchOptions): Promise<DocsSearchResponse>;