@consilioweb/spellcheck 0.10.1

package/dist/index.cjs

@@ -0,0 +1,1691 @@
+'use strict';
+
+// src/collections/SpellCheckResults.ts
+function createSpellCheckResultsCollection() {
+  return {
+    slug: "spellcheck-results",
+    admin: {
+      hidden: true
+    },
+    access: {
+      read: ({ req }) => !!req.user,
+      create: ({ req }) => !!req.user,
+      update: ({ req }) => !!req.user,
+      delete: ({ req }) => !!req.user
+    },
+    timestamps: false,
+    fields: [
+      {
+        name: "docId",
+        type: "text",
+        required: true,
+        index: true,
+        admin: {
+          description: "ID of the checked document"
+        }
+      },
+      {
+        name: "collection",
+        type: "text",
+        required: true,
+        index: true,
+        admin: {
+          description: "Collection slug (e.g. 'pages', 'posts')"
+        }
+      },
+      {
+        name: "title",
+        type: "text",
+        admin: {
+          description: "Document title (for dashboard display)"
+        }
+      },
+      {
+        name: "slug",
+        type: "text",
+        admin: {
+          description: "Document slug"
+        }
+      },
+      {
+        name: "score",
+        type: "number",
+        required: true,
+        min: 0,
+        max: 100,
+        admin: {
+          description: "Spellcheck score (0-100, 100 = no issues)"
+        }
+      },
+      {
+        name: "issueCount",
+        type: "number",
+        required: true,
+        min: 0,
+        admin: {
+          description: "Number of issues found"
+        }
+      },
+      {
+        name: "wordCount",
+        type: "number",
+        min: 0,
+        admin: {
+          description: "Word count of the extracted text"
+        }
+      },
+      {
+        name: "issues",
+        type: "json",
+        admin: {
+          description: "JSON array of SpellCheckIssue objects"
+        }
+      },
+      {
+        name: "ignoredIssues",
+        type: "json",
+        admin: {
+          description: "JSON array of { ruleId, original } \u2014 issues ignored by the user, filtered on rescan"
+        }
+      },
+      {
+        name: "lastChecked",
+        type: "date",
+        required: true,
+        index: true,
+        defaultValue: () => (/* @__PURE__ */ new Date()).toISOString(),
+        admin: {
+          description: "Date of the last spellcheck"
+        }
+      }
+    ]
+  };
+}
+
+// src/collections/SpellCheckDictionary.ts
+function createSpellCheckDictionaryCollection() {
+  return {
+    slug: "spellcheck-dictionary",
+    admin: {
+      hidden: true
+    },
+    access: {
+      read: ({ req }) => !!req.user,
+      create: ({ req }) => !!req.user,
+      update: ({ req }) => !!req.user,
+      delete: ({ req }) => !!req.user
+    },
+    hooks: {
+      beforeValidate: [
+        ({ data }) => {
+          if (data?.word && typeof data.word === "string") {
+            data.word = data.word.trim().toLowerCase();
+          }
+          return data;
+        }
+      ]
+    },
+    fields: [
+      {
+        name: "word",
+        type: "text",
+        required: true,
+        unique: true,
+        index: true,
+        admin: {
+          description: "Dictionary word (auto-lowercased)"
+        }
+      },
+      {
+        name: "addedBy",
+        type: "relationship",
+        relationTo: "users",
+        admin: {
+          description: "User who added this word"
+        }
+      }
+    ]
+  };
+}
+
+// src/engine/shared.ts
+var SKIP_TYPES = /* @__PURE__ */ new Set(["code", "code-block", "codeBlock"]);
+function isLexicalJson(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return Boolean(
+    obj.root && typeof obj.root === "object" || Array.isArray(obj.children) && obj.type !== void 0
+  );
+}
+var SKIP_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "_order",
+  "_parent_id",
+  "_path",
+  "_locale",
+  "_uuid",
+  "blockType",
+  "blockName",
+  "icon",
+  "color",
+  "link",
+  "link_url",
+  "enable_link",
+  "image",
+  "media",
+  "form",
+  "form_id",
+  "rating",
+  "size",
+  "position",
+  "relationTo",
+  "value",
+  "updatedAt",
+  "createdAt",
+  "_status",
+  "slug",
+  "meta",
+  "publishedAt",
+  "populatedAuthors"
+]);
+var PLAIN_TEXT_KEYS = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "heading",
+  "subheading",
+  "subtitle",
+  "quote",
+  "author",
+  "role",
+  "label",
+  "link_label",
+  "block_name",
+  "caption",
+  "alt",
+  "text",
+  "summary",
+  "excerpt"
+]);
+
+// src/engine/lexicalParser.ts
+function extractAllTextFromDocWithSources(doc, contentField = "content") {
+  const rawSegments = [];
+  const visited = /* @__PURE__ */ new WeakSet();
+  if (doc.title && typeof doc.title === "string") {
+    rawSegments.push({ text: doc.title, source: { type: "title" } });
+  }
+  if (doc.hero?.richText) {
+    rawSegments.push({
+      text: extractTextFromLexical(doc.hero.richText),
+      source: { type: "lexical", data: doc.hero.richText, topField: "hero" }
+    });
+  }
+  if (doc[contentField] && isLexicalJson(doc[contentField])) {
+    rawSegments.push({
+      text: extractTextFromLexical(doc[contentField]),
+      source: { type: "lexical", data: doc[contentField], topField: contentField }
+    });
+  }
+  if (Array.isArray(doc.layout)) {
+    for (const block of doc.layout) {
+      extractBlockSegments(block, rawSegments, visited, "layout");
+    }
+  }
+  const segments = rawSegments.filter((s) => Boolean(s.text));
+  const fullText = segments.map((s) => s.text).join("\n").trim();
+  return { fullText, segments };
+}
+function extractAllTextFromDoc(doc, contentField = "content") {
+  return extractAllTextFromDocWithSources(doc, contentField).fullText;
+}
+function extractBlockSegments(obj, segments, visited, topField, depth = 0) {
+  if (!obj || typeof obj !== "object" || depth > 10) return;
+  if (visited.has(obj)) return;
+  visited.add(obj);
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      extractBlockSegments(item, segments, visited, topField, depth + 1);
+    }
+    return;
+  }
+  const record = obj;
+  for (const [key, value] of Object.entries(record)) {
+    if (SKIP_KEYS.has(key)) continue;
+    if (isLexicalJson(value)) {
+      segments.push({
+        text: extractTextFromLexical(value),
+        source: { type: "lexical", data: value, topField }
+      });
+      continue;
+    }
+    if (typeof value === "string" && value.length > 2 && value.length < 5e3) {
+      if (/^(https?:|\/|#|\d{4}-\d{2}|[0-9a-f-]{36}|data:|mailto:)/i.test(value)) continue;
+      if (/^\{.*\}$/.test(value) || /^\[.*\]$/.test(value)) continue;
+      if (PLAIN_TEXT_KEYS.has(key)) {
+        segments.push({
+          text: value,
+          source: { type: "plain", parent: record, key, topField }
+        });
+      }
+    }
+    if (typeof value === "object" && value !== null) {
+      extractBlockSegments(value, segments, visited, topField, depth + 1);
+    }
+  }
+}
+function extractTextFromLexical(node, maxDepth = 50) {
+  return extractRecursive(node, 0, maxDepth).trim();
+}
+function extractRecursive(node, depth, maxDepth) {
+  if (!node || depth > maxDepth) return "";
+  if (Array.isArray(node)) {
+    let text2 = "";
+    for (const item of node) {
+      text2 += extractRecursive(item, depth + 1, maxDepth);
+    }
+    return text2;
+  }
+  if (typeof node !== "object") return "";
+  if (node.type && SKIP_TYPES.has(node.type)) return "";
+  let text = "";
+  if (node.type === "text" && typeof node.text === "string") {
+    text += node.text;
+  }
+  if (node.type === "paragraph" || node.type === "heading" || node.type === "listitem") {
+    for (const child of node.children || []) {
+      text += extractRecursive(child, depth + 1, maxDepth);
+    }
+    text += "\n";
+    return text;
+  }
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      text += extractRecursive(child, depth + 1, maxDepth);
+    }
+  }
+  if (node.root) {
+    text += extractRecursive(node.root, depth + 1, maxDepth);
+  }
+  return text;
+}
+function countWords(text) {
+  return text.split(/\s+/).filter((w) => w.length > 0).length;
+}
+
+// src/engine/languagetool.ts
+var LANGUAGETOOL_API = "https://api.languagetool.org/v2/check";
+var MAX_TEXT_LENGTH = 18e3;
+var REQUEST_TIMEOUT = 3e4;
+async function checkWithLanguageTool(text, language, config) {
+  if (!text.trim()) return [];
+  const truncatedText = text.length > MAX_TEXT_LENGTH ? text.slice(0, MAX_TEXT_LENGTH) : text;
+  const disabledRules = [
+    ...config.skipRules || [],
+    "WHITESPACE_RULE",
+    "COMMA_PARENTHESIS_WHITESPACE",
+    "UNPAIRED_BRACKETS"
+  ].join(",");
+  const params = new URLSearchParams({
+    text: truncatedText,
+    language,
+    disabledRules
+  });
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+  try {
+    const response = await fetch(LANGUAGETOOL_API, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: params.toString(),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`LanguageTool API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return parseMatches(data.matches || []);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error.name === "AbortError") {
+      console.error("[spellcheck] LanguageTool request timed out");
+      return [];
+    }
+    console.error("[spellcheck] LanguageTool error:", error);
+    return [];
+  }
+}
+function parseMatches(matches) {
+  return matches.map((m) => ({
+    ruleId: m.rule.id,
+    category: m.rule.category.id,
+    message: m.message,
+    context: m.context.text,
+    contextOffset: m.context.offset,
+    offset: m.offset,
+    length: m.length,
+    original: m.context.text.slice(m.context.offset, m.context.offset + m.context.length),
+    replacements: m.replacements.slice(0, 3).map((r) => r.value),
+    source: "languagetool",
+    isPremium: m.rule.isPremium ?? false
+  }));
+}
+
+// src/engine/claude.ts
+var ANTHROPIC_API = "https://api.anthropic.com/v1/messages";
+var REQUEST_TIMEOUT2 = 6e4;
+var MAX_TEXT_LENGTH2 = 8e3;
+async function checkWithClaude(text, language, apiKey) {
+  if (!text.trim() || !apiKey) return [];
+  const truncatedText = text.length > MAX_TEXT_LENGTH2 ? text.slice(0, MAX_TEXT_LENGTH2) : text;
+  const langLabel = language === "fr" ? "French" : "English";
+  const prompt = `Analyze this ${langLabel} web content for semantic issues ONLY (NOT spelling/grammar \u2014 a separate tool handles that). Check for:
+1. Inconsistent tone or register (formal vs informal mixing)
+2. Incoherent statements or contradictions
+3. Awkward phrasing that a spellchecker wouldn't catch
+4. Missing words that change meaning
+
+Return a JSON array of issues found. Each issue: { "message": "...", "context": "10-word excerpt around issue", "original": "problematic phrase", "suggestion": "improved version", "category": "COHERENCE|TONE|PHRASING|MISSING_WORD" }
+
+Return [] if no issues found. Be strict \u2014 only flag clear problems, not style preferences.
+
+Text:
+${truncatedText}`;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT2);
+  try {
+    const response = await fetch(ANTHROPIC_API, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 2048,
+        messages: [
+          { role: "user", content: prompt }
+        ]
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      console.error(`[spellcheck] Claude API error: ${response.status}`);
+      return [];
+    }
+    const data = await response.json();
+    const responseText = data.content?.[0]?.text || "[]";
+    const jsonMatch = responseText.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) return [];
+    const issues = JSON.parse(jsonMatch[0]);
+    return issues.map((issue) => ({
+      ruleId: `CLAUDE_${issue.category}`,
+      category: issue.category,
+      message: issue.message,
+      context: issue.context,
+      contextOffset: issue.context ? issue.context.indexOf(issue.original) : 0,
+      offset: 0,
+      length: issue.original.length,
+      original: issue.original,
+      replacements: issue.suggestion ? [issue.suggestion] : [],
+      source: "claude"
+    }));
+  } catch (error) {
+    clearTimeout(timeoutId);
+    console.error("[spellcheck] Claude error:", error);
+    return [];
+  }
+}
+
+// src/endpoints/dictionary.ts
+function createDictionaryListHandler() {
+  return async (req) => {
+    if (!req.user) {
+      return Response.json({ error: "Unauthorized" }, { status: 401 });
+    }
+    try {
+      const result = await req.payload.find({
+        collection: "spellcheck-dictionary",
+        limit: 0,
+        sort: "word",
+        overrideAccess: true
+      });
+      return Response.json({
+        words: result.docs,
+        count: result.totalDocs
+      });
+    } catch (error) {
+      console.error("[spellcheck/dictionary] List error:", error);
+      return Response.json({ error: "Internal server error" }, { status: 500 });
+    }
+  };
+}
+function createDictionaryAddHandler() {
+  return async (req) => {
+    if (!req.user) {
+      return Response.json({ error: "Unauthorized" }, { status: 401 });
+    }
+    try {
+      const body = await req.json().catch(() => ({}));
+      const { word, words } = body;
+      const wordsToAdd = [];
+      if (word) wordsToAdd.push(word);
+      if (Array.isArray(words)) wordsToAdd.push(...words);
+      if (wordsToAdd.length === 0) {
+        return Response.json({ error: "Provide { word } or { words: [] }" }, { status: 400 });
+      }
+      const added = [];
+      const skipped = [];
+      for (const w of wordsToAdd) {
+        const cleaned = w.trim().toLowerCase();
+        if (!cleaned) continue;
+        try {
+          const existing = await req.payload.find({
+            collection: "spellcheck-dictionary",
+            where: { word: { equals: cleaned } },
+            limit: 1,
+            overrideAccess: true
+          });
+          if (existing.docs.length > 0) {
+            skipped.push(cleaned);
+            continue;
+          }
+          await req.payload.create({
+            collection: "spellcheck-dictionary",
+            data: {
+              word: cleaned,
+              addedBy: typeof req.user.id !== "undefined" ? req.user.id : void 0
+            },
+            overrideAccess: true
+          });
+          added.push(cleaned);
+        } catch (err) {
+          skipped.push(cleaned);
+        }
+      }
+      invalidateDictionaryCache();
+      return Response.json({ added, skipped, count: added.length });
+    } catch (error) {
+      console.error("[spellcheck/dictionary] Add error:", error);
+      return Response.json({ error: "Internal server error" }, { status: 500 });
+    }
+  };
+}
+function createDictionaryDeleteHandler() {
+  return async (req) => {
+    if (!req.user) {
+      return Response.json({ error: "Unauthorized" }, { status: 401 });
+    }
+    try {
+      const body = await req.json().catch(() => ({}));
+      const { id: bodyId, ids } = body;
+      const url = new URL(req.url || "", "http://localhost");
+      const queryId = url.searchParams.get("id");
+      const idsToDelete = [];
+      if (bodyId) idsToDelete.push(bodyId);
+      if (queryId) idsToDelete.push(queryId);
+      if (Array.isArray(ids)) idsToDelete.push(...ids);
+      if (idsToDelete.length === 0) {
+        return Response.json({ error: "Provide { id } or { ids: [] }" }, { status: 400 });
+      }
+      let deleted = 0;
+      for (const deleteId of idsToDelete) {
+        try {
+          await req.payload.delete({
+            collection: "spellcheck-dictionary",
+            id: deleteId,
+            overrideAccess: true
+          });
+          deleted++;
+        } catch {
+        }
+      }
+      invalidateDictionaryCache();
+      return Response.json({ deleted });
+    } catch (error) {
+      console.error("[spellcheck/dictionary] Delete error:", error);
+      return Response.json({ error: "Internal server error" }, { status: 500 });
+    }
+  };
+}
+var cachedWords = null;
+var cacheTimestamp = 0;
+var CACHE_TTL = 5 * 60 * 1e3;
+function invalidateDictionaryCache() {
+  cachedWords = null;
+  cacheTimestamp = 0;
+}
+async function loadDictionaryWords(payload) {
+  const now = Date.now();
+  if (cachedWords && now - cacheTimestamp < CACHE_TTL) {
+    return cachedWords;
+  }
+  try {
+    const result = await payload.find({
+      collection: "spellcheck-dictionary",
+      limit: 0,
+      overrideAccess: true
+    });
+    cachedWords = result.docs.map((doc) => doc.word.toLowerCase());
+    cacheTimestamp = now;
+    return cachedWords;
+  } catch {
+    return [];
+  }
+}
+
+// src/engine/filters.ts
+var DEFAULT_SKIP_RULES = /* @__PURE__ */ new Set([
+  "WHITESPACE_RULE",
+  "COMMA_PARENTHESIS_WHITESPACE",
+  "UNPAIRED_BRACKETS",
+  "UPPERCASE_SENTENCE_START",
+  // Headings/titles don't start with uppercase
+  "FRENCH_WHITESPACE",
+  // Non-breaking spaces are inconsistent in CMS
+  "MORFOLOGIK_RULE_FR_FR",
+  // Overly aggressive French spelling (flags proper nouns)
+  "APOS_TYP",
+  // Typography apostrophe (curly vs straight)
+  "APOS_INCORRECT",
+  // Backtick/apostrophe in code contexts
+  "POINT_VIRGULE",
+  // Semicolon spacing
+  "DASH_RULE",
+  // Dash types (em vs en)
+  "FRENCH_WORD_REPEAT_RULE",
+  // Repetitions from heading+body extraction
+  "MOT_TRAIT_MOT",
+  // Hyphenated English tech terms (mobile-first, utility-first)
+  "PAS_DE_TRAIT_UNION",
+  // Prefix hyphenation (multi-appareils)
+  "D_N",
+  // Determiner gender mismatch on English terms (un pull, du June)
+  "DOUBLES_ESPACES",
+  // Double spaces — auto-fixable but noisy in CMS content
+  "ESPACE_ENTRE_VIRGULE_ET_MOT",
+  // Grammalecte: space after comma (often CMS extraction artifacts)
+  "ESPACE_ENTRE_POINT_ET_MOT",
+  // Grammalecte: space after period (extraction artifacts)
+  "PRONOMS_PERSONNELS_MINUSCULE",
+  // False positive from paragraph boundary extraction (heading + body)
+  "DET_MAJ_SENT_START",
+  // Same issue: paragraph boundary makes it look like missing capital
+  "FR_SPLIT_WORDS_HYPHEN"
+  // Suggests splitting hyphenated words (éco-responsable → éco responsable)
+]);
+var DEFAULT_SKIP_CATEGORIES = /* @__PURE__ */ new Set([
+  // English categories
+  "TYPOGRAPHY",
+  "TYPOS",
+  "STYLE",
+  // French categories (LanguageTool uses different IDs for French)
+  "CAT_TYPOGRAPHIE",
+  // French typography rules
+  "REPETITIONS_STYLE",
+  // French style/repetition suggestions
+  "CAT_REGLES_DE_BASEE"
+  // French basic rules (word repetition from CMS extraction)
+]);
+var SKIP_PATTERNS = [
+  /^https?:\/\//i,
+  // URLs
+  /^mailto:/i,
+  // Email links
+  /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+  // Emails
+  /^[A-Z][a-z]+[A-Z]/,
+  // CamelCase (JavaScript, TypeScript)
+  /^[A-Z]{2,}$/,
+  // All caps abbreviations (API, CSS, SEO)
+  /^\d+[\d.,]*$/,
+  // Numbers
+  /^\d+[a-zA-Z]+$/,
+  // Numbers with units (80px, 24h, mp3)
+  /^[#@]/,
+  // Hashtags, mentions
+  /^[€$£¥]/,
+  // Currency amounts
+  /^0[1-9]\d{8}$/,
+  // French phone numbers
+  /^\+?\d[\d\s.-]{8,}$/,
+  // International phone numbers
+  /^[a-z-]+\.[a-z]{2,}$/i,
+  // Domain names
+  /^`.*`$/,
+  // Inline code (backticks)
+  /^[a-z]+_[a-z]+/i,
+  // snake_case identifiers
+  /^--[a-z]/
+  // CSS custom properties (--color-primary)
+];
+var CODE_CONTEXT_PATTERNS = [
+  /`[^`]*$/,
+  // Inside backtick code span (opening but no close before issue)
+  /\b(npm|pnpm|yarn|git|docker|curl|wget)\b/i
+  // CLI commands
+];
+async function filterFalsePositives(issues, config, payload) {
+  const skipRules = /* @__PURE__ */ new Set([
+    ...DEFAULT_SKIP_RULES,
+    ...config.skipRules || []
+  ]);
+  const skipCategories = /* @__PURE__ */ new Set([
+    ...DEFAULT_SKIP_CATEGORIES,
+    ...config.skipCategories || []
+  ]);
+  const configWords = (config.customDictionary || []).map((w) => w.toLowerCase());
+  const dbWords = payload ? await loadDictionaryWords(payload) : [];
+  const dictionaryWords = [.../* @__PURE__ */ new Set([...configWords, ...dbWords])];
+  const dictionary = new Set(dictionaryWords);
+  return issues.filter((issue) => {
+    if (issue.isPremium) return false;
+    if (skipRules.has(issue.ruleId)) return false;
+    if (skipCategories.has(issue.category)) return false;
+    if (issue.original && dictionary.has(issue.original.toLowerCase())) return false;
+    if (issue.original) {
+      const lower = issue.original.toLowerCase();
+      for (const word of dictionaryWords) {
+        if (lower.includes(word) || word.includes(lower)) return false;
+      }
+    }
+    if (issue.context) {
+      const ctxLower = issue.context.toLowerCase();
+      for (const word of dictionaryWords) {
+        if (word.includes(" ") && ctxLower.includes(word)) {
+          return false;
+        }
+      }
+    }
+    if (issue.original && issue.original.length <= 1 && issue.category !== "GRAMMAR") return false;
+    if (issue.original) {
+      for (const pattern of SKIP_PATTERNS) {
+        if (pattern.test(issue.original)) return false;
+      }
+    }
+    if (issue.context) {
+      for (const pattern of CODE_CONTEXT_PATTERNS) {
+        if (pattern.test(issue.context)) return false;
+      }
+      if (issue.original && issue.context.includes("`" + issue.original + "`")) return false;
+    }
+    if (issue.replacements.length > 0 && issue.replacements[0] === issue.original) return false;
+    if (issue.context && issue.context.trim().length < 5) return false;
+    if (issue.ruleId.includes("REPET") || issue.category === "CAT_REGLES_DE_BASE") {
+      if (issue.original) {
+        const lower = issue.original.toLowerCase();
+        for (const word of dictionaryWords) {
+          if (lower.includes(word) || word.includes(lower)) return false;
+        }
+      }
+      if (issue.replacements.length > 0 && issue.replacements[0] === issue.original) return false;
+      if (issue.replacements.length > 0 && issue.replacements[0] === "") return false;
+    }
+    return true;
+  });
+}
+function calculateScore(wordCount, issueCount) {
+  if (wordCount === 0) return 100;
+  if (issueCount === 0) return 100;
+  const issuesPerHundredWords = issueCount / wordCount * 100;
+  const score = Math.max(0, Math.round(100 - issuesPerHundredWords * 10));
+  return Math.min(100, score);
+}
+
+// src/endpoints/validate.ts
+function createValidateHandler(pluginConfig) {
+  return async (req) => {
+    try {
+      if (!req.user) {
+        return Response.json({ error: "Unauthorized" }, { status: 401 });
+      }
+      const body = await req.json().catch(() => ({}));
+      const {
+        id,
+        collection,
+        text: rawText,
+        language: bodyLanguage
+      } = body;
+      const language = bodyLanguage || pluginConfig.language || "fr";
+      const contentField = pluginConfig.contentField || "content";
+      let textToCheck;
+      let fetchedDoc = null;
+      if (rawText) {
+        textToCheck = rawText;
+      } else if (id && collection) {
+        const findResult = await req.payload.find({
+          collection,
+          where: { id: { equals: id } },
+          limit: 1,
+          depth: 0,
+          draft: true,
+          overrideAccess: true
+        });
+        if (!findResult.docs.length) {
+          return Response.json({ error: "Document not found" }, { status: 404 });
+        }
+        fetchedDoc = findResult.docs[0];
+        textToCheck = extractAllTextFromDoc(fetchedDoc, contentField);
+      } else {
+        return Response.json(
+          { error: "Provide { id, collection } or { text }" },
+          { status: 400 }
+        );
+      }
+      const wordCount = countWords(textToCheck);
+      let issues = await checkWithLanguageTool(textToCheck, language, pluginConfig);
+      if (pluginConfig.enableAiFallback && pluginConfig.anthropicApiKey) {
+        const claudeIssues = await checkWithClaude(textToCheck, language, pluginConfig.anthropicApiKey);
+        issues = [...issues, ...claudeIssues];
+      }
+      issues = await filterFalsePositives(issues, pluginConfig, req.payload);
+      let ignoredIssues = [];
+      let existingDoc = null;
+      if (id && collection) {
+        try {
+          const existing = await req.payload.find({
+            collection: "spellcheck-results",
+            where: {
+              docId: { equals: String(id) },
+              collection: { equals: collection }
+            },
+            limit: 1,
+            overrideAccess: true
+          });
+          if (existing.docs.length > 0) {
+            existingDoc = existing.docs[0];
+            ignoredIssues = Array.isArray(existingDoc.ignoredIssues) ? existingDoc.ignoredIssues : [];
+          }
+        } catch {
+        }
+      }
+      if (ignoredIssues.length > 0) {
+        issues = issues.filter(
+          (issue) => !ignoredIssues.some((ignored) => ignored.ruleId === issue.ruleId && ignored.original === issue.original)
+        );
+      }
+      const score = calculateScore(wordCount, issues.length);
+      if (id && collection) {
+        const docIdStr = String(id);
+        try {
+          const title = fetchedDoc?.title || "";
+          const slug = fetchedDoc?.slug || "";
+          const resultData = {
+            docId: docIdStr,
+            collection,
+            title,
+            slug,
+            score,
+            issueCount: issues.length,
+            wordCount,
+            issues,
+            ignoredIssues,
+            lastChecked: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          if (existingDoc) {
+            await req.payload.update({
+              collection: "spellcheck-results",
+              id: existingDoc.id,
+              data: resultData,
+              overrideAccess: true
+            });
+          } else {
+            await req.payload.create({
+              collection: "spellcheck-results",
+              data: resultData,
+              overrideAccess: true
+            });
+          }
+        } catch (err) {
+          console.error("[spellcheck] Failed to store result:", err);
+        }
+      }
+      const result = {
+        docId: id ? String(id) : "",
+        collection: collection || "",
+        score,
+        issueCount: issues.length,
+        wordCount,
+        issues,
+        lastChecked: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return Response.json(result);
+    } catch (error) {
+      console.error("[spellcheck/validate] Error:", error);
+      return Response.json({ error: "Internal server error" }, { status: 500 });
+    }
+  };
+}
+
+// src/endpoints/fix.ts
+function fixInLexicalTree(node, targetOffset, targetLength, replacement, currentPos, depth = 0, maxDepth = 50) {
+  if (!node || depth > maxDepth) return { fixed: false, chars: 0 };
+  if (Array.isArray(node)) {
+    let chars2 = 0;
+    for (const item of node) {
+      const r = fixInLexicalTree(item, targetOffset, targetLength, replacement, currentPos + chars2, depth + 1, maxDepth);
+      chars2 += r.chars;
+      if (r.fixed) return { fixed: true, chars: chars2 };
+    }
+    return { fixed: false, chars: chars2 };
+  }
+  if (typeof node !== "object") return { fixed: false, chars: 0 };
+  if (node.type && SKIP_TYPES.has(node.type)) return { fixed: false, chars: 0 };
+  if (node.type === "text" && typeof node.text === "string") {
+    const nodeStart = currentPos;
+    const nodeEnd = currentPos + node.text.length;
+    if (targetOffset >= nodeStart && targetOffset < nodeEnd) {
+      const posInNode = targetOffset - nodeStart;
+      node.text = node.text.slice(0, posInNode) + replacement + node.text.slice(posInNode + targetLength);
+      return { fixed: true, chars: node.text.length };
+    }
+    return { fixed: false, chars: node.text.length };
+  }
+  if (node.type === "paragraph" || node.type === "heading" || node.type === "listitem") {
+    let chars2 = 0;
+    for (const child of node.children || []) {
+      const r = fixInLexicalTree(child, targetOffset, targetLength, replacement, currentPos + chars2, depth + 1, maxDepth);
+      chars2 += r.chars;
+      if (r.fixed) return { fixed: true, chars: chars2 + 1 };
+    }
+    chars2 += 1;
+    return { fixed: false, chars: chars2 };
+  }
+  let chars = 0;
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      const r = fixInLexicalTree(child, targetOffset, targetLength, replacement, currentPos + chars, depth + 1, maxDepth);
+      chars += r.chars;
+      if (r.fixed) return { fixed: true, chars };
+    }
+  }
+  if (node.root) {
+    const r = fixInLexicalTree(node.root, targetOffset, targetLength, replacement, currentPos + chars, depth + 1, maxDepth);
+    chars += r.chars;
+    if (r.fixed) return { fixed: true, chars };
+  }
+  return { fixed: false, chars };
+}
+function applyFixAtOffset(segments, fullText, targetOffset, targetLength, replacement, docClone) {
+  const rawJoined = segments.map((s) => s.text).join("\n");
+  const trimOffset = rawJoined.length - rawJoined.trimStart().length;
+  const rawTargetOffset = targetOffset + trimOffset;
+  let pos = 0;
+  for (const segment of segments) {
+    const segEnd = pos + segment.text.length;
+    if (rawTargetOffset >= pos && rawTargetOffset < segEnd) {
+      const localOffset = rawTargetOffset - pos;
+      return applyFixToSegment(segment, localOffset, targetLength, replacement, docClone);
+    }
+    pos = segEnd + 1;
+  }
+  return { fixed: false, modifiedField: null };
+}
+function applyFixToSegment(segment, localOffset, targetLength, replacement, docClone) {
+  const { source } = segment;
+  switch (source.type) {
+    case "title": {
+      const title = docClone.title;
+      docClone.title = title.slice(0, localOffset) + replacement + title.slice(localOffset + targetLength);
+      return { fixed: true, modifiedField: "title" };
+    }
+    case "lexical": {
+      const r = fixInLexicalTree(source.data, localOffset, targetLength, replacement, 0);
+      return r.fixed ? { fixed: true, modifiedField: source.topField } : { fixed: false, modifiedField: null };
+    }
+    case "plain": {
+      const currentVal = source.parent[source.key];
+      source.parent[source.key] = currentVal.slice(0, localOffset) + replacement + currentVal.slice(localOffset + targetLength);
+      return { fixed: true, modifiedField: source.topField };
+    }
+  }
+}
+function legacyFixSubstring(docClone, original, replacement, contentField) {
+  if (typeof docClone.title === "string" && docClone.title.includes(original)) {
+    docClone.title = docClone.title.replace(original, replacement);
+    return { fixed: true, modifiedField: "title" };
+  }
+  if (docClone.hero?.richText) {
+    const state = { done: false };
+    const fixed = legacyApplyToLexical(docClone.hero.richText, original, replacement, state);
+    if (fixed) return { fixed: true, modifiedField: "hero" };
+  }
+  if (docClone[contentField]) {
+    const state = { done: false };
+    const fixed = legacyApplyToLexical(docClone[contentField], original, replacement, state);
+    if (fixed) return { fixed: true, modifiedField: contentField };
+  }
+  if (Array.isArray(docClone.layout)) {
+    for (const block of docClone.layout) {
+      const state = { done: false };
+      const fixed = legacyApplyInObject(block, original, replacement, state);
+      if (fixed) return { fixed: true, modifiedField: "layout" };
+    }
+  }
+  return { fixed: false, modifiedField: null };
+}
+function legacyApplyToLexical(node, original, replacement, state) {
+  if (!node || state.done) return false;
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      if (state.done) break;
+      if (legacyApplyToLexical(item, original, replacement, state)) return true;
+    }
+    return false;
+  }
+  if (typeof node !== "object") return false;
+  if (node.type === "text" && typeof node.text === "string") {
+    if (!state.done && node.text.includes(original)) {
+      node.text = node.text.replace(original, replacement);
+      state.done = true;
+      return true;
+    }
+  }
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      if (state.done) break;
+      if (legacyApplyToLexical(child, original, replacement, state)) return true;
+    }
+  }
+  if (node.root && !state.done) {
+    if (legacyApplyToLexical(node.root, original, replacement, state)) return true;
+  }
+  return false;
+}
+function legacyApplyInObject(obj, original, replacement, state, depth = 0) {
+  if (!obj || typeof obj !== "object" || state.done || depth > 10) return false;
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      if (state.done) break;
+      if (legacyApplyInObject(item, original, replacement, state, depth + 1)) return true;
+    }
+    return false;
+  }
+  const record = obj;
+  for (const [key, value] of Object.entries(record)) {
+    if (state.done) break;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const v = value;
+      if (v.root && typeof v.root === "object") {
+        if (legacyApplyToLexical(value, original, replacement, state)) return true;
+        continue;
+      }
+    }
+    if (typeof value === "string" && value.includes(original)) {
+      if (PLAIN_TEXT_KEYS.has(key)) {
+        record[key] = value.replace(original, replacement);
+        state.done = true;
+        return true;
+      }
+    }
+    if (typeof value === "object" && value !== null) {
+      if (legacyApplyInObject(value, original, replacement, state, depth + 1)) return true;
+    }
+  }
+  return false;
+}
+function findClosestMatch(text, needle, expectedOffset) {
+  if (!needle) return -1;
+  const occurrences = [];
+  let idx = text.indexOf(needle);
+  while (idx !== -1) {
+    occurrences.push(idx);
+    idx = text.indexOf(needle, idx + 1);
+  }
+  if (occurrences.length === 0) return -1;
+  if (occurrences.length === 1) return occurrences[0];
+  return occurrences.reduce(
+    (closest, curr) => Math.abs(curr - expectedOffset) < Math.abs(closest - expectedOffset) ? curr : closest
+  );
+}
+function createFixHandler(pluginConfig) {
+  return async (req) => {
+    try {
+      if (!req.user) {
+        return Response.json({ error: "Unauthorized" }, { status: 401 });
+      }
+      const body = await req.json();
+      const { id, collection, original, replacement, offset, length, field } = body;
+      if (!id || !collection || !original || replacement === void 0) {
+        return Response.json(
+          { error: "Missing required fields: id, collection, original, replacement" },
+          { status: 400 }
+        );
+      }
+      const contentField = field || pluginConfig.contentField || "content";
+      const findResult = await req.payload.find({
+        collection,
+        where: { id: { equals: id } },
+        limit: 1,
+        depth: 0,
+        draft: true,
+        overrideAccess: true
+      });
+      if (!findResult.docs.length) {
+        return Response.json({ error: "Document not found" }, { status: 404 });
+      }
+      const doc = findResult.docs[0];
+      const { fullText, segments } = extractAllTextFromDocWithSources(doc, contentField);
+      let result;
+      let method = "legacy";
+      if (typeof offset === "number" && typeof length === "number") {
+        const actual = fullText.slice(offset, offset + length);
+        if (actual === original) {
+          result = applyFixAtOffset(segments, fullText, offset, length, replacement, doc);
+          method = "offset";
+        } else {
+          const foundOffset = findClosestMatch(fullText, original, offset);
+          if (foundOffset >= 0) {
+            console.log(
+              `[spellcheck/fix] Offset drift corrected: "${original}" at ${foundOffset} (stored: ${offset}, drift: ${foundOffset - offset})`
+            );
+            result = applyFixAtOffset(segments, fullText, foundOffset, original.length, replacement, doc);
+            method = "search";
+          } else {
+            console.warn(
+              `[spellcheck/fix] "${original}" not found in extracted text (${fullText.length} chars)`
+            );
+            result = { fixed: false, modifiedField: null };
+          }
+        }
+        if (!result.fixed) {
+          result = legacyFixSubstring(doc, original, replacement, contentField);
+          if (result.fixed) method = "legacy";
+        }
+      } else {
+        result = legacyFixSubstring(doc, original, replacement, contentField);
+      }
+      if (!result.fixed || !result.modifiedField) {
+        return Response.json({
+          success: false,
+          fixesApplied: 0,
+          error: "Could not locate the text to fix",
+          original,
+          replacement
+        });
+      }
+      const updateData = {};
+      switch (result.modifiedField) {
+        case "title":
+          updateData.title = doc.title;
+          break;
+        case "hero":
+          updateData.hero = doc.hero;
+          break;
+        case "layout":
+          updateData.layout = doc.layout;
+          break;
+        default:
+          updateData[result.modifiedField] = doc[result.modifiedField];
+          break;
+      }
+      await req.payload.update({
+        collection,
+        id,
+        data: updateData,
+        overrideAccess: true
+      });
+      return Response.json({
+        success: true,
+        fixesApplied: 1,
+        original,
+        replacement,
+        method
+      });
+    } catch (error) {
+      console.error("[spellcheck/fix] Error:", error);
+      return Response.json({ error: "Internal server error" }, { status: 500 });
+    }
+  };
+}
+
+// src/endpoints/bulk.ts
+var RATE_LIMIT_DELAY = 3e3;
+var STALE_TIMEOUT = 10 * 60 * 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var currentJob = null;
+function isJobStale() {
+  if (!currentJob || currentJob.status !== "running") return false;
+  return Date.now() - currentJob.lastActivity > STALE_TIMEOUT;
+}
+function resetIfStale() {
+  if (isJobStale() && currentJob) {
+    console.warn(`[spellcheck/bulk] Job stale (no progress for ${STALE_TIMEOUT / 1e3}s), auto-resetting`);
+    currentJob.status = "error";
+    currentJob.error = "Scan timed out (no progress)";
+    currentJob.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+}
+async function runBulkScan(payload, collectionsToScan, idsFilter, pluginConfig) {
+  const language = pluginConfig.language || "fr";
+  const contentField = pluginConfig.contentField || "content";
+  const results = [];
+  try {
+    let totalToScan = 0;
+    const docsByCollection = /* @__PURE__ */ new Map();
+    for (const collectionSlug of collectionsToScan) {
+      const idsForCollection = idsFilter ? idsFilter.filter((i) => i.collection === collectionSlug).map((i) => i.id) : null;
+      const allDocs = await payload.find({
+        collection: collectionSlug,
+        limit: 0,
+        depth: 0,
+        // depth:0 — must match fix.ts for offset alignment
+        draft: true,
+        // Read latest version (including unpublished edits)
+        overrideAccess: true,
+        where: {
+          ...idsForCollection ? { id: { in: idsForCollection } } : { _status: { equals: "published" } }
+        }
+      });
+      docsByCollection.set(collectionSlug, allDocs.docs);
+      totalToScan += allDocs.docs.length;
+    }
+    if (currentJob) {
+      currentJob.total = totalToScan;
+      currentJob.lastActivity = Date.now();
+    }
+    let processed = 0;
+    let totalIssues = 0;
+    let skipped = 0;
+    for (const collectionSlug of collectionsToScan) {
+      const docs = docsByCollection.get(collectionSlug) || [];
+      for (const doc of docs) {
+        processed++;
+        const docAny = doc;
+        const docTitle = docAny.title || docAny.slug || String(doc.id);
+        if (currentJob) {
+          currentJob.current = processed;
+          currentJob.currentDoc = docTitle;
+          currentJob.lastActivity = Date.now();
+        }
+        try {
+          const text = extractAllTextFromDoc(docAny, contentField);
+          if (!text.trim()) {
+            skipped++;
+            continue;
+          }
+          const wordCount = countWords(text);
+          let issues = await checkWithLanguageTool(text, language, pluginConfig);
+          issues = await filterFalsePositives(issues, pluginConfig, payload);
+          let existingDoc = null;
+          try {
+            const existing = await payload.find({
+              collection: "spellcheck-results",
+              where: {
+                docId: { equals: String(doc.id) },
+                collection: { equals: collectionSlug }
+              },
+              limit: 1,
+              overrideAccess: true
+            });
+            if (existing.docs.length > 0) {
+              existingDoc = existing.docs[0];
+            }
+          } catch {
+          }
+          const ignoredIssues = Array.isArray(existingDoc?.ignoredIssues) ? existingDoc.ignoredIssues : [];
+          if (ignoredIssues.length > 0) {
+            issues = issues.filter(
+              (issue) => !ignoredIssues.some((ignored) => ignored.ruleId === issue.ruleId && ignored.original === issue.original)
+            );
+          }
+          const score = calculateScore(wordCount, issues.length);
+          totalIssues += issues.length;
+          const result = {
+            docId: String(doc.id),
+            collection: collectionSlug,
+            score,
+            issueCount: issues.length,
+            wordCount,
+            issues,
+            lastChecked: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          results.push(result);
+          try {
+            const resultData = {
+              docId: String(doc.id),
+              collection: collectionSlug,
+              title: docAny.title || "",
+              slug: docAny.slug || "",
+              score,
+              issueCount: issues.length,
+              wordCount,
+              issues,
+              ignoredIssues,
+              lastChecked: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            if (existingDoc) {
+              await payload.update({
+                collection: "spellcheck-results",
+                id: existingDoc.id,
+                data: resultData,
+                overrideAccess: true
+              });
+            } else {
+              await payload.create({
+                collection: "spellcheck-results",
+                data: resultData,
+                overrideAccess: true
+              });
+            }
+          } catch (err) {
+            console.error(`[spellcheck/bulk] Failed to store result for ${docTitle}:`, err);
+          }
+        } catch (docErr) {
+          console.error(`[spellcheck/bulk] Error processing "${docTitle}":`, docErr);
+        }
+        if (currentJob) {
+          currentJob.totalIssues = totalIssues;
+          currentJob.totalDocuments = processed;
+          currentJob.lastActivity = Date.now();
+        }
+        await sleep(RATE_LIMIT_DELAY);
+      }
+    }
+    const averageScore = results.length > 0 ? Math.round(results.reduce((sum, r) => sum + r.score, 0) / results.length) : 100;
+    if (currentJob) {
+      currentJob.status = "completed";
+      currentJob.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      currentJob.averageScore = averageScore;
+      currentJob.totalDocuments = processed;
+      currentJob.totalIssues = totalIssues;
+      currentJob.lastActivity = Date.now();
+    }
+    console.log(`[spellcheck/bulk] Scan completed: ${processed} docs (${skipped} skipped), ${totalIssues} issues, avg score ${averageScore}`);
+  } catch (error) {
+    console.error("[spellcheck/bulk] Scan error:", error);
+    if (currentJob) {
+      currentJob.status = "error";
+      currentJob.error = error.message;
+      currentJob.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      currentJob.lastActivity = Date.now();
+    }
+  }
+}
+function createBulkHandler(targetCollections, pluginConfig) {
+  return async (req) => {
+    try {
+      if (!req.user) {
+        return Response.json({ error: "Unauthorized" }, { status: 401 });
+      }
+      resetIfStale();
+      const body = await req.json().catch(() => ({}));
+      const { collection: targetCollection, ids, force } = body;
+      if (currentJob?.status === "running") {
+        if (force) {
+          console.warn("[spellcheck/bulk] Force-resetting stuck scan");
+          currentJob.status = "error";
+          currentJob.error = "Force reset by user";
+          currentJob.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        } else {
+          return Response.json({
+            error: "Scan already in progress",
+            ...currentJob
+          }, { status: 409 });
+        }
+      }
+      const scanSpecificIds = Array.isArray(ids) && ids.length > 0;
+      const collectionsToScan = scanSpecificIds ? [...new Set(ids.map((i) => i.collection))] : targetCollection ? [targetCollection] : targetCollections;
+      const idsFilter = scanSpecificIds ? ids : null;
+      currentJob = {
+        status: "running",
+        current: 0,
+        total: 0,
+        currentDoc: "",
+        totalIssues: 0,
+        totalDocuments: 0,
+        averageScore: 0,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        completedAt: null,
+        error: null,
+        lastActivity: Date.now()
+      };
+      runBulkScan(req.payload, collectionsToScan, idsFilter, pluginConfig);
+      return Response.json({
+        message: "Scan started",
+        status: "running"
+      });
+    } catch (error) {
+      console.error("[spellcheck/bulk] Error:", error);
+      return Response.json({ error: "Internal server error" }, { status: 500 });
+    }
+  };
+}
+function createStatusHandler() {
+  return async (req) => {
+    if (!req.user) {
+      return Response.json({ error: "Unauthorized" }, { status: 401 });
+    }
+    resetIfStale();
+    if (!currentJob) {
+      return Response.json({ status: "idle" });
+    }
+    return Response.json({ ...currentJob });
+  };
+}
+
+// src/hooks/afterChangeCheck.ts
+function createAfterChangeCheckHook(pluginConfig) {
+  return ({ doc, collection, req }) => {
+    (async () => {
+      try {
+        const contentField = pluginConfig.contentField || "content";
+        const language = pluginConfig.language || "fr";
+        const text = extractAllTextFromDoc(doc, contentField);
+        if (!text) return;
+        const wordCount = countWords(text);
+        let issues = await checkWithLanguageTool(text, language, pluginConfig);
+        issues = await filterFalsePositives(issues, pluginConfig, req.payload);
+        const collectionSlug = typeof collection === "string" ? collection : collection.slug;
+        const existing = await req.payload.find({
+          collection: "spellcheck-results",
+          where: {
+            docId: { equals: String(doc.id) },
+            collection: { equals: collectionSlug }
+          },
+          limit: 1,
+          overrideAccess: true
+        });
+        const existingDoc = existing.docs.length > 0 ? existing.docs[0] : null;
+        const ignoredIssues = Array.isArray(existingDoc?.ignoredIssues) ? existingDoc.ignoredIssues : [];
+        if (ignoredIssues.length > 0) {
+          issues = issues.filter(
+            (issue) => !ignoredIssues.some((ignored) => ignored.ruleId === issue.ruleId && ignored.original === issue.original)
+          );
+        }
+        const score = calculateScore(wordCount, issues.length);
+        const docAny = doc;
+        const resultData = {
+          docId: String(doc.id),
+          collection: collectionSlug,
+          title: docAny.title || "",
+          slug: docAny.slug || "",
+          score,
+          issueCount: issues.length,
+          wordCount,
+          issues,
+          ignoredIssues,
+          lastChecked: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (existingDoc) {
+          await req.payload.update({
+            collection: "spellcheck-results",
+            id: existingDoc.id,
+            data: resultData,
+            overrideAccess: true
+          });
+        } else {
+          await req.payload.create({
+            collection: "spellcheck-results",
+            data: resultData,
+            overrideAccess: true
+          });
+        }
+        console.log(`[spellcheck] Auto-check: ${collectionSlug}/${doc.id} \u2014 score ${score}, ${issues.length} issues`);
+      } catch (err) {
+        console.error("[spellcheck] afterChange hook error:", err);
+      }
+    })();
+    return doc;
+  };
+}
+
+// src/plugin.ts
+async function autoFixSchema(payload) {
+  try {
+    await payload.find({ collection: "spellcheck-dictionary", limit: 1, overrideAccess: true });
+  } catch (e) {
+    const msg = String(e?.message || "");
+    if (!msg.includes("no such column") && !msg.includes("spellcheck_dictionary")) return;
+    payload.logger.info("[spellcheck] Detected missing schema column, attempting auto-fix...");
+    const alterSQL = "ALTER TABLE payload_locked_documents_rels ADD COLUMN spellcheck_dictionary_id integer";
+    const db = payload.db;
+    const rawClient = db.pool || db.client || db.drizzle?.session?.client;
+    if (!rawClient?.exec) {
+      payload.logger.warn(`[spellcheck] Auto-fix: could not access raw DB client. Run manually: ${alterSQL}`);
+      return;
+    }
+    try {
+      rawClient.exec(alterSQL);
+      payload.logger.info("[spellcheck] Auto-fixed: added spellcheck_dictionary_id to payload_locked_documents_rels");
+    } catch (fixErr) {
+      const fixMsg = String(fixErr?.message || "");
+      if (fixMsg.includes("duplicate column") || fixMsg.includes("already exists")) return;
+      payload.logger.warn(`[spellcheck] Auto-fix failed: ${fixMsg}. Run manually: ${alterSQL}`);
+    }
+  }
+}
+var spellcheckPlugin = (pluginConfig = {}) => (incomingConfig) => {
+  const config = { ...incomingConfig };
+  const targetCollections = pluginConfig.collections ?? ["pages", "posts"];
+  const basePath = pluginConfig.endpointBasePath ?? "/spellcheck";
+  const checkOnSave = pluginConfig.checkOnSave !== false;
+  const addSidebarField = pluginConfig.addSidebarField !== false;
+  const addDashboardView = pluginConfig.addDashboardView !== false;
+  if (config.collections) {
+    config.collections = config.collections.map((collection) => {
+      if (!targetCollections.includes(collection.slug)) return collection;
+      const updated = { ...collection };
+      if (checkOnSave) {
+        const existingHooks = updated.hooks?.afterChange || [];
+        updated.hooks = {
+          ...updated.hooks,
+          afterChange: [
+            ...Array.isArray(existingHooks) ? existingHooks : [existingHooks],
+            createAfterChangeCheckHook(pluginConfig)
+          ]
+        };
+      }
+      if (addSidebarField) {
+        updated.fields = [
+          ...updated.fields || [],
+          {
+            name: "_spellcheck",
+            type: "ui",
+            admin: {
+              position: "sidebar",
+              components: {
+                Field: "@consilioweb/spellcheck/client#SpellCheckField"
+              }
+            }
+          }
+        ];
+      }
+      if (pluginConfig.addListColumn !== false) {
+        updated.fields = [
+          ...updated.fields || [],
+          {
+            name: "_spellcheckScore",
+            type: "ui",
+            label: "Ortho",
+            admin: {
+              components: {
+                Cell: "@consilioweb/spellcheck/client#SpellCheckScoreCell"
+              }
+            }
+          }
+        ];
+        if (updated.admin?.defaultColumns) {
+          const cols = [...updated.admin.defaultColumns];
+          if (!cols.includes("_spellcheckScore")) {
+            cols.push("_spellcheckScore");
+          }
+          updated.admin = { ...updated.admin, defaultColumns: cols };
+        }
+      }
+      return updated;
+    });
+  }
+  config.collections = [
+    ...config.collections || [],
+    createSpellCheckResultsCollection(),
+    createSpellCheckDictionaryCollection()
+  ];
+  config.endpoints = [
+    ...config.endpoints || [],
+    {
+      path: `${basePath}/validate`,
+      method: "post",
+      handler: createValidateHandler(pluginConfig)
+    },
+    {
+      path: `${basePath}/fix`,
+      method: "post",
+      handler: createFixHandler(pluginConfig)
+    },
+    {
+      path: `${basePath}/bulk`,
+      method: "post",
+      handler: createBulkHandler(targetCollections, pluginConfig)
+    },
+    {
+      path: `${basePath}/status`,
+      method: "get",
+      handler: createStatusHandler()
+    },
+    {
+      path: `${basePath}/dictionary`,
+      method: "get",
+      handler: createDictionaryListHandler()
+    },
+    {
+      path: `${basePath}/dictionary`,
+      method: "post",
+      handler: createDictionaryAddHandler()
+    },
+    {
+      path: `${basePath}/dictionary`,
+      method: "delete",
+      handler: createDictionaryDeleteHandler()
+    },
+    {
+      path: `${basePath}/collections`,
+      method: "get",
+      handler: (async (req) => {
+        if (!req.user) return Response.json({ error: "Unauthorized" }, { status: 401 });
+        return Response.json({ collections: targetCollections });
+      })
+    }
+  ];
+  if (addDashboardView) {
+    if (!config.admin) config.admin = {};
+    if (!config.admin.components) config.admin.components = {};
+    if (!config.admin.components.views) config.admin.components.views = {};
+    config.admin.components.views.spellcheck = {
+      Component: "@consilioweb/spellcheck/views#SpellCheckView",
+      path: "/spellcheck"
+    };
+  }
+  const existingOnInit = config.onInit;
+  config.onInit = async (payload) => {
+    if (existingOnInit) await existingOnInit(payload);
+    await autoFixSchema(payload);
+  };
+  return config;
+};
+
+// src/i18n.ts
+var fr = {
+  dashboardTitle: "Correcteur orthographique",
+  dashboardDescription: "Analyse orthographique et grammaticale du contenu",
+  scanAll: "Scanner tout",
+  scanning: "Analyse en cours...",
+  scanComplete: "Analyse termin\xE9e",
+  noIssues: "Aucun probl\xE8me d\xE9tect\xE9",
+  issuesFound: (count) => `${count} probl\xE8me${count > 1 ? "s" : ""} d\xE9tect\xE9${count > 1 ? "s" : ""}`,
+  score: "Score",
+  wordCount: "Mots",
+  lastChecked: "Derni\xE8re v\xE9rification",
+  collection: "Collection",
+  document: "Document",
+  issues: "Probl\xE8mes",
+  actions: "Actions",
+  fieldTitle: "Orthographe",
+  fieldDescription: "V\xE9rification orthographique et grammaticale",
+  checkNow: "V\xE9rifier",
+  checking: "V\xE9rification...",
+  fixAll: "Tout corriger",
+  fix: "Corriger",
+  ignore: "Ignorer",
+  autoChecked: "V\xE9rifi\xE9 automatiquement",
+  suggestion: "Suggestion",
+  noSuggestion: "Aucune suggestion",
+  context: "Contexte",
+  rule: "R\xE8gle",
+  category: "Cat\xE9gorie",
+  applied: "Corrig\xE9",
+  source: "Source",
+  excellent: "Excellent",
+  good: "Bon",
+  needsWork: "\xC0 am\xE9liorer",
+  poor: "Insuffisant",
+  errorFetching: "Erreur lors de l'analyse",
+  errorFixing: "Erreur lors de la correction",
+  unauthorized: "Non autoris\xE9"
+};
+var en = {
+  dashboardTitle: "Spellchecker",
+  dashboardDescription: "Spelling and grammar analysis of content",
+  scanAll: "Scan all",
+  scanning: "Scanning...",
+  scanComplete: "Scan complete",
+  noIssues: "No issues found",
+  issuesFound: (count) => `${count} issue${count > 1 ? "s" : ""} found`,
+  score: "Score",
+  wordCount: "Words",
+  lastChecked: "Last checked",
+  collection: "Collection",
+  document: "Document",
+  issues: "Issues",
+  actions: "Actions",
+  fieldTitle: "Spelling",
+  fieldDescription: "Spelling and grammar check",
+  checkNow: "Check",
+  checking: "Checking...",
+  fixAll: "Fix all",
+  fix: "Fix",
+  ignore: "Ignore",
+  autoChecked: "Auto-checked",
+  suggestion: "Suggestion",
+  noSuggestion: "No suggestion",
+  context: "Context",
+  rule: "Rule",
+  category: "Category",
+  applied: "Fixed",
+  source: "Source",
+  excellent: "Excellent",
+  good: "Good",
+  needsWork: "Needs work",
+  poor: "Poor",
+  errorFetching: "Error during analysis",
+  errorFixing: "Error applying fix",
+  unauthorized: "Unauthorized"
+};
+var translations = { fr, en };
+function getTranslations(locale = "fr") {
+  return translations[locale] || translations.fr;
+}
+function getScoreLabel(score, t) {
+  if (score >= 95) return t.excellent;
+  if (score >= 80) return t.good;
+  if (score >= 50) return t.needsWork;
+  return t.poor;
+}
+
+exports.calculateScore = calculateScore;
+exports.checkWithClaude = checkWithClaude;
+exports.checkWithLanguageTool = checkWithLanguageTool;
+exports.countWords = countWords;
+exports.extractAllTextFromDoc = extractAllTextFromDoc;
+exports.extractAllTextFromDocWithSources = extractAllTextFromDocWithSources;
+exports.extractTextFromLexical = extractTextFromLexical;
+exports.filterFalsePositives = filterFalsePositives;
+exports.getScoreLabel = getScoreLabel;
+exports.getTranslations = getTranslations;
+exports.invalidateDictionaryCache = invalidateDictionaryCache;
+exports.loadDictionaryWords = loadDictionaryWords;
+exports.spellcheckPlugin = spellcheckPlugin;