@aeptus/aexeo-emdash 0.8.18 → 0.9.0

package/dist/configured.js

@@ -5,13 +5,15 @@ var __export = (target, all) => {
 };
 
 // src/adapter.ts
-async function adaptContentItemWithContext(content, contentApi, defaultLocale) {
+async function adaptContentItemWithContext(content, contentApi, defaultLocale, blockMappings, contentFields) {
   const publicUrl = content.status === "published" ? await contentApi.getPublicUrl(content.type, content.id) : null;
   const route = publicUrl === null ? deriveRoute(content) : routeFromPublicUrl(publicUrl);
   const adapted = adaptContentItem(content, {
     route,
     publicUrl,
-    ...defaultLocale === void 0 ? {} : { defaultLocale }
+    ...defaultLocale === void 0 ? {} : { defaultLocale },
+    ...blockMappings === void 0 ? {} : { blockMappings },
+    ...contentFields === void 0 ? {} : { contentFields }
   });
   const translationSet = await contentApi.getTranslations(
     content.type,
@@ -53,8 +55,11 @@ function adaptContentItem(content, options = {}) {
   if (typeof locale === "string" && locale.length > 0) {
     document.lang = locale;
   }
-  const body = extractPortableText(content.data);
-  if (body !== null) document.body = body;
+  const body = options.contentFields === void 0 ? extractPortableText(content.data, options.blockMappings) : extractSelectedContent(content.data, options.contentFields, options.blockMappings);
+  if (body !== null) {
+    document.body = body.blocks;
+    if (body.capabilities !== void 0) document.body_capabilities = body.capabilities;
+  }
   return {
     document,
     meta: {
@@ -63,7 +68,8 @@ function adaptContentItem(content, options = {}) {
       slug: content.slug,
       status: content.status,
       title,
-      publicUrl: options.publicUrl ?? null
+      publicUrl: options.publicUrl ?? null,
+      ...content.updatedAt === void 0 ? {} : { updatedAt: content.updatedAt }
     }
   };
 }
@@ -82,24 +88,53 @@ function routeFromPublicUrl(publicUrl) {
 function stringOrEmpty(value) {
   return typeof value === "string" ? value : "";
 }
-function extractPortableText(data) {
+function extractSelectedContent(data, fields, mappings) {
+  if (fields.length === 0 || new Set(fields).size !== fields.length || fields.some((field) => typeof field !== "string" || field.length === 0)) return null;
+  const all = ["text", "headings", "paragraphs", "links"];
+  let capabilities = all;
+  const blocks = [];
+  let observed = false;
+  for (const field of fields) {
+    const value = data[field];
+    if (value === void 0 || value === null) continue;
+    observed = true;
+    const part = extractFirstPortableText({ content: value }, mappings);
+    if (part === null) return { blocks, capabilities: [] };
+    blocks.push(...part.blocks);
+    capabilities = capabilities.filter((capability) => part.capabilities === void 0 || part.capabilities.includes(capability));
+  }
+  if (!observed) return null;
+  return capabilities.length === all.length ? { blocks } : { blocks, capabilities: [...capabilities] };
+}
+function extractPortableText(data, mappings) {
+  const result = extractFirstPortableText(data, mappings);
+  if (result === null) return null;
+  const candidates = Object.entries(data).filter(
+    ([field, value]) => isPortableTextArray(value) || isEmdashBlocksArray(value, field) || (field === "body" || field === "content") && typeof value === "string" && value.trim().length > 0
+  );
+  return candidates.length > 1 ? { blocks: result.blocks, capabilities: [] } : result;
+}
+function extractFirstPortableText(data, mappings) {
+  let foundEmptyBody = false;
   for (const slug of ["body", "content"]) {
     const value = data[slug];
-    if (isPortableTextArray(value)) return value;
-    if (isEmdashBlocksArray(value, slug)) return blocksToPortableText(value);
+    if (Array.isArray(value) && value.length === 0 || typeof value === "string" && value.trim().length === 0) foundEmptyBody = true;
+    if (isPortableTextArray(value)) return { blocks: value };
+    if (isEmdashBlocksArray(value, slug)) return mapCustomBlocks(value, mappings);
     if (typeof value === "string" && value.trim().length > 0) {
-      return [portableTextBlock(value.trim(), `${slug}-text`)];
+      return { blocks: [portableTextBlock(value.trim(), `${slug}-text`)], capabilities: ["text"] };
     }
   }
   const blocks = data["blocks"];
-  if (isPortableTextArray(blocks)) return blocks;
-  if (isEmdashBlocksArray(blocks, "blocks")) return blocksToPortableText(blocks);
+  if (Array.isArray(blocks) && blocks.length === 0) foundEmptyBody = true;
+  if (isPortableTextArray(blocks)) return { blocks };
+  if (isEmdashBlocksArray(blocks, "blocks")) return mapCustomBlocks(blocks, mappings);
   for (const [field, value] of Object.entries(data)) {
     if (field === "body" || field === "content" || field === "blocks") continue;
-    if (isPortableTextArray(value)) return value;
-    if (isEmdashBlocksArray(value, field)) return blocksToPortableText(value);
+    if (isPortableTextArray(value)) return { blocks: value };
+    if (isEmdashBlocksArray(value, field)) return mapCustomBlocks(value, mappings);
   }
-  return null;
+  return foundEmptyBody ? { blocks: [] } : null;
 }
 function isPortableTextArray(value) {
   return Array.isArray(value) && value.length > 0 && value.every(
@@ -114,6 +149,52 @@ function isEmdashBlocksArray(value, field) {
     (item) => isRecord(item) && typeof item["_type"] === "string" && typeof item["_key"] === "string" && (typeof item["_version"] === "number" || field === "blocks")
   );
 }
+function mapCustomBlocks(blocks, mappings) {
+  const unavailable = () => ({ blocks: blocksToPortableText(blocks), capabilities: [] });
+  const result = [];
+  const mapFields = (record, fields, depth) => {
+    if (depth > 8 || fields.length === 0) return false;
+    for (const entry of fields) {
+      if (!entry || typeof entry.field !== "string" || !entry.field || !["heading", "paragraph", "richText", "link", "repeat"].includes(entry.kind)) return false;
+      if (entry.kind === "heading" && entry.level !== void 0 && ![1, 2, 3, 4, 5, 6].includes(entry.level)) return false;
+      if (entry.kind === "link" && (typeof entry.hrefField !== "string" || !entry.hrefField)) return false;
+      if (entry.kind === "repeat" && (!Array.isArray(entry.fields) || entry.fields.length === 0)) return false;
+      const value = record[entry.field];
+      if ((value === void 0 || value === null || value === "") && entry.optional) {
+        if (entry.kind === "link" && record[entry.hrefField] != null && record[entry.hrefField] !== "") return false;
+        continue;
+      }
+      if (entry.kind === "richText") {
+        if (!Array.isArray(value) || value.length > 0 && !isPortableTextArray(value)) return false;
+        result.push(...value);
+      } else if (entry.kind === "heading" || entry.kind === "paragraph") {
+        if (typeof value !== "string") return false;
+        result.push({ ...portableTextBlock(value, ""), style: entry.kind === "heading" ? `h${entry.level ?? 2}` : "normal" });
+      } else if (entry.kind === "link") {
+        const href = record[entry.hrefField];
+        if (typeof value !== "string" || typeof href !== "string" || !href) return false;
+        result.push({
+          _type: "block",
+          children: [{ _type: "span", text: value, marks: ["link"] }],
+          markDefs: [{ _key: "link", _type: "link", href }]
+        });
+      } else if (entry.kind === "repeat") {
+        if (!Array.isArray(value) || !Array.isArray(entry.fields)) return false;
+        for (const item of value) {
+          if (!isRecord(item) || !mapFields(item, entry.fields, depth + 1)) return false;
+        }
+      } else {
+        return false;
+      }
+    }
+    return true;
+  };
+  for (const block of blocks) {
+    const fields = mappings?.[String(block["_type"])];
+    if (!Array.isArray(fields) || !mapFields(block, fields, 0)) return unavailable();
+  }
+  return { blocks: result };
+}
 function blocksToPortableText(blocks) {
   const paragraphs = [];
   for (const block of blocks) {
@@ -197,27 +278,107 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/version.ts
+var PACKAGE_VERSION = "0.9.0";
+
 // src/plugin.ts
-async function handleAfterSaveConfigured(event, ctx, evaluator, suppressionFilter) {
+var SETTINGS_TOKEN_KEY = "eval_token";
+var SETTINGS_BLOCK_MAPPINGS_KEY = "block_mappings";
+var SETTINGS_CONTENT_FIELDS_KEY = "content_fields_by_collection";
+var PLUGIN_SETTINGS_SCHEMA = {
+  [SETTINGS_CONTENT_FIELDS_KEY]: {
+    type: "string",
+    label: "Content fields by collection (JSON)",
+    description: "Ordered rendered body fields per collection.",
+    multiline: true
+  },
+  [SETTINGS_BLOCK_MAPPINGS_KEY]: {
+    type: "string",
+    label: "Custom block mappings (JSON)",
+    description: "Ordered mappings for the rendered fields of each custom block type.",
+    multiline: true
+  },
+  [SETTINGS_TOKEN_KEY]: {
+    type: "secret",
+    label: "EVAL_TOKEN",
+    description: "Bearer token for your aexeo-crawl-worker Worker. Encrypted at rest by the emdash host."
+  }
+};
+function recordContentCoverage(ctx, documents) {
+  const counts = { documents: documents.length, complete: 0, partial: 0, unavailable: 0 };
+  for (const document of documents) {
+    if (document.body === void 0 || document.body_capabilities?.length === 0) counts.unavailable++;
+    else if (document.body_capabilities === void 0 || ["text", "headings", "paragraphs", "links"].every(
+      (capability) => document.body_capabilities?.includes(capability)
+    )) counts.complete++;
+    else counts.partial++;
+  }
+  try {
+    ctx.log?.info?.("aexeo.content_coverage", counts);
+  } catch {
+  }
+}
+async function handleAfterDelete(event, ctx) {
+  for (const entry of await ctx.kv.list("document:")) {
+    const stored = toStoredDocument(entry.value);
+    if (stored !== null && stored.meta.id === event.id && stored.meta.collection === event.collection) {
+      await ctx.kv.delete(entry.key);
+      await ctx.kv.delete(findingsKey(stored.document.route));
+    }
+  }
+}
+var SITE_GRAPH_RULE_IDS = /* @__PURE__ */ new Set([
+  "LNK001",
+  // internal link target missing from the site
+  "LNK002",
+  // no inbound links
+  "LNK003",
+  // weak anchor, checked only when the target route exists
+  "LNK004",
+  // too few inbound links
+  "SEO009",
+  // hreflang alternate target missing from the site
+  "SEO012",
+  // hreflang alternate does not link back
+  "SEO016",
+  // canonical points at another crawlable route
+  "SEO017",
+  // title and description shared with another route
+  "CNT005"
+  // visible text duplicated on another route
+]);
+async function handleAfterSaveConfigured(event, ctx, evaluator, suppressionFilter, blockMappings, contentFields) {
   const adapted = await adaptContentItemWithContext(
     event.content,
     ctx.content,
-    ctx.site?.locale
+    ctx.site?.locale,
+    blockMappings,
+    contentFields
   );
   const document = adapted.document;
+  recordContentCoverage(ctx, [document]);
   const { kv, log } = ctx;
   const stored = { document, meta: adapted.meta };
-  await persistDocument(ctx, stored);
-  const result = await evaluator([document]);
+  if (!await persistDocument(ctx, stored)) {
+    log?.info?.(`Aexeo afterSave skipped: ${document.route} has a newer save`);
+    return;
+  }
+  const result = await evaluator([document], { collections: [adapted.meta.collection] });
   if (!result.ok) {
     log?.error?.(`afterSave evaluator failure (${result.reason})`, {
       detail: result.detail
     });
     return;
   }
-  const pageFindings = result.findings.filter(
-    (finding) => finding.scope === "page"
+  const storedGraphFindings = (await readFindings(kv, document.route)).filter(
+    (finding) => SITE_GRAPH_RULE_IDS.has(finding.rule_id)
   );
+  const pageFindings = [
+    ...result.findings.filter(
+      (finding) => finding.scope === "page" && !SITE_GRAPH_RULE_IDS.has(finding.rule_id)
+    ),
+    ...storedGraphFindings
+  ];
   const filtered = suppressionFilter === void 0 ? pageFindings : suppressionFilter.apply(
     {
       route: document.route,
@@ -226,6 +387,10 @@ async function handleAfterSaveConfigured(event, ctx, evaluator, suppressionFilte
     },
     pageFindings
   );
+  if (await isSuperseded(kv, document.route, adapted.meta.updatedAt)) {
+    log?.info?.(`Aexeo afterSave discarded: ${document.route} changed while evaluating`);
+    return;
+  }
   await kv.set(findingsKey(document.route), {
     route: document.route,
     findings: filtered
@@ -242,7 +407,9 @@ async function evaluateAndPersistAll(ctx, options) {
     totalFindings: 0,
     errors: []
   };
+  const storedAtStart = await readAllStoredDocuments(kv);
   const documents = [];
+  const documentCollections = [];
   const adaptedByRoute = /* @__PURE__ */ new Map();
   const documentRoutes = /* @__PURE__ */ new Set();
   for (const collection of collections) {
@@ -257,9 +424,12 @@ async function evaluateAndPersistAll(ctx, options) {
           const adapted = await adaptContentItemWithContext(
             item,
             ctx.content,
-            ctx.site?.locale
+            ctx.site?.locale,
+            options.blockMappings,
+            options.contentFieldsByCollection?.[collection]
           );
           documents.push(adapted.document);
+          documentCollections.push(adapted.meta.collection);
           documentRoutes.add(adapted.document.route);
           adaptedByRoute.set(adapted.document.route, {
             document: adapted.document,
@@ -275,10 +445,14 @@ async function evaluateAndPersistAll(ctx, options) {
     } while (cursor !== void 0);
   }
   summary.documentsScanned = documents.length;
+  recordContentCoverage(ctx, documents);
   for (const stored of adaptedByRoute.values()) {
-    await kv.set(documentKey(stored.document.route), stored);
+    const current = await readStoredDocument(kv, stored.document.route);
+    if (!isOlderRevision(stored.meta.updatedAt, current?.meta.updatedAt)) {
+      await kv.set(documentKey(stored.document.route), stored);
+    }
   }
-  const result = await options.evaluator(documents);
+  const result = await options.evaluator(documents, { collections: documentCollections });
   if (!result.ok) {
     log?.error?.(`aexeo evaluator failure (${result.reason})`, {
       detail: result.detail
@@ -299,6 +473,9 @@ async function evaluateAndPersistAll(ctx, options) {
   let totalAfterSuppression = 0;
   for (const [route, findings] of findingsByRoute) {
     const stored = adaptedByRoute.get(route);
+    if (stored !== void 0 && await isSuperseded(kv, route, stored.meta.updatedAt)) {
+      continue;
+    }
     const context = {
       route,
       ...stored?.meta.collection === void 0 ? {} : { collection: stored.meta.collection },
@@ -311,29 +488,52 @@ async function evaluateAndPersistAll(ctx, options) {
   }
   summary.totalFindings = totalAfterSuppression;
   if (summary.errors.length === 0) {
-    await removeStaleDocuments(ctx, collections, documentRoutes);
+    await removeStaleDocuments(ctx, collections, documentRoutes, storedAtStart);
   }
   return summary;
 }
+function isOlderRevision(revision, other) {
+  if (revision === void 0 || other === void 0) return false;
+  return Date.parse(revision) < Date.parse(other);
+}
+async function readStoredDocument(kv, route) {
+  return toStoredDocument(await kv.get(documentKey(route)));
+}
+async function isSuperseded(kv, route, revision) {
+  const current = await readStoredDocument(kv, route);
+  return current === null || isOlderRevision(revision, current.meta.updatedAt);
+}
 async function persistDocument(ctx, stored) {
   const route = stored.document.route;
-  const entries = await ctx.kv.list("document:");
-  for (const entry of entries) {
+  const sameEntry = (await ctx.kv.list("document:")).flatMap((entry) => {
     const previous = toStoredDocument(entry.value);
-    if (previous === null || previous.document.route === route || previous.meta.id !== stored.meta.id || previous.meta.collection !== stored.meta.collection) {
-      continue;
-    }
-    await ctx.kv.delete(entry.key);
+    return previous !== null && previous.meta.id === stored.meta.id && previous.meta.collection === stored.meta.collection ? [{ key: entry.key, previous }] : [];
+  });
+  if (sameEntry.some(
+    ({ previous }) => isOlderRevision(stored.meta.updatedAt, previous.meta.updatedAt)
+  )) {
+    return false;
+  }
+  for (const { key, previous } of sameEntry) {
+    if (previous.document.route === route) continue;
+    await ctx.kv.delete(key);
     await ctx.kv.delete(findingsKey(previous.document.route));
   }
   await ctx.kv.set(documentKey(route), stored);
+  return true;
 }
-async function removeStaleDocuments(ctx, collections, currentRoutes) {
+async function removeStaleDocuments(ctx, collections, currentRoutes, storedAtStart) {
   const scannedCollections = new Set(collections);
+  const revisionAtStart = new Map(
+    storedAtStart.map((stored) => [
+      stored.document.route,
+      stored.meta.updatedAt
+    ])
+  );
   const entries = await ctx.kv.list("document:");
   for (const entry of entries) {
     const stored = toStoredDocument(entry.value);
-    if (stored === null || !scannedCollections.has(stored.meta.collection) || currentRoutes.has(stored.document.route)) {
+    if (stored === null || stored.meta.collection !== "" && !scannedCollections.has(stored.meta.collection) || currentRoutes.has(stored.document.route) || !revisionAtStart.has(stored.document.route) || revisionAtStart.get(stored.document.route) !== stored.meta.updatedAt) {
       continue;
     }
     await ctx.kv.delete(entry.key);
@@ -394,6 +594,312 @@ async function readFindings(kv, route) {
   return stored.findings;
 }
 
+// src/findings-view.ts
+function normalizeInteraction(input) {
+  if (!input || typeof input !== "object") {
+    return { type: "page_load", page: "/findings" };
+  }
+  const raw = input;
+  if (raw.type === "page_load") {
+    return {
+      type: "page_load",
+      page: typeof raw.page === "string" && raw.page.length > 0 ? raw.page : "/findings"
+    };
+  }
+  if (raw.type === "block_action") {
+    return {
+      type: "block_action",
+      action_id: typeof raw.action_id === "string" ? raw.action_id : "",
+      ...typeof raw.block_id === "string" ? { block_id: raw.block_id } : {},
+      value: raw.value
+    };
+  }
+  if (raw.type === "form_submit") {
+    return {
+      type: "form_submit",
+      action_id: typeof raw.action_id === "string" ? raw.action_id : "",
+      ...typeof raw.block_id === "string" ? { block_id: raw.block_id } : {},
+      values: raw.values && typeof raw.values === "object" ? raw.values : {}
+    };
+  }
+  return { type: "page_load", page: "/findings" };
+}
+async function handleRefresh(options) {
+  let summary;
+  try {
+    summary = await evaluateAndPersistAll(options.ctx, {
+      collections: options.collections,
+      evaluator: options.evaluator,
+      blockMappings: options.blockMappings,
+      contentFieldsByCollection: options.contentFieldsByCollection,
+      // Always forwarded. See RefreshOptions.suppressionFilter.
+      suppressionFilter: options.suppressionFilter
+    });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    const message = `Refresh failed: ${detail}`;
+    return {
+      blocks: [
+        { type: "header", text: "SEO findings" },
+        {
+          type: "banner",
+          title: message,
+          variant: options.tuning.refreshFailureVariant
+        }
+      ],
+      toast: { message, type: "error" }
+    };
+  }
+  const refreshed = await renderFindingsPage(options.ctx.kv, options.tuning);
+  const toastMessage = summary.errors.length === 0 ? `Refreshed ${summary.routesUpdated} routes (${summary.totalFindings} findings across ${summary.documentsScanned} documents)` : `Refresh completed with ${summary.errors.length} errors \u2014 see banner`;
+  if (summary.errors.length > 0) {
+    refreshed.blocks.unshift({
+      type: "banner",
+      title: `Refresh issues: ${summary.errors.join(" \u2022 ")}`,
+      variant: "alert"
+    });
+  }
+  return {
+    ...refreshed,
+    toast: {
+      message: toastMessage,
+      type: summary.errors.length === 0 ? "success" : "info"
+    }
+  };
+}
+async function readAllFindings(kv) {
+  const entries = await kv.list(
+    "findings:"
+  );
+  const out = [];
+  for (const entry of entries) {
+    if (entry.value === null) {
+      continue;
+    }
+    const route = entry.key.replace(/^findings:/, "");
+    for (const finding of entry.value.findings) {
+      out.push({ ...finding, document_route: route });
+    }
+  }
+  return out;
+}
+function severityFirst(a, b) {
+  const rank = (severity) => severity === "error" ? 0 : 1;
+  const diff = rank(a.severity) - rank(b.severity);
+  if (diff !== 0) {
+    return diff;
+  }
+  return a.rule_id.localeCompare(b.rule_id);
+}
+function uniqueRoutes(rows) {
+  const routes = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    routes.add(row.document_route);
+  }
+  return [...routes].sort();
+}
+async function renderFindingsPage(kv, tuning) {
+  const findings = await readAllFindings(kv);
+  const errors = findings.filter((finding) => finding.severity === "error");
+  const warnings = findings.filter(
+    (finding) => finding.severity === "warning"
+  );
+  const sorted = [...findings].sort(severityFirst);
+  const routes = uniqueRoutes(findings);
+  const blocks = [
+    { type: "header", text: "SEO findings" },
+    {
+      type: "context",
+      text: findings.length === 0 ? "No findings yet \u2014 click Refresh to evaluate the site." : `${findings.length} findings across ${routes.length} routes \u2014 ${errors.length} errors, ${warnings.length} warnings.`
+    },
+    { type: "divider" },
+    {
+      type: "actions",
+      elements: [
+        // Refresh evaluates every configured entry. Pressing it lists
+        // content via the live in-request bridge, evaluates it, and
+        // writes findings back to KV (with suppressions applied).
+        {
+          type: "button",
+          label: "Refresh",
+          action_id: "refresh_findings",
+          style: "primary"
+        },
+        { type: "button", label: "All", action_id: "filter:all" },
+        { type: "button", label: "Errors only", action_id: "filter:errors" },
+        {
+          type: "button",
+          label: "Warnings only",
+          action_id: "filter:warnings"
+        }
+      ]
+    },
+    sorted.length === 0 ? {
+      type: "context",
+      text: tuning.emptyFindingsText
+    } : findingsTable(sorted)
+  ];
+  if (routes.length > 0) {
+    blocks.push({
+      type: "form",
+      fields: [
+        {
+          type: "select",
+          action_id: "route_picker",
+          label: "Document to inspect",
+          options: routes.map((route) => ({ label: route, value: route }))
+        }
+      ],
+      submit: { label: "View document SEO", action_id: "view_document" }
+    });
+  }
+  return { blocks };
+}
+function findingsTable(rows) {
+  return {
+    type: "table",
+    columns: [
+      { key: "route", label: "Route" },
+      { key: "rule", label: "Rule", format: "code" },
+      { key: "severity", label: "Severity", format: "badge" },
+      { key: "message", label: "Message" }
+    ],
+    rows: rows.map((row) => ({
+      route: row.document_route,
+      rule: row.rule_id,
+      severity: row.severity,
+      message: row.message
+    }))
+  };
+}
+async function renderScoreWidget(kv, tuning, log) {
+  const documents = await readAllDocuments(kv);
+  if (documents.length === 0) {
+    return {
+      blocks: [
+        { type: "header", text: "SEO score" },
+        {
+          type: "context",
+          text: tuning.emptyScoreText
+        }
+      ]
+    };
+  }
+  let score;
+  try {
+    score = await tuning.score(documents, kv);
+  } catch (error) {
+    log?.error("Aexeo score widget failed to initialize", { error });
+    return {
+      blocks: [
+        { type: "banner", title: "SEO score is temporarily unavailable", variant: "alert" },
+        { type: "context", text: "The authoring interface remains available. Retry after the evaluator runtime has been checked." }
+      ]
+    };
+  }
+  if (score === null) {
+    return {
+      blocks: [
+        { type: "header", text: "SEO score" },
+        {
+          type: "context",
+          text: "The site score is unavailable in sandboxed mode. Findings are not affected."
+        }
+      ]
+    };
+  }
+  const blocks = [
+    {
+      type: "stats",
+      items: [
+        {
+          label: "Citation",
+          value: score.citation_readiness_score?.toString() ?? "unknown"
+        },
+        {
+          label: tuning.truthLabel(score),
+          value: score.truth_consistency_score?.toString() ?? "unknown"
+        },
+        {
+          label: "Answers",
+          value: `${score.answer_pack.routes_with_answer_blocks}/${score.answer_pack.routes_analyzed} routes`
+        }
+      ]
+    }
+  ];
+  if (score.blockers.length > 0) {
+    blocks.push({
+      type: "context",
+      text: topBlockersLine(score)
+    });
+  }
+  return { blocks };
+}
+function topBlockersLine(score) {
+  const top = score.blockers.slice(0, 3).map((blocker) => blocker.message);
+  if (top.length === 0) {
+    return "No blockers identified.";
+  }
+  return `Top blockers: ${top.join(" \u2022 ")}`;
+}
+async function renderDocumentPanel(kv, route) {
+  if (route === void 0) {
+    return {
+      blocks: [
+        { type: "header", text: "Document SEO" },
+        {
+          type: "context",
+          text: "Pick a document from the SEO findings list to see its rule findings here."
+        }
+      ]
+    };
+  }
+  const findings = await readFindings(kv, route);
+  const errors = findings.filter((finding) => finding.severity === "error");
+  const warnings = findings.filter(
+    (finding) => finding.severity === "warning"
+  );
+  const sorted = [...findings].sort(severityFirst);
+  return {
+    blocks: [
+      { type: "header", text: `Document SEO \u2014 ${route}` },
+      {
+        type: "context",
+        text: findings.length === 0 ? `No findings for ${route} \u2014 the document is currently clean.` : `${findings.length} findings \u2014 ${errors.length} errors, ${warnings.length} warnings.`
+      },
+      ...findings.length === 0 ? [] : [{ type: "divider" }, documentFindingsTable(sorted)]
+    ]
+  };
+}
+function documentFindingsTable(findings) {
+  return {
+    type: "table",
+    columns: [
+      { key: "rule", label: "Rule", format: "code" },
+      { key: "severity", label: "Severity", format: "badge" },
+      { key: "message", label: "Message" },
+      { key: "block", label: "Block", format: "code" }
+    ],
+    rows: findings.map((finding) => ({
+      rule: finding.rule_id,
+      severity: finding.severity,
+      message: finding.message,
+      // The bridge stamps every Portable Text block with id + data-pt-key
+      // when rendering; surfacing the path:line locator here lets authors
+      // locate the failing block via the editor's ⌘-F.
+      block: `${finding.path}:${finding.line}`
+    }))
+  };
+}
+function notFound(page) {
+  return {
+    blocks: [
+      { type: "header", text: "Not found" },
+      { type: "context", text: `unknown page: ${page}` }
+    ]
+  };
+}
+
 // wasm/aexeo_emdash_bridge_bg.js
 var aexeo_emdash_bridge_bg_exports = {};
 __export(aexeo_emdash_bridge_bg_exports, {
@@ -403,11 +909,65 @@ __export(aexeo_emdash_bridge_bg_exports, {
   __wbg_set_wasm: () => __wbg_set_wasm,
   __wbg_stack_3b0d974bbf31e44f: () => __wbg_stack_3b0d974bbf31e44f,
   __wbindgen_init_externref_table: () => __wbindgen_init_externref_table,
+  evaluateContent: () => evaluateContent,
+  evaluateContentCollection: () => evaluateContentCollection,
   evaluateDocuments: () => evaluateDocuments,
   generateFactsPrompt: () => generateFactsPrompt,
   scoreIntelligence: () => scoreIntelligence,
   validateFactsManifest: () => validateFactsManifest
 });
+function evaluateContent(document_json, preset_name, sources_json, evidence_json) {
+  let deferred6_0;
+  let deferred6_1;
+  try {
+    const ptr0 = passStringToWasm0(document_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(preset_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(sources_json) ? 0 : passStringToWasm0(sources_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    var ptr3 = isLikeNone(evidence_json) ? 0 : passStringToWasm0(evidence_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len3 = WASM_VECTOR_LEN;
+    const ret = wasm.evaluateContent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    var ptr5 = ret[0];
+    var len5 = ret[1];
+    if (ret[3]) {
+      ptr5 = 0;
+      len5 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred6_0 = ptr5;
+    deferred6_1 = len5;
+    return getStringFromWasm0(ptr5, len5);
+  } finally {
+    wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+  }
+}
+function evaluateContentCollection(documents_json, preset_name, sources_json) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passStringToWasm0(documents_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(preset_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(sources_json) ? 0 : passStringToWasm0(sources_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    const ret = wasm.evaluateContentCollection(ptr0, len0, ptr1, len1, ptr2, len2);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
 function evaluateDocuments(documents_json, config_json) {
   let deferred4_0;
   let deferred4_1;
@@ -677,6 +1237,10 @@ async function validateFactsManifest2(manifestJson, documentsJson) {
   await ensureInitialized();
   return validateFactsManifest(manifestJson, documentsJson);
 }
+async function evaluateContent2(documentJson, presetName, sourcesJson, evidenceJson) {
+  await ensureInitialized();
+  return evaluateContent(documentJson, presetName, sourcesJson, evidenceJson);
+}
 
 // src/data-route.ts
 async function handleDataRoute(ctx, options) {
@@ -685,6 +1249,8 @@ async function handleDataRoute(ctx, options) {
     summary = await evaluateAndPersistAll(ctx, {
       collections: options.collections,
       evaluator: options.evaluator,
+      blockMappings: options.blockMappings,
+      contentFieldsByCollection: options.contentFieldsByCollection,
       ...options.suppressionFilter === void 0 ? {} : { suppressionFilter: options.suppressionFilter }
     });
     await persistManifestStateFindings(ctx);
@@ -953,12 +1519,16 @@ async function handleSave(ctx, body) {
   return { saved: true };
 }
 
-// src/presence-route.ts
-import { PluginRouteError as PluginRouteError2 } from "emdash";
-
 // src/presence-check.ts
 var FETCH_TIMEOUT_MS = 5e3;
 var USER_AGENT = "aexeo-emdash-plugin/0.8 (+https://github.com/schiste/Aexeo; entity-presence diagnostic)";
+var PRESENCE_HOSTS = [
+  "en.wikipedia.org",
+  "www.wikidata.org",
+  "api.github.com",
+  "rdap.org",
+  "index.commoncrawl.org"
+];
 var SOURCE_NAMES = [
   "wikipedia",
   "wikidata",
@@ -1012,11 +1582,11 @@ async function checkWikipedia(input, fetcher) {
     const descriptions = body[2];
     const urls = body[3];
     if (!Array.isArray(titles) || !Array.isArray(urls) || titles.length === 0) {
-      return notFound("wikipedia");
+      return notFound2("wikipedia");
     }
     const title = String(titles[0]);
-    if (!fuzzyMatch(title, input.name)) {
-      return notFound("wikipedia");
+    if (!namesEntity(title, input)) {
+      return notFound2("wikipedia");
     }
     const articleUrl = String(urls[0] ?? "");
     const description = Array.isArray(descriptions) ? String(descriptions[0] ?? "") : "";
@@ -1042,11 +1612,11 @@ async function checkWikidata(input, fetcher) {
     const body = await res.json();
     const top = body.search?.[0];
     if (!top || typeof top.id !== "string") {
-      return notFound("wikidata");
+      return notFound2("wikidata");
     }
     const label = top.label ?? input.name;
-    if (!fuzzyMatch(label, input.name)) {
-      return notFound("wikidata");
+    if (!namesEntity(label, input)) {
+      return notFound2("wikidata");
     }
     return found("wikidata", {
       label: `${top.id}${top.label ? ` \u2014 ${top.label}` : ""}`,
@@ -1072,7 +1642,7 @@ async function checkGitHub(input, fetcher) {
       // it the API can return either v3 or experimental shapes.
       headers: { Accept: "application/vnd.github+json" }
     });
-    if (res.status === 404) return notFound("github");
+    if (res.status === 404) return notFound2("github");
     if (res.status === 403 || res.status === 429) {
       return unreachable("github", "rate-limited (try Refresh later)");
     }
@@ -1104,7 +1674,7 @@ async function checkRdap(input, fetcher) {
   const url = `https://rdap.org/domain/${encodeURIComponent(host)}`;
   try {
     const res = await timedFetch(fetcher, url);
-    if (res.status === 404) return notFound("rdap");
+    if (res.status === 404) return notFound2("rdap");
     if (!res.ok) return unreachable("rdap", `HTTP ${res.status}`);
     const body = await res.json();
     const reg = (body.events ?? []).find(
@@ -1134,20 +1704,38 @@ async function checkCommonCrawl(input, fetcher) {
       "no website URL in manifest, can't query crawl index"
     );
   }
-  const index = "CC-MAIN-2026-15";
+  let index;
+  try {
+    const res = await timedFetch(
+      fetcher,
+      "https://index.commoncrawl.org/collinfo.json"
+    );
+    if (!res.ok) return unreachable("common_crawl", `HTTP ${res.status}`);
+    const newest = newestCrawlId(await res.json());
+    if (newest === null) {
+      return unreachable(
+        "common_crawl",
+        "no crawl index listed in collinfo.json"
+      );
+    }
+    index = newest;
+  } catch (error) {
+    return unreachable("common_crawl", errMsg(error));
+  }
   const url = new URL(`https://index.commoncrawl.org/${index}-index`);
   url.searchParams.set("url", host);
+  url.searchParams.set("matchType", "domain");
   url.searchParams.set("output", "json");
   url.searchParams.set("limit", "1");
   try {
     const res = await timedFetch(fetcher, url.toString());
-    if (res.status === 404) return notFound("common_crawl");
+    if (res.status === 404) return notFound2("common_crawl");
     if (!res.ok) return unreachable("common_crawl", `HTTP ${res.status}`);
     const text = (await res.text()).trim();
-    if (text.length === 0) return notFound("common_crawl");
+    if (text.length === 0) return notFound2("common_crawl");
     let firstLine = text.split("\n")[0];
     if (firstLine === void 0 || firstLine.length === 0) {
-      return notFound("common_crawl");
+      return notFound2("common_crawl");
     }
     let entry;
     try {
@@ -1163,6 +1751,16 @@ async function checkCommonCrawl(input, fetcher) {
     return unreachable("common_crawl", errMsg(error));
   }
 }
+function newestCrawlId(collinfo) {
+  if (!Array.isArray(collinfo)) return null;
+  let newest = null;
+  for (const crawl of collinfo) {
+    const id = crawl?.id;
+    if (typeof id !== "string" || !/^CC-MAIN-[A-Za-z0-9-]+$/.test(id)) continue;
+    if (newest === null || id > newest) newest = id;
+  }
+  return newest;
+}
 async function timedFetch(fetcher, url, init) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
@@ -1189,7 +1787,7 @@ function found(source, details) {
   if (details.extra !== void 0) result.extra = details.extra;
   return result;
 }
-function notFound(source) {
+function notFound2(source) {
   return { source, status: "not_found", checkedAt: nowIso() };
 }
 function unreachable(source, error) {
@@ -1208,10 +1806,45 @@ function errMsg(error) {
   }
   return String(error);
 }
-function fuzzyMatch(a, b) {
-  const aL = a.toLowerCase().trim();
-  const bL = b.toLowerCase().trim();
-  return aL.includes(bL) || bL.includes(aL);
+function namesEntity(candidate, input) {
+  const normalized = normalizeEntityName(candidate);
+  return [input.name, ...input.aliases ?? []].some(
+    (name) => normalizeEntityName(name) === normalized
+  );
+}
+var LEGAL_FORMS = /* @__PURE__ */ new Set([
+  "ab",
+  "ag",
+  "bv",
+  "co",
+  "company",
+  "corp",
+  "corporation",
+  "gmbh",
+  "inc",
+  "incorporated",
+  "kk",
+  "limited",
+  "llc",
+  "llp",
+  "lp",
+  "ltd",
+  "nv",
+  "oy",
+  "plc",
+  "pty",
+  "sa",
+  "sarl",
+  "sas",
+  "srl"
+]);
+function normalizeEntityName(name) {
+  const words = name.replace(/\([^)]*\)/g, " ").toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((word) => word.length > 0);
+  let end = words.length;
+  while (end > 0 && LEGAL_FORMS.has(words[end - 1])) end -= 1;
+  const start = words[0] === "the" ? 1 : 0;
+  const core = words.slice(start, end);
+  return (core.length > 0 ? core : words).join(" ");
 }
 function sanitizeGitHubHandle(name) {
   const handle = name.replace(/[\s_]+/g, "-");
@@ -1250,6 +1883,7 @@ function formatCdxTimestamp(ts) {
 }
 
 // src/presence-route.ts
+import { PluginRouteError as PluginRouteError2 } from "emdash";
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var PRESENCE_KEY = "presence:current";
 async function handlePresenceRoute(ctx) {
@@ -1258,7 +1892,7 @@ async function handlePresenceRoute(ctx) {
     case "data":
       return await handleData2(ctx);
     case "refresh":
-      return await handleRefresh(ctx);
+      return await handleRefresh2(ctx);
     default:
       throw PluginRouteError2.badRequest(
         `unknown presence route kind: ${String(body.kind)}`
@@ -1285,7 +1919,7 @@ async function handleData2(ctx) {
   const state = ageMs !== null && ageMs > CACHE_TTL_MS ? "stale" : "fresh";
   return payload(state, cached.results, cached.generatedAt, entity.name);
 }
-async function handleRefresh(ctx) {
+async function handleRefresh2(ctx) {
   const manifest = await readStoredFacts(ctx.kv);
   if (manifest === null) {
     return payload("no_manifest", [], null, null);
@@ -1372,8 +2006,61 @@ function globToMatcher(pattern) {
   return (route) => re.test(route);
 }
 
-// src/version.ts
-var PACKAGE_VERSION = "0.8.18";
+// src/content.ts
+async function evaluateContent3(document, preset, sources = {}, evidenceSources, onTelemetry) {
+  const started = onTelemetry ? performance.now() : 0;
+  const documentJson = JSON.stringify(document);
+  const sourcesJson = JSON.stringify(sources);
+  const result = evidenceSources === void 0 ? await evaluateContent2(documentJson, preset, sourcesJson) : await evaluateContent2(documentJson, preset, sourcesJson, JSON.stringify(evidenceSources));
+  const report = JSON.parse(result);
+  if (onTelemetry) {
+    const event = { evaluation_ms: performance.now() - started, source_locations_mapped: report.source_locations?.length ?? 0 };
+    for (const gate of report.gates) {
+      const checked = gate.measurements?.checked_destinations;
+      const invalid = gate.measurements?.invalid_destinations;
+      if (checked !== void 0 && invalid !== void 0) {
+        event.link_destinations ??= { checked: 0, invalid: 0 };
+        event.link_destinations.checked += checked;
+        event.link_destinations.invalid += invalid;
+      }
+    }
+    onTelemetry(event);
+  }
+  return report;
+}
+
+// src/content-evaluator.ts
+function withContentPreset(base, preset, evaluate) {
+  if (!preset) return base;
+  return async (documents, context) => {
+    const result = await base(documents, context);
+    if (!result.ok) return result;
+    const findings = [...result.findings];
+    try {
+      for (const [index, document] of documents.entries()) {
+        const collection = context?.collections[index];
+        if (preset.collections !== void 0) {
+          if (collection === void 0) throw new Error("collection is required for a scoped content preset");
+          if (!preset.collections.includes(collection)) continue;
+        }
+        const selected = collection !== void 0 && preset.byCollection !== void 0 && Object.hasOwn(preset.byCollection, collection) ? preset.byCollection[collection] : void 0;
+        const name = selected ?? preset.name;
+        if (!name) throw new Error(`empty preset name for collection ${collection}`);
+        const report = preset.evidenceSources === void 0 ? await evaluate(document, name, preset.sources) : await evaluate(document, name, preset.sources, preset.evidenceSources);
+        const incomplete = report.gates.filter((gate) => gate.status === "not_checked");
+        if (incomplete.length) return {
+          ok: false,
+          reason: "content_preset_incomplete",
+          detail: `${document.route}: ${incomplete.map((gate) => `${gate.gate_id}: ${gate.reason}`).join(", ")}`
+        };
+        for (const gate of report.gates) findings.push(...gate.findings);
+      }
+      return { ok: true, findings };
+    } catch (error) {
+      return { ok: false, reason: "content_preset_error", detail: error instanceof Error ? error.message : String(error) };
+    }
+  };
+}
 
 // src/configured.ts
 import { definePlugin } from "emdash";
@@ -1439,10 +2126,15 @@ function createPlugin(options = {}) {
     options.excludeCollections
   );
   const suppressionFilter = compileSuppressions(options.suppressions);
+  const evaluator = withContentPreset(inProcessEvaluator, options.contentPreset, evaluateContent3);
   return definePlugin({
     id: "aexeo-emdash",
     version: PACKAGE_VERSION,
-    capabilities: ["content:read"],
+    // The entity-presence route fetches its public sources directly (see
+    // presence-check.ts). rdap.org then redirects to the registry for the
+    // domain's TLD; those registries cannot be listed here.
+    capabilities: ["content:read", "network:request"],
+    allowedHosts: [...PRESENCE_HOSTS],
     hooks: {
       // afterSave processes one saved document at a time — collections
       // list isn't needed here. The hook always runs regardless of
@@ -1450,16 +2142,26 @@ function createPlugin(options = {}) {
       "content:afterSave": (event, ctx) => handleAfterSaveConfigured(
         event,
         ctx,
-        inProcessEvaluator,
-        suppressionFilter
-      )
+        evaluator,
+        suppressionFilter,
+        options.blockMappings,
+        options.contentFieldsByCollection?.[event.content.type]
+      ),
+      "content:afterDelete": (event, ctx) => handleAfterDelete(event, ctx)
     },
+    // emdash requires plugins:manage (admin) on a route that declares no
+    // permission. Reading findings only needs plugins:read (editor); anything
+    // that writes stays admin, stated explicitly so the split is visible.
     routes: {
       // The Refresh sweep (handleAdminRoute → handleRefresh) is the
       // one consumer of `collections`. Bind the resolved list here so
       // every request handles the same set without re-reading options.
+      //
+      // This route serves the pages and the dashboard widget, and also the
+      // refresh_findings action, which handleAdminRoute gates itself.
       admin: {
-        handler: (ctx) => handleAdminRoute(ctx, collections)
+        permission: "plugins:read",
+        handler: (ctx) => handleAdminRoute(ctx, collections, suppressionFilter, evaluator, options.blockMappings, options.contentFieldsByCollection)
       },
       // JSON data endpoint for the React adminEntry. Two routes:
       //   POST /_emdash/api/plugins/aexeo-emdash/data    — read current findings
@@ -1469,19 +2171,25 @@ function createPlugin(options = {}) {
       // emdash edit page and the public site, which Block Kit can't
       // express in any element type as of emdash 0.8.0.
       data: {
+        permission: "plugins:read",
         handler: async (ctx) => (await handleDataRoute(ctx, {
           collections,
-          evaluator: inProcessEvaluator,
+          evaluator,
           refresh: false,
-          suppressionFilter
+          suppressionFilter,
+          blockMappings: options.blockMappings,
+          contentFieldsByCollection: options.contentFieldsByCollection
         })).payload
       },
       refresh: {
+        permission: "plugins:manage",
         handler: (ctx) => handleDataRoute(ctx, {
           collections,
-          evaluator: inProcessEvaluator,
+          evaluator,
           refresh: true,
-          suppressionFilter
+          suppressionFilter,
+          blockMappings: options.blockMappings,
+          contentFieldsByCollection: options.contentFieldsByCollection
         })
       },
       // /facts route serves the truth-manifest authoring UI. It
@@ -1489,6 +2197,7 @@ function createPlugin(options = {}) {
       // onto one POST endpoint via a "kind" body field — see
       // facts-route.ts for the full contract.
       facts: {
+        permission: "plugins:manage",
         handler: (ctx) => handleFactsRoute(ctx)
       },
       // /presence route serves the layer-4 entity-presence
@@ -1498,6 +2207,7 @@ function createPlugin(options = {}) {
       // results in KV for 24h. Multiplexes data / refresh kinds —
       // see presence-route.ts.
       presence: {
+        permission: "plugins:manage",
         handler: (ctx) => handlePresenceRoute(ctx)
       }
     },
@@ -1529,246 +2239,76 @@ function createPlugin(options = {}) {
   });
 }
 var configured_default = createPlugin;
-function normalizeInteraction(input) {
-  if (!input || typeof input !== "object") {
-    return { type: "page_load", page: "/findings" };
-  }
-  const raw = input;
-  if (raw.type === "page_load") {
-    return {
-      type: "page_load",
-      page: typeof raw.page === "string" && raw.page.length > 0 ? raw.page : "/findings"
-    };
-  }
-  if (raw.type === "block_action") {
-    return {
-      type: "block_action",
-      action_id: typeof raw.action_id === "string" ? raw.action_id : "",
-      ...typeof raw.block_id === "string" ? { block_id: raw.block_id } : {},
-      value: raw.value
-    };
-  }
-  if (raw.type === "form_submit") {
-    return {
-      type: "form_submit",
-      action_id: typeof raw.action_id === "string" ? raw.action_id : "",
-      ...typeof raw.block_id === "string" ? { block_id: raw.block_id } : {},
-      values: raw.values && typeof raw.values === "object" ? raw.values : {}
-    };
-  }
-  return { type: "page_load", page: "/findings" };
-}
-async function handleAdminRoute(ctx, collections) {
+var ADMIN_ROLE = 50;
+var adminViewTuning = {
+  emptyFindingsText: "Once a Refresh runs, findings will list here.",
+  emptyScoreText: "No documents indexed \u2014 click Refresh on the Aexeo findings page.",
+  refreshFailureVariant: "error",
+  score: async (documents, kv) => scoreLocally(documents, await readStoredFacts(kv)),
+  truthLabel: formatTruthLabel
+};
+async function handleAdminRoute(ctx, collections, suppressionFilter, evaluator, blockMappings, contentFieldsByCollection) {
   const body = normalizeInteraction(ctx.input);
   if (body.type === "page_load") {
     return handlePageLoad(ctx, body.page);
   }
   if (body.type === "block_action") {
     if (body.action_id === "view_document" && typeof body.value === "string") {
-      return renderDocumentPanel(ctx, body.value);
+      return renderDocumentPanel(ctx.kv, body.value);
     }
     if (body.action_id === "refresh_findings") {
-      return handleRefresh2(ctx, collections);
+      if ((ctx.user?.role ?? 0) < ADMIN_ROLE) {
+        const page = await renderFindingsPage(ctx.kv, adminViewTuning);
+        return {
+          ...page,
+          blocks: [
+            {
+              type: "banner",
+              title: "Only administrators can run Refresh.",
+              variant: "error"
+            },
+            ...page.blocks
+          ]
+        };
+      }
+      return handleRefresh({
+        ctx,
+        collections,
+        evaluator,
+        suppressionFilter,
+        tuning: adminViewTuning,
+        blockMappings,
+        contentFieldsByCollection
+      });
     }
     if (body.action_id.startsWith("filter:")) {
-      return renderFindingsPage(ctx);
+      return renderFindingsPage(ctx.kv, adminViewTuning);
     }
-    return notFound2(body.action_id);
+    return notFound(body.action_id);
   }
   if (body.type === "form_submit") {
     if (body.action_id === "view_document") {
       const picked = body.values["route_picker"];
       if (typeof picked === "string" && picked.length > 0) {
-        return renderDocumentPanel(ctx, picked);
+        return renderDocumentPanel(ctx.kv, picked);
       }
     }
-    return renderFindingsPage(ctx);
+    return renderFindingsPage(ctx.kv, adminViewTuning);
   }
-  return renderFindingsPage(ctx);
+  return renderFindingsPage(ctx.kv, adminViewTuning);
 }
 async function handlePageLoad(ctx, page) {
   const normalized = page.startsWith("/") ? page.slice(1) : page;
   if (normalized === "" || normalized === "findings") {
-    return renderFindingsPage(ctx);
+    return renderFindingsPage(ctx.kv, adminViewTuning);
   }
   if (normalized === "widget:aexeo-score") {
-    return renderScoreWidget(ctx);
+    return renderScoreWidget(ctx.kv, adminViewTuning, ctx.log);
   }
   if (normalized === "document") {
-    return renderDocumentPanel(ctx);
-  }
-  return notFound2(page);
-}
-async function handleRefresh2(ctx, collections) {
-  let summary;
-  try {
-    summary = await evaluateAndPersistAll(ctx, {
-      evaluator: inProcessEvaluator,
-      collections
-    });
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    return {
-      blocks: [
-        { type: "header", text: "SEO findings" },
-        {
-          type: "banner",
-          title: `Refresh failed: ${detail}`,
-          variant: "error"
-        }
-      ],
-      toast: { message: `Refresh failed: ${detail}`, type: "error" }
-    };
-  }
-  const refreshed = await renderFindingsPage(ctx);
-  const toastMessage = summary.errors.length === 0 ? `Refreshed ${summary.routesUpdated} routes (${summary.totalFindings} findings across ${summary.documentsScanned} documents)` : `Refresh completed with ${summary.errors.length} errors \u2014 see banner`;
-  if (summary.errors.length > 0) {
-    refreshed.blocks.unshift({
-      type: "banner",
-      title: `Refresh issues: ${summary.errors.join(" \u2022 ")}`,
-      variant: "alert"
-    });
-  }
-  return {
-    ...refreshed,
-    toast: {
-      message: toastMessage,
-      type: summary.errors.length === 0 ? "success" : "info"
-    }
-  };
-}
-async function readAllFindings(ctx) {
-  const entries = await ctx.kv.list(
-    "findings:"
-  );
-  const out = [];
-  for (const entry of entries) {
-    if (entry.value === null) continue;
-    const route = entry.key.replace(/^findings:/, "");
-    for (const finding of entry.value.findings) {
-      out.push({ ...finding, document_route: route });
-    }
-  }
-  return out;
-}
-function severityFirst(a, b) {
-  const rank = (severity) => severity === "error" ? 0 : 1;
-  const diff = rank(a.severity) - rank(b.severity);
-  if (diff !== 0) return diff;
-  return a.rule_id.localeCompare(b.rule_id);
-}
-function uniqueRoutes(rows) {
-  const set = /* @__PURE__ */ new Set();
-  for (const row of rows) set.add(row.document_route);
-  return [...set].sort();
-}
-async function renderFindingsPage(ctx) {
-  const findings = await readAllFindings(ctx);
-  const errors = findings.filter((f) => f.severity === "error");
-  const warnings = findings.filter((f) => f.severity === "warning");
-  const sorted = [...findings].sort(severityFirst);
-  const routes = uniqueRoutes(findings);
-  const blocks = [
-    { type: "header", text: "SEO findings" },
-    {
-      type: "context",
-      text: findings.length === 0 ? "No findings yet \u2014 click Refresh to evaluate the site." : `${findings.length} findings across ${routes.length} routes \u2014 ${errors.length} errors, ${warnings.length} warnings.`
-    },
-    { type: "divider" },
-    {
-      type: "actions",
-      elements: [
-        {
-          type: "button",
-          label: "Refresh",
-          action_id: "refresh_findings",
-          style: "primary"
-        },
-        { type: "button", label: "All", action_id: "filter:all" },
-        { type: "button", label: "Errors only", action_id: "filter:errors" },
-        {
-          type: "button",
-          label: "Warnings only",
-          action_id: "filter:warnings"
-        }
-      ]
-    },
-    sorted.length === 0 ? {
-      type: "context",
-      text: "Once a Refresh runs, findings will list here."
-    } : findingsTable(sorted)
-  ];
-  if (routes.length > 0) {
-    blocks.push({
-      type: "form",
-      fields: [
-        {
-          type: "select",
-          action_id: "route_picker",
-          label: "Document to inspect",
-          options: routes.map((route) => ({ label: route, value: route }))
-        }
-      ],
-      submit: { label: "View document SEO", action_id: "view_document" }
-    });
-  }
-  return { blocks };
-}
-function findingsTable(rows) {
-  return {
-    type: "table",
-    columns: [
-      { key: "route", label: "Route" },
-      { key: "rule", label: "Rule", format: "code" },
-      { key: "severity", label: "Severity", format: "badge" },
-      { key: "message", label: "Message" }
-    ],
-    rows: rows.map((row) => ({
-      route: row.document_route,
-      rule: row.rule_id,
-      severity: row.severity,
-      message: row.message
-    }))
-  };
-}
-async function renderScoreWidget(ctx) {
-  const documents = await readAllDocuments(ctx.kv);
-  if (documents.length === 0) {
-    return {
-      blocks: [
-        { type: "header", text: "SEO score" },
-        {
-          type: "context",
-          text: "No documents indexed \u2014 click Refresh on the Aexeo findings page."
-        }
-      ]
-    };
+    return renderDocumentPanel(ctx.kv);
   }
-  const facts = await readStoredFacts(ctx.kv);
-  const score = await scoreLocally(documents, facts);
-  const truthLabel = formatTruthLabel(score);
-  const blocks = [
-    {
-      type: "stats",
-      items: [
-        { label: "Overall", value: `${score.overall_score}` },
-        { label: "Citation", value: `${score.citation_readiness_score}` },
-        { label: truthLabel, value: `${score.truth_consistency_score}` },
-        { label: "Answers", value: `${score.answer_pack_score}` }
-      ]
-    }
-  ];
-  if (score.overall_score < 60) {
-    blocks.unshift({
-      type: "banner",
-      title: `Site score is ${score.overall_score} \u2014 below the 60 quality threshold`,
-      variant: "alert"
-    });
-  }
-  if (score.blockers.length > 0) {
-    blocks.push({ type: "context", text: topBlockersLine(score) });
-  }
-  return { blocks };
+  return notFound(page);
 }
 async function scoreLocally(documents, manifest = null) {
   const manifestJson = manifest === null ? null : JSON.stringify(manifest);
@@ -1789,63 +2329,6 @@ function formatTruthLabel(score) {
       return "Truth";
   }
 }
-function topBlockersLine(score) {
-  const top = score.blockers.slice(0, 3).map((b) => b.message);
-  if (top.length === 0) return "No blockers identified.";
-  return `Top blockers: ${top.join(" \u2022 ")}`;
-}
-async function renderDocumentPanel(ctx, route) {
-  if (route === void 0) {
-    return {
-      blocks: [
-        { type: "header", text: "Document SEO" },
-        {
-          type: "context",
-          text: "Pick a document from the SEO findings list to see its rule findings here."
-        }
-      ]
-    };
-  }
-  const findings = await readFindings(ctx.kv, route);
-  const errors = findings.filter((f) => f.severity === "error");
-  const warnings = findings.filter((f) => f.severity === "warning");
-  const sorted = [...findings].sort(severityFirst);
-  return {
-    blocks: [
-      { type: "header", text: `Document SEO \u2014 ${route}` },
-      {
-        type: "context",
-        text: findings.length === 0 ? `No findings for ${route} \u2014 the document is currently clean.` : `${findings.length} findings \u2014 ${errors.length} errors, ${warnings.length} warnings.`
-      },
-      ...findings.length === 0 ? [] : [{ type: "divider" }, documentFindingsTable(sorted)]
-    ]
-  };
-}
-function documentFindingsTable(findings) {
-  return {
-    type: "table",
-    columns: [
-      { key: "rule", label: "Rule", format: "code" },
-      { key: "severity", label: "Severity", format: "badge" },
-      { key: "message", label: "Message" },
-      { key: "block", label: "Block", format: "code" }
-    ],
-    rows: findings.map((finding) => ({
-      rule: finding.rule_id,
-      severity: finding.severity,
-      message: finding.message,
-      block: `${finding.path}:${finding.line}`
-    }))
-  };
-}
-function notFound2(page) {
-  return {
-    blocks: [
-      { type: "header", text: "Not found" },
-      { type: "context", text: `unknown page: ${page}` }
-    ]
-  };
-}
 export {
   createPlugin,
   configured_default as default