@aeptus/aexeo-emdash 0.8.19 → 0.9.1

package/dist/configured.js

@@ -4,14 +4,39 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/cms-coverage.ts
+var NATIVE_RULE_ID = /^(?:A11Y|AGT|CNT|CRW|DEP|EDT|FACTS|GEO|IMG|LLM|LNK|MAP|QLT|ROB|SCH|SEO|SOC|SRF)[0-9]{3}$/;
+var OBSERVABLE_BODY_RULES = /* @__PURE__ */ new Set(["CNT006", "LNK003"]);
+function isCmsObservableFinding(finding, bodyComplete = true) {
+  return finding.aexeo_origin === "content_preset" || isLegacyCmsObservableFinding(finding, bodyComplete);
+}
+function isLegacyCmsObservableFinding(finding, bodyComplete = true) {
+  if (!NATIVE_RULE_ID.test(finding.rule_id)) return true;
+  return bodyComplete && finding.scope === "page" && OBSERVABLE_BODY_RULES.has(finding.rule_id);
+}
+function hasCompleteBody(document) {
+  return document.body !== void 0 && (document.body_capabilities === void 0 || ["text", "headings", "paragraphs", "links"].every((capability) => document.body_capabilities?.includes(capability)));
+}
+function cmsBodyCoverage(document) {
+  if (document.body === void 0 || document.body_capabilities?.length === 0) return "unavailable";
+  return hasCompleteBody(document) ? "complete" : "partial";
+}
+function cmsBodyCoverageNotice(coverage) {
+  if (coverage === "complete") return void 0;
+  return coverage === void 0 ? "Body coverage is unknown for this evaluation; save or refresh to reassess it." : `Body coverage is ${coverage}; content checks depending on missing capabilities cannot be evaluated reliably.`;
+}
+
 // src/adapter.ts
-async function adaptContentItemWithContext(content, contentApi, defaultLocale) {
+async function adaptContentItemWithContext(content, contentApi, defaultLocale, blockMappings, contentFields, descriptionFields) {
   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 },
+    ...descriptionFields === void 0 ? {} : { descriptionFields }
   });
   const translationSet = await contentApi.getTranslations(
     content.type,
@@ -36,14 +61,32 @@ async function adaptContentItemWithContext(content, contentApi, defaultLocale) {
   return adapted;
 }
 function adaptContentItem(content, options = {}) {
+  return adaptContentItemInternal(content, options, true);
+}
+function adaptContentItemInternal(content, options, includeSourcePaths) {
   const route = options.route ?? deriveRoute(content);
   const title = stringOrEmpty(
     content.seo?.title ?? content.data["title"] ?? content.slug ?? content.id
   );
-  const document = { route, title };
-  const description = content.seo?.description ?? content.data["description"];
-  if (typeof description === "string" && description.length > 0) {
-    document.description = description;
+  const document = { route, title, description_source_observed: false };
+  const fields = options.descriptionFields;
+  if (fields === void 0) {
+    const description = content.seo?.description ?? content.data["description"];
+    if (typeof description === "string" && description.length > 0) document.description = description;
+  } else if (fields.length > 0 && fields.every((field) => typeof field === "string" && field.length > 0)) {
+    let observed = true;
+    for (const field of fields) {
+      if (!Object.hasOwn(content.data, field) || content.data[field] === void 0 || content.data[field] !== null && typeof content.data[field] !== "string") {
+        observed = false;
+        break;
+      }
+      const value = content.data[field];
+      if (typeof value === "string" && value.length > 0) {
+        document.description = value;
+        break;
+      }
+    }
+    if (observed) document.description_source_observed = true;
   }
   const canonical = content.seo?.canonical;
   if (typeof canonical === "string" && canonical.length > 0) {
@@ -53,8 +96,13 @@ 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;
+  }
+  const bodySourcePaths = body === null || !includeSourcePaths ? void 0 : portableTextSourcePaths(content.data, body.blocks);
+  const bodySourceSpanPaths = body === null || !includeSourcePaths ? void 0 : portableTextSourceSpanPaths(content.data, body.blocks, bodySourcePaths);
   return {
     document,
     meta: {
@@ -63,7 +111,10 @@ function adaptContentItem(content, options = {}) {
       slug: content.slug,
       status: content.status,
       title,
-      publicUrl: options.publicUrl ?? null
+      publicUrl: options.publicUrl ?? null,
+      ...bodySourcePaths === void 0 ? {} : { bodySourcePaths },
+      ...bodySourceSpanPaths === void 0 ? {} : { bodySourceSpanPaths },
+      ...content.updatedAt === void 0 ? {} : { updatedAt: content.updatedAt }
     }
   };
 }
@@ -82,38 +133,390 @@ function routeFromPublicUrl(publicUrl) {
 function stringOrEmpty(value) {
   return typeof value === "string" ? value : "";
 }
-function extractPortableText(data) {
+function portableTextSourcePaths(data, blocks) {
+  if (blocks.length === 0) return void 0;
+  const targets = new WeakSet(blocks);
+  const paths = /* @__PURE__ */ new WeakMap();
+  const seen = /* @__PURE__ */ new WeakSet();
+  const stack = [{ value: data, path: ["data"] }];
+  let count = 0;
+  let inspected = 0;
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (typeof current.value !== "object" || current.value === null) continue;
+    if (++count > 5e4 || current.path.length > 64 || seen.has(current.value)) return void 0;
+    seen.add(current.value);
+    if (targets.has(current.value)) {
+      paths.set(current.value, current.path);
+      continue;
+    }
+    if (Array.isArray(current.value)) {
+      for (let i = 0; i < current.value.length; i++) {
+        if (++inspected > 5e4) return void 0;
+        const value = current.value[i];
+        if (typeof value === "object" && value !== null) stack.push({ value, path: [...current.path, i] });
+      }
+    } else {
+      for (const key in current.value) {
+        if (!Object.hasOwn(current.value, key)) continue;
+        if (++inspected > 5e4) return void 0;
+        const value = current.value[key];
+        if (typeof value === "object" && value !== null) stack.push({ value, path: [...current.path, key] });
+      }
+    }
+  }
+  const result = blocks.map((block) => paths.get(block) ?? null);
+  return result.some((path) => path !== null) ? result : void 0;
+}
+var BODY_CAPABILITIES = ["text", "headings", "paragraphs", "links"];
+function intersectCapabilities(current, other) {
+  return other === void 0 ? [...current] : current.filter((capability) => other.includes(capability));
+}
+function bodyWithCapabilities(blocks, capabilities) {
+  return capabilities.length === BODY_CAPABILITIES.length ? { blocks } : { blocks, capabilities };
+}
+function portableTextSourceSpanPaths(data, blocks, blockPaths) {
+  const targets = /* @__PURE__ */ new WeakSet();
+  let targetCount = 0;
+  for (let i = 0; i < blocks.length; i++) {
+    if (blockPaths?.[i]) continue;
+    for (const child of blocks[i].children) {
+      if (++targetCount > 5e4) return void 0;
+      targets.add(child);
+    }
+  }
+  if (targetCount === 0) return void 0;
+  const paths = /* @__PURE__ */ new WeakMap();
+  const seen = /* @__PURE__ */ new WeakSet();
+  const stack = [
+    { value: data, path: ["data"], portableChild: false }
+  ];
+  let count = 0;
+  let inspected = 0;
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (typeof current.value !== "object" || current.value === null) continue;
+    if (++count > 5e4 || current.path.length > 64 || seen.has(current.value)) return void 0;
+    seen.add(current.value);
+    if (current.portableChild && targets.has(current.value) && isPortableTextSpan(current.value)) {
+      paths.set(current.value, [...current.path, "text"]);
+    }
+    if (Array.isArray(current.value)) {
+      for (let i = 0; i < current.value.length; i++) {
+        if (++inspected > 5e4) return void 0;
+        const value = current.value[i];
+        if (typeof value === "object" && value !== null) stack.push({ value, path: [...current.path, i], portableChild: current.portableChild });
+      }
+    } else {
+      for (const key in current.value) {
+        if (!Object.hasOwn(current.value, key)) continue;
+        if (++inspected > 5e4) return void 0;
+        const value = current.value[key];
+        if (typeof value === "object" && value !== null) stack.push({ value, path: [...current.path, key], portableChild: key === "children" && isPortableTextBlockCandidate(current.value) });
+      }
+    }
+  }
+  let mapped = false;
+  const result = blocks.map((block, index) => {
+    if (blockPaths?.[index]) return null;
+    return block.children.map((child) => {
+      const path = paths.get(child) ?? null;
+      if (path !== null) mapped = true;
+      return path;
+    });
+  });
+  return mapped ? result : void 0;
+}
+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) {
+      capabilities = [];
+      continue;
+    }
+    observed = true;
+    if (value === null) continue;
+    const part = extractFirstPortableText({ content: value }, mappings);
+    if (part === null) {
+      capabilities = [];
+      continue;
+    }
+    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) || isMixedPortableTextArray(value) || isEmdashBlocksArray(value, field) || (field === "body" || field === "content") && typeof value === "string" && value.trim().length > 0
+  );
+  const unrecognizedBody = ["body", "content", "blocks"].some((field) => {
+    const value = data[field];
+    if (value == null || Array.isArray(value) && value.length === 0 || typeof value === "string" && value.trim().length === 0) return false;
+    return !candidates.some(([candidate]) => candidate === field);
+  });
+  return candidates.length > 1 || unrecognizedBody ? { 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 (isMixedPortableTextArray(value)) return mapMixedPortableText(value, mappings);
+    if (isEmdashBlocksArray(value, slug)) return mapMixedPortableText(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 (isMixedPortableTextArray(blocks)) return mapMixedPortableText(blocks, mappings);
+  if (isEmdashBlocksArray(blocks, "blocks")) return mapMixedPortableText(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 (isMixedPortableTextArray(value)) return mapMixedPortableText(value, mappings);
+    if (isEmdashBlocksArray(value, field)) return mapMixedPortableText(value, mappings);
   }
-  return null;
+  return foundEmptyBody ? { blocks: [] } : null;
 }
 function isPortableTextArray(value) {
   return Array.isArray(value) && value.length > 0 && value.every(
-    (item) => isRecord(item) && item["_type"] === "block" && Array.isArray(item["children"]) && item["children"].every(
-      (child) => isRecord(child) && typeof child["text"] === "string"
-    )
+    (item) => isPortableTextBlockCandidate(item) && isWireSafeBlock(item)
   );
 }
+function isPortableTextSpan(value) {
+  return isRecord(value) && value["_type"] === "span" && typeof value["text"] === "string";
+}
+function isPortableTextBlockCandidate(value) {
+  return isRecord(value) && value["_type"] === "block" && Array.isArray(value["children"]);
+}
+function isWireSafeSpan(value) {
+  return isPortableTextSpan(value) && isRecord(value) && (value["_key"] == null || typeof value["_key"] === "string") && (value["marks"] === void 0 || Array.isArray(value["marks"]) && value["marks"].every((mark) => typeof mark === "string"));
+}
+function isWireSafeMarkDef(value) {
+  return isRecord(value) && typeof value["_key"] === "string" && typeof value["_type"] === "string" && (value["_type"] !== "link" || typeof value["href"] === "string");
+}
+function isWireSafeBlock(block) {
+  const level = block["level"];
+  return (block["_key"] == null || typeof block["_key"] === "string") && (block["style"] === void 0 || typeof block["style"] === "string" && ["normal", "h1", "h2", "h3", "h4", "h5", "h6", "blockquote"].includes(block["style"])) && (block["listItem"] == null || block["listItem"] === "bullet" || block["listItem"] === "number") && (level == null || typeof level === "number" && Number.isInteger(level) && level >= 0 && level <= 4294967295) && (block["markDefs"] === void 0 || Array.isArray(block["markDefs"]) && block["markDefs"].every(isWireSafeMarkDef)) && block["children"].every(isWireSafeSpan);
+}
+function normalizePortableBlock(block) {
+  const normalized = { ...block };
+  let incomplete = false;
+  if (normalized["_key"] != null && typeof normalized["_key"] !== "string") {
+    delete normalized["_key"];
+    incomplete = true;
+  }
+  if (normalized["style"] !== void 0 && (typeof normalized["style"] !== "string" || !["normal", "h1", "h2", "h3", "h4", "h5", "h6", "blockquote"].includes(normalized["style"]))) {
+    delete normalized["style"];
+    incomplete = true;
+  }
+  if (normalized["listItem"] != null && normalized["listItem"] !== "bullet" && normalized["listItem"] !== "number") {
+    delete normalized["listItem"];
+    incomplete = true;
+  }
+  const level = normalized["level"];
+  if (level != null && (typeof level !== "number" || !Number.isInteger(level) || level < 0 || level > 4294967295)) {
+    delete normalized["level"];
+    incomplete = true;
+  }
+  if (normalized["markDefs"] !== void 0) {
+    if (!Array.isArray(normalized["markDefs"])) {
+      delete normalized["markDefs"];
+      incomplete = true;
+    } else {
+      const defs = normalized["markDefs"].filter(isWireSafeMarkDef);
+      if (defs.length !== normalized["markDefs"].length) {
+        normalized["markDefs"] = defs;
+        incomplete = true;
+      }
+    }
+  }
+  normalized["children"] = block["children"].map((child) => {
+    if (!isPortableTextSpan(child) || !isRecord(child) || isWireSafeSpan(child)) return child;
+    const span = { ...child };
+    if (span["_key"] != null && typeof span["_key"] !== "string") delete span["_key"];
+    if (span["marks"] !== void 0 && (!Array.isArray(span["marks"]) || !span["marks"].every((mark) => typeof mark === "string"))) delete span["marks"];
+    incomplete = true;
+    return span;
+  });
+  return { block: normalized, incomplete };
+}
+function isMixedPortableTextArray(value) {
+  return Array.isArray(value) && value.some(isPortableTextBlockCandidate);
+}
+function mapMixedPortableText(blocks, mappings, depth = 0) {
+  if (depth > 8) return { blocks: [], capabilities: [] };
+  const result = [];
+  let capabilities = [...BODY_CAPABILITIES];
+  for (const block of blocks) {
+    if (isPortableTextArray([block])) {
+      result.push(block);
+      continue;
+    }
+    if (isPortableTextBlockCandidate(block)) {
+      const normalized = normalizePortableBlock(block);
+      const projected = projectInlineBlock(normalized.block, mappings);
+      result.push(projected.block);
+      capabilities = normalized.incomplete ? [] : intersectCapabilities(capabilities, projected.capabilities);
+      continue;
+    }
+    if (!isRecord(block) || typeof block["_type"] !== "string" || block["_type"] === "block") {
+      capabilities = [];
+      continue;
+    }
+    const mapped = mapCustomBlocks([block], mappings, depth + 1);
+    result.push(...mapped.blocks);
+    capabilities = intersectCapabilities(capabilities, mapped.capabilities);
+  }
+  return bodyWithCapabilities(result, capabilities);
+}
+function projectInlineBlock(block, mappings) {
+  const children = [];
+  const defs = Array.isArray(block["markDefs"]) ? [...block["markDefs"]] : [];
+  const keys = new Set(defs.flatMap((def) => isRecord(def) && typeof def["_key"] === "string" ? [def["_key"]] : []));
+  let sequence = 0;
+  let capabilities = block["markDefs"] === void 0 || Array.isArray(block["markDefs"]) ? [...BODY_CAPABILITIES] : [];
+  for (const child of block["children"]) {
+    if (isRecord(child) && Array.isArray(child["marks"])) {
+      for (const mark of child["marks"]) if (typeof mark === "string") keys.add(mark);
+    }
+  }
+  for (const child of block["children"]) {
+    if (isPortableTextSpan(child)) {
+      children.push(child);
+      continue;
+    }
+    const type = isRecord(child) ? child["_type"] : void 0;
+    const mapping = typeof type === "string" && mappings && Object.hasOwn(mappings, type) ? mappings[type] : void 0;
+    if (!isRecord(child) || !isRecord(mapping) || !Array.isArray(mapping["inline"])) {
+      capabilities = [];
+      continue;
+    }
+    const declared = mapping["capabilities"];
+    if (declared !== void 0 && (!Array.isArray(declared) || declared.some((value) => typeof value !== "string" || !BODY_CAPABILITIES.includes(value)) || new Set(declared).size !== declared.length)) {
+      capabilities = [];
+      continue;
+    }
+    const newChildren = [];
+    const newDefs = [];
+    let valid = true;
+    for (const field of mapping["inline"]) {
+      if (!isRecord(field) || field["kind"] !== "text" && field["kind"] !== "link" || typeof field["field"] !== "string" || !field["field"] || field["optional"] !== void 0 && typeof field["optional"] !== "boolean" || field["kind"] === "link" && (typeof field["hrefField"] !== "string" || !field["hrefField"])) {
+        valid = false;
+        break;
+      }
+      const value = child[field["field"]];
+      const href = field["kind"] === "link" && typeof field["hrefField"] === "string" && field["hrefField"] ? child[field["hrefField"]] : void 0;
+      if ((value == null || value === "") && field["optional"] === true && (field["kind"] !== "link" || href == null || href === "")) continue;
+      if (typeof value !== "string" || field["kind"] === "link" && (typeof href !== "string" || !href)) {
+        valid = false;
+        break;
+      }
+      if (field["kind"] === "text") newChildren.push({ _type: "span", text: value, marks: [] });
+      else {
+        let key;
+        do {
+          key = `aexeo-inline-${sequence++}`;
+        } while (keys.has(key));
+        keys.add(key);
+        newDefs.push({ _key: key, _type: "link", href });
+        newChildren.push({ _type: "span", text: value, marks: [key] });
+      }
+    }
+    if (!valid) {
+      capabilities = [];
+      continue;
+    }
+    children.push(...newChildren);
+    defs.push(...newDefs);
+    if (Array.isArray(declared)) capabilities = intersectCapabilities(capabilities, declared);
+  }
+  return { block: { ...block, children, markDefs: defs }, capabilities };
+}
 function isEmdashBlocksArray(value, field) {
   if (!Array.isArray(value) || value.length === 0) return false;
   return value.every(
-    (item) => isRecord(item) && typeof item["_type"] === "string" && typeof item["_key"] === "string" && (typeof item["_version"] === "number" || field === "blocks")
+    (item) => isRecord(item) && typeof item["_type"] === "string" && typeof item["_key"] === "string" && (typeof item["_version"] === "number" || field === "blocks" || field === "body" || field === "content")
   );
 }
+function mapCustomBlocks(blocks, mappings, depth = 0) {
+  if (depth > 8) return { blocks: [], capabilities: [] };
+  const unavailable = () => ({ blocks: blocksToPortableText(blocks), capabilities: [] });
+  const result = [];
+  let capabilities = [...BODY_CAPABILITIES];
+  const mapFields = (record, fields, depth2) => {
+    if (depth2 > 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)) return false;
+        if (value.length === 0 || isPortableTextArray(value)) {
+          result.push(...value);
+        } else if (isMixedPortableTextArray(value) || isEmdashBlocksArray(value, "blocks")) {
+          const nested = mapMixedPortableText(value, mappings, depth2 + 1);
+          result.push(...nested.blocks);
+          capabilities = intersectCapabilities(capabilities, nested.capabilities);
+        } else {
+          return false;
+        }
+      } 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, depth2 + 1)) return false;
+        }
+      } else {
+        return false;
+      }
+    }
+    return true;
+  };
+  for (const block of blocks) {
+    const mapping = mappings?.[String(block["_type"])];
+    let fields;
+    if (Array.isArray(mapping)) {
+      fields = mapping;
+    } else if (isRecord(mapping) && Array.isArray(mapping["fields"]) && Array.isArray(mapping["capabilities"])) {
+      const declared = mapping["capabilities"];
+      if (declared.some((capability) => typeof capability !== "string" || !BODY_CAPABILITIES.includes(capability)) || new Set(declared).size !== declared.length) return unavailable();
+      fields = mapping["fields"];
+      capabilities = intersectCapabilities(capabilities, declared);
+    } else return unavailable();
+    if (fields.length === 0) continue;
+    if (!mapFields(block, fields, depth)) return unavailable();
+  }
+  return bodyWithCapabilities(result, capabilities);
+}
 function blocksToPortableText(blocks) {
   const paragraphs = [];
   for (const block of blocks) {
@@ -126,20 +529,49 @@ function blocksToPortableText(blocks) {
   }
   return paragraphs;
 }
+var FALLBACK_MAX_DEPTH = 64;
+var FALLBACK_MAX_NODES = 5e4;
+var FALLBACK_MAX_CHARS = 1048576;
 function collectText(value, key, out) {
-  if (typeof value === "string") {
-    if (!isStructuralField(key) && value.trim().length > 0) out.push(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) collectText(item, key, out);
-    return;
-  }
-  if (!isRecord(value)) return;
-  for (const [childKey, childValue] of Object.entries(value)) {
-    if (isStructuralField(childKey)) continue;
-    collectText(childValue, childKey, out);
-  }
+  const active = /* @__PURE__ */ new WeakSet();
+  let nodes = 0;
+  let remaining = FALLBACK_MAX_CHARS;
+  const visit = (current, field, depth) => {
+    if (depth > FALLBACK_MAX_DEPTH || nodes >= FALLBACK_MAX_NODES || remaining <= 0) return;
+    nodes++;
+    if (typeof current === "string") {
+      if (!isStructuralField(field)) {
+        const separator = out.length > 0 ? 1 : 0;
+        const limit = Math.max(0, remaining - separator);
+        let text = current.slice(0, limit);
+        if (limit < current.length && /[\uD800-\uDBFF]/.test(text.at(-1) ?? "") && /[\uDC00-\uDFFF]/.test(current[limit] ?? "")) text = text.slice(0, -1);
+        text = text.trim();
+        if (text.length > 0) {
+          out.push(text);
+          remaining -= text.length + separator;
+        }
+      }
+      return;
+    }
+    if (!Array.isArray(current) && !isRecord(current)) return;
+    if (active.has(current)) return;
+    active.add(current);
+    if (Array.isArray(current)) {
+      for (const item of current) {
+        if (nodes >= FALLBACK_MAX_NODES || remaining <= 0) break;
+        visit(item, field, depth + 1);
+      }
+    } else {
+      for (const childKey in current) {
+        if (nodes >= FALLBACK_MAX_NODES || remaining <= 0) break;
+        if (Object.hasOwn(current, childKey) && !isStructuralField(childKey)) {
+          visit(current[childKey], childKey, depth + 1);
+        }
+      }
+    }
+    active.delete(current);
+  };
+  visit(value, key, 0);
 }
 var STRUCTURAL_FIELDS = /* @__PURE__ */ new Set([
   "_key",
@@ -197,35 +629,210 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/version.ts
+var PACKAGE_VERSION = "0.9.1";
+
 // src/plugin.ts
 var SETTINGS_TOKEN_KEY = "eval_token";
+var SETTINGS_BLOCK_MAPPINGS_KEY = "block_mappings";
+var SETTINGS_CONTENT_FIELDS_KEY = "content_fields_by_collection";
+var SETTINGS_DESCRIPTION_FIELDS_KEY = "description_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_DESCRIPTION_FIELDS_KEY]: {
+    type: "string",
+    label: "Description fields by collection (JSON)",
+    description: "Ordered renderer description fallback 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."
   }
 };
-async function handleAfterSaveConfigured(event, ctx, evaluator, suppressionFilter) {
-  const adapted = await adaptContentItemWithContext(
-    event.content,
-    ctx.content,
-    ctx.site?.locale
+function recordContentCoverage(ctx, documents) {
+  const counts = { documents: documents.length, complete: 0, partial: 0, unavailable: 0 };
+  for (const document of documents) {
+    counts[cmsBodyCoverage(document)]++;
+  }
+  try {
+    ctx.log?.info?.("aexeo.content_coverage", counts);
+    ctx.log?.info?.("aexeo.page_coverage", { documents: documents.length, rendered_page: "not_observed", generated_metadata: "not_observed" });
+    const observed = documents.filter((document) => document.description_source_observed === true).length;
+    const withValue = documents.filter((document) => document.description_source_observed === true && !!document.description).length;
+    ctx.log?.info?.("aexeo.description_coverage", { documents: documents.length, observed, with_value: withValue, unverified: documents.length - observed });
+  } catch {
+  }
+}
+function recordAssessmentCoverage(ctx, result, documents) {
+  let passed = 0, failed = 0, notChecked = 0, mappingReports = 0, mappingEligible = 0, mappingMapped = 0, mappingUnmapped = 0;
+  if (result.ok) for (const assessment of Object.values(result.assessments ?? {})) {
+    if (assessment.status !== "evaluated") continue;
+    if (assessment.source_mapping) {
+      mappingReports++;
+      mappingEligible += assessment.source_mapping.eligible;
+      mappingMapped += assessment.source_mapping.mapped;
+      mappingUnmapped += assessment.source_mapping.unmapped;
+    }
+    for (const gate of assessment.gates) {
+      if (gate.status === "passed") passed++;
+      else if (gate.status === "failed") failed++;
+      else notChecked++;
+    }
+  }
+  let assessedDocuments = 0, missingDocuments = 0, errorDocuments = 0;
+  if (result.ok) for (const document of documents) {
+    const assessment = result.assessments?.[document.route];
+    if (assessment === void 0) missingDocuments++;
+    else if (assessment.status === "error") errorDocuments++;
+    else assessedDocuments++;
+  }
+  const collidingFindings = result.ok ? result.findings.filter((finding) => finding.aexeo_origin === "content_preset" && (SITE_GRAPH_RULE_IDS.has(finding.rule_id) || !isLegacyCmsObservableFinding(finding))).length : 0;
+  try {
+    ctx.log?.info?.("aexeo.preset_coverage", { status: result.ok ? "evaluated" : "error", documents: documents.length, assessed_documents: assessedDocuments, missing_assessments: missingDocuments, assessment_errors: errorDocuments, passed, failed, not_checked: notChecked, colliding_findings: collidingFindings, mapping_reports: mappingReports, mapping_eligible: mappingEligible, mapping_mapped: mappingMapped, mapping_unmapped: mappingUnmapped });
+  } catch {
+  }
+  const completeByRoute = new Map(documents.map((document) => [document.route, hasCompleteBody(document)]));
+  let withheld = 0, incompleteBodyWithheld = 0;
+  if (result.ok) for (const finding of result.findings) {
+    if (finding.aexeo_origin === "content_preset") continue;
+    if (!isLegacyCmsObservableFinding(finding)) withheld++;
+    else if (!isLegacyCmsObservableFinding(finding, completeByRoute.get(finding.path) ?? false)) incompleteBodyWithheld++;
+  }
+  try {
+    ctx.log?.info?.("aexeo.cms_finding_coverage", { status: result.ok ? "evaluated" : "error", rendered_findings_withheld: withheld, incomplete_body_findings_withheld: incompleteBodyWithheld });
+  } 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
+]);
+function isSiteGraphFinding(finding) {
+  return finding.aexeo_origin !== "content_preset" && SITE_GRAPH_RULE_IDS.has(finding.rule_id);
+}
+function withCmsSourceLocation(finding, stored) {
+  if (finding.aexeo_cms_location !== void 0) {
+    finding = { ...finding };
+    delete finding.aexeo_cms_location;
+  }
+  const location = finding.aexeo_source_location;
+  if (finding.aexeo_origin !== "content_preset" || !location || !stored) return finding;
+  const blockPath = stored.meta.bodySourcePaths?.[location.block_index];
+  const spanPath = stored.meta.bodySourceSpanPaths?.[location.block_index]?.[location.span_index];
+  const path = blockPath ? [...blockPath, "children", location.span_index, "text"] : spanPath;
+  const text = stored.document.body?.[location.block_index]?.children[location.span_index]?.text;
+  const offset = location.utf16_offset;
+  if (!path || typeof text !== "string" || !Number.isSafeInteger(offset) || offset < 0 || offset > text.length || offset > 0 && offset < text.length && /[\uD800-\uDBFF]/.test(text[offset - 1]) && /[\uDC00-\uDFFF]/.test(text[offset])) return finding;
+  return { ...finding, aexeo_cms_location: { path, utf16_offset: offset } };
+}
+function countCmsLocations(counts, findings) {
+  for (const finding of findings) {
+    if (finding.aexeo_origin !== "content_preset" || finding.aexeo_source_location === void 0) continue;
+    counts.eligible++;
+    if (finding.aexeo_cms_location !== void 0) counts.mapped++;
+  }
+}
+function recordCmsLocationCoverage(ctx, counts) {
+  try {
+    ctx.log?.info?.("aexeo.cms_location_coverage", { ...counts, unmapped: counts.eligible - counts.mapped });
+  } catch {
+  }
+}
+async function handleAfterSaveConfigured(event, ctx, evaluator, suppressionFilter, blockMappings, contentFields, descriptionFields, contentFieldsUnavailable = false) {
+  const prior = (await readAllStoredDocuments(ctx.kv)).filter(
+    (stored2) => stored2.meta.id === event.content.id && stored2.meta.collection === event.content.type
   );
+  let adapted;
+  try {
+    adapted = await adaptContentItemWithContext(
+      event.content,
+      ctx.content,
+      ctx.site?.locale,
+      blockMappings,
+      contentFields,
+      descriptionFields
+    );
+  } catch {
+    try {
+      ctx.log?.info?.("aexeo.adaptation_coverage", { failed: 1 });
+    } catch {
+    }
+    ctx.log?.error?.("Aexeo afterSave adaptation failed");
+    const previous = prior.length === 1 ? prior[0] : void 0;
+    if (previous !== void 0) await markAdaptationUnavailable(ctx, event.content, previous);
+    return;
+  }
   const document = adapted.document;
+  if (contentFieldsUnavailable && document.body !== void 0) document.body_capabilities = [];
+  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 evaluateSafely(evaluator, [document], { collections: [adapted.meta.collection] });
+  recordAssessmentCoverage(ctx, result, [document]);
   if (!result.ok) {
     log?.error?.(`afterSave evaluator failure (${result.reason})`, {
       detail: result.detail
     });
+    if (!await isSuperseded(kv, stored)) {
+      await kv.set(findingsKey(document.route), {
+        route: document.route,
+        findings: [],
+        assessment: { status: "error", reason: result.reason, detail: result.detail }
+      });
+    }
     return;
   }
-  const pageFindings = result.findings.filter(
-    (finding) => finding.scope === "page"
+  const storedGraphFindings = (await readFindings(kv, document.route)).filter(
+    (finding) => isSiteGraphFinding(finding) && isCmsObservableFinding(finding, hasCompleteBody(document))
   );
+  const pageFindings = [
+    ...result.findings.filter(
+      (finding) => finding.scope === "page" && !isSiteGraphFinding(finding) && isCmsObservableFinding(finding, hasCompleteBody(document))
+    ).map((finding) => withCmsSourceLocation(finding, stored)),
+    ...storedGraphFindings
+  ];
   const filtered = suppressionFilter === void 0 ? pageFindings : suppressionFilter.apply(
     {
       route: document.route,
@@ -234,12 +841,51 @@ async function handleAfterSaveConfigured(event, ctx, evaluator, suppressionFilte
     },
     pageFindings
   );
+  if (await isSuperseded(kv, stored)) {
+    log?.info?.(`Aexeo afterSave discarded: ${document.route} changed while evaluating`);
+    return;
+  }
+  const cmsLocationCounts = { eligible: 0, mapped: 0 };
+  countCmsLocations(cmsLocationCounts, filtered);
+  recordCmsLocationCoverage(ctx, cmsLocationCounts);
   await kv.set(findingsKey(document.route), {
     route: document.route,
-    findings: filtered
+    findings: filtered,
+    body_coverage: cmsBodyCoverage(document),
+    ...result.assessments?.[document.route] === void 0 ? {} : { assessment: result.assessments[document.route] }
   });
 }
 var DEFAULT_COLLECTIONS = ["posts", "pages"];
+async function markAdaptationUnavailable(ctx, item, previous) {
+  if (isOlderRevision(item.updatedAt, previous.meta.updatedAt) || await isSuperseded(ctx.kv, previous)) return;
+  const unavailable = {
+    document: { route: previous.document.route, title: previous.document.title },
+    meta: {
+      id: item.id,
+      collection: item.type,
+      slug: item.slug,
+      status: item.status,
+      title: previous.meta.title,
+      publicUrl: null,
+      adaptationFailed: true,
+      ...item.updatedAt === void 0 ? {} : { updatedAt: item.updatedAt }
+    }
+  };
+  if (!await persistDocument(ctx, unavailable) || await isSuperseded(ctx.kv, unavailable)) return;
+  recordContentCoverage(ctx, [unavailable.document]);
+  await ctx.kv.set(findingsKey(unavailable.document.route), {
+    route: unavailable.document.route,
+    findings: [],
+    assessment: { status: "error", reason: "adaptation_failed", detail: "The CMS record could not be adapted." }
+  });
+}
+async function evaluateSafely(evaluator, documents, context) {
+  try {
+    return await evaluator(documents, context);
+  } catch {
+    return { ok: false, reason: "evaluator_exception", detail: "The evaluator failed unexpectedly." };
+  }
+}
 async function evaluateAndPersistAll(ctx, options) {
   const collections = options.collections ?? DEFAULT_COLLECTIONS;
   const suppressionFilter = options.suppressionFilter;
@@ -250,11 +896,15 @@ 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();
+  const adaptationFailures = [];
   for (const collection of collections) {
     let cursor;
+    const seenCursors = /* @__PURE__ */ new Set();
     do {
       try {
         const page = await ctx.content.list(collection, {
@@ -262,19 +912,35 @@ async function evaluateAndPersistAll(ctx, options) {
           ...cursor === void 0 ? {} : { cursor }
         });
         for (const item of page.items) {
-          const adapted = await adaptContentItemWithContext(
-            item,
-            ctx.content,
-            ctx.site?.locale
-          );
-          documents.push(adapted.document);
-          documentRoutes.add(adapted.document.route);
-          adaptedByRoute.set(adapted.document.route, {
-            document: adapted.document,
-            meta: adapted.meta
-          });
+          try {
+            const adapted = await adaptContentItemWithContext(
+              item,
+              ctx.content,
+              ctx.site?.locale,
+              options.blockMappings,
+              options.contentFieldsByCollection?.[collection],
+              options.descriptionFieldsByCollection?.[collection]
+            );
+            if (options.contentFieldsUnavailable && adapted.document.body !== void 0) adapted.document.body_capabilities = [];
+            documents.push(adapted.document);
+            documentCollections.push(adapted.meta.collection);
+            documentRoutes.add(adapted.document.route);
+            adaptedByRoute.set(adapted.document.route, {
+              document: adapted.document,
+              meta: adapted.meta
+            });
+          } catch {
+            adaptationFailures.push({ item, collection });
+            summary.errors.push(`${collection}: content adaptation failed`);
+          }
+        }
+        if (page.hasMore) {
+          if (!page.cursor || seenCursors.has(page.cursor)) throw new Error("incomplete pagination: missing or repeated cursor");
+          seenCursors.add(page.cursor);
+          cursor = page.cursor;
+        } else {
+          cursor = void 0;
         }
-        cursor = page.hasMore ? page.cursor : void 0;
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         summary.errors.push(`${collection}: ${message}`);
@@ -282,66 +948,183 @@ async function evaluateAndPersistAll(ctx, options) {
       }
     } while (cursor !== void 0);
   }
+  const inventoryComplete = summary.errors.length === 0;
   summary.documentsScanned = documents.length;
+  recordContentCoverage(ctx, documents);
+  if (adaptationFailures.length > 0) {
+    try {
+      ctx.log?.info?.("aexeo.adaptation_coverage", { failed: adaptationFailures.length });
+    } catch {
+    }
+    const storedByCollection = /* @__PURE__ */ new Map();
+    for (const stored of storedAtStart) {
+      const byId = storedByCollection.get(stored.meta.collection) ?? /* @__PURE__ */ new Map();
+      const entries = byId.get(stored.meta.id) ?? [];
+      entries.push(stored);
+      byId.set(stored.meta.id, entries);
+      storedByCollection.set(stored.meta.collection, byId);
+    }
+    for (const { item, collection } of adaptationFailures) {
+      for (const stored of storedByCollection.get(collection)?.get(item.id) ?? []) {
+        if (documentRoutes.has(stored.document.route)) continue;
+        await markAdaptationUnavailable(ctx, item, stored);
+      }
+    }
+  }
   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 evaluateSafely(options.evaluator, documents, { collections: documentCollections });
+  recordAssessmentCoverage(ctx, result, documents);
   if (!result.ok) {
     log?.error?.(`aexeo evaluator failure (${result.reason})`, {
       detail: result.detail
     });
     summary.errors.push(`${result.reason}: ${result.detail}`);
+    try {
+      ctx.log?.info?.("aexeo.sitewide_coverage", { status: "evaluation_error" });
+    } catch {
+    }
+    await kv.set(findingsKey("*"), {
+      route: "*",
+      findings: [],
+      assessment: { status: "error", reason: result.reason, detail: result.detail }
+    });
+    for (const [route, stored] of adaptedByRoute) {
+      if (!await isSuperseded(kv, stored)) {
+        await kv.set(findingsKey(route), {
+          route,
+          findings: [],
+          assessment: { status: "error", reason: result.reason, detail: result.detail }
+        });
+      }
+    }
     return summary;
   }
   const findingsByRoute = /* @__PURE__ */ new Map();
+  findingsByRoute.set("*", []);
   for (const route of documentRoutes) {
     findingsByRoute.set(route, []);
   }
+  const completeByRoute = new Map(documents.map((document) => [document.route, hasCompleteBody(document)]));
+  const allBodiesComplete = documents.every(hasCompleteBody);
+  const changed = await refreshInputChanged(kv, collections, adaptedByRoute, storedAtStart);
+  const coverageStatus = !inventoryComplete ? "inventory_incomplete" : changed ? "changed_during_refresh" : !allBodiesComplete ? "body_incomplete" : "complete";
+  const globalCoverageComplete = coverageStatus === "complete";
+  try {
+    ctx.log?.info?.("aexeo.sitewide_coverage", { status: coverageStatus });
+  } catch {
+  }
+  const globalAssessment = globalCoverageComplete ? void 0 : {
+    status: "error",
+    reason: coverageStatus,
+    detail: coverageStatus === "changed_during_refresh" ? "Sitewide and cross-document checks are unavailable because content changed during refresh." : "Sitewide and cross-document checks are unavailable because the CMS input is incomplete."
+  };
+  if (changed && inventoryComplete) {
+    summary.errors.push("Sitewide checks unavailable: content changed during refresh.");
+  } else if (!allBodiesComplete && inventoryComplete) {
+    summary.errors.push("Sitewide checks unavailable: one or more document bodies are incomplete.");
+  }
   for (const finding of result.findings) {
+    if (!globalCoverageComplete && (finding.scope !== "page" || isSiteGraphFinding(finding))) continue;
+    const complete = finding.scope === "page" ? completeByRoute.get(finding.path) ?? false : allBodiesComplete;
+    if (!isCmsObservableFinding(finding, complete)) continue;
     const bucket = finding.scope === "page" ? finding.path : "*";
     const list = findingsByRoute.get(bucket) ?? [];
-    list.push(finding);
+    list.push(withCmsSourceLocation(finding, adaptedByRoute.get(bucket)));
     findingsByRoute.set(bucket, list);
   }
   let totalAfterSuppression = 0;
+  const cmsLocationCounts = { eligible: 0, mapped: 0 };
   for (const [route, findings] of findingsByRoute) {
     const stored = adaptedByRoute.get(route);
+    if (stored !== void 0 && await isSuperseded(kv, stored)) {
+      continue;
+    }
     const context = {
       route,
       ...stored?.meta.collection === void 0 ? {} : { collection: stored.meta.collection },
       ...stored?.meta.status === void 0 ? {} : { status: stored.meta.status }
     };
     const filtered = suppressionFilter === void 0 ? findings : suppressionFilter.apply(context, findings);
-    await kv.set(findingsKey(route), { route, findings: filtered });
+    countCmsLocations(cmsLocationCounts, filtered);
+    await kv.set(findingsKey(route), {
+      route,
+      findings: filtered,
+      ...stored === void 0 ? {} : { body_coverage: cmsBodyCoverage(stored.document) },
+      ...route === "*" && globalAssessment !== void 0 ? { assessment: globalAssessment } : result.assessments?.[route] === void 0 ? {} : { assessment: result.assessments[route] }
+    });
     summary.routesUpdated += 1;
     totalAfterSuppression += filtered.length;
   }
+  recordCmsLocationCoverage(ctx, cmsLocationCounts);
   summary.totalFindings = totalAfterSuppression;
-  if (summary.errors.length === 0) {
-    await removeStaleDocuments(ctx, collections, documentRoutes);
+  if (inventoryComplete && !changed) {
+    await removeStaleDocuments(ctx, collections, documentRoutes, storedAtStart);
   }
   return summary;
 }
+async function refreshInputChanged(kv, collections, evaluated, initial) {
+  const current = await readAllStoredDocuments(kv);
+  const currentByRoute = new Map(current.map((entry) => [entry.document.route, entry]));
+  const initialByRoute = new Map(initial.map((entry) => [entry.document.route, entry]));
+  for (const [route, entry] of evaluated) {
+    if (!sameStoredDocument(entry, currentByRoute.get(route))) return true;
+  }
+  const selected = new Set(collections);
+  for (const entry of current) {
+    const route = entry.document.route;
+    if (!evaluated.has(route) && (entry.meta.collection === "" || selected.has(entry.meta.collection)) && !sameStoredDocument(entry, initialByRoute.get(route))) return true;
+  }
+  return false;
+}
+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)));
+}
+function sameStoredDocument(a, b) {
+  return a != null && b != null && JSON.stringify(a) === JSON.stringify(b);
+}
+async function isSuperseded(kv, evaluated) {
+  return !sameStoredDocument(evaluated, await readStoredDocument(kv, evaluated.document.route));
+}
 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);
@@ -401,6 +1184,23 @@ async function readFindings(kv, route) {
   }
   return stored.findings;
 }
+async function readAssessment(kv, route) {
+  const stored = await kv.get(findingsKey(route));
+  return stored?.assessment;
+}
+
+// src/assessment-display.ts
+function describeGate(gate) {
+  const status = gate.status === "not_checked" ? "not checked" : gate.status;
+  const reason = gate.status === "not_checked" ? `: ${gate.reason ?? "required input unavailable"}` : "";
+  const metrics = Object.entries(gate.measurements ?? {}).map(([key, value]) => `${key.replaceAll("_", " ")}: ${value}`).join(", ");
+  return `${gate.gate_id} ${status}${reason} (${gate.blocking ? "blocking" : "advisory"})${metrics ? ` \u2014 ${metrics}` : ""}`;
+}
+function summarizeGates(gates) {
+  const counts = { passed: 0, failed: 0, not_checked: 0 };
+  for (const gate of gates) counts[gate.status]++;
+  return `${gates.length} configured checks: ${counts.passed} passed, ${counts.failed} failed, ${counts.not_checked} not checked`;
+}
 
 // src/findings-view.ts
 function normalizeInteraction(input) {
@@ -438,6 +1238,10 @@ async function handleRefresh(options) {
     summary = await evaluateAndPersistAll(options.ctx, {
       collections: options.collections,
       evaluator: options.evaluator,
+      blockMappings: options.blockMappings,
+      contentFieldsByCollection: options.contentFieldsByCollection,
+      contentFieldsUnavailable: options.contentFieldsUnavailable,
+      descriptionFieldsByCollection: options.descriptionFieldsByCollection,
       // Always forwarded. See RefreshOptions.suppressionFilter.
       suppressionFilter: options.suppressionFilter
     });
@@ -473,21 +1277,38 @@ async function handleRefresh(options) {
     }
   };
 }
-async function readAllFindings(kv) {
-  const entries = await kv.list(
-    "findings:"
-  );
-  const out = [];
+async function readFindingsSnapshot(kv) {
+  const entries = await kv.list("findings:");
+  const sitewideAssessment = entries.find((entry) => entry.key === "findings:*")?.value?.assessment;
+  const incomplete = sitewideAssessment?.status === "error";
+  const findings = [];
+  const routes = /* @__PURE__ */ new Set();
+  let failedAssessments = 0;
+  let uncheckedGates = 0;
+  let incompleteBodies = 0;
+  let unknownBodies = 0;
+  let missingAssessments = 0;
   for (const entry of entries) {
-    if (entry.value === null) {
-      continue;
-    }
+    if (entry.value === null) continue;
     const route = entry.key.replace(/^findings:/, "");
+    if (route !== "*") {
+      routes.add(route);
+      if (entry.value.body_coverage === void 0) unknownBodies++;
+      else if (entry.value.body_coverage !== "complete") incompleteBodies++;
+      const assessment = entry.value.assessment;
+      if (assessment === void 0) missingAssessments++;
+      if (assessment?.status === "error") failedAssessments++;
+      if (assessment?.status === "evaluated") {
+        uncheckedGates += assessment.gates.filter((gate) => gate.status === "not_checked").length;
+      }
+    }
     for (const finding of entry.value.findings) {
-      out.push({ ...finding, document_route: route });
+      if (!isCmsObservableFinding(finding, route === "*" || entry.value.body_coverage === "complete") || incomplete && isSiteGraphFinding(finding)) continue;
+      findings.push({ ...finding, document_route: route });
+      if (route === "*") routes.add(route);
     }
   }
-  return out;
+  return { findings, documentRoutes: [...routes].sort(), sitewideAssessment, failedAssessments, uncheckedGates, incompleteBodies, unknownBodies, missingAssessments };
 }
 function severityFirst(a, b) {
   const rank = (severity) => severity === "error" ? 0 : 1;
@@ -505,7 +1326,7 @@ function uniqueRoutes(rows) {
   return [...routes].sort();
 }
 async function renderFindingsPage(kv, tuning) {
-  const findings = await readAllFindings(kv);
+  const { findings, documentRoutes, sitewideAssessment, failedAssessments, uncheckedGates, incompleteBodies, unknownBodies, missingAssessments } = await readFindingsSnapshot(kv);
   const errors = findings.filter((finding) => finding.severity === "error");
   const warnings = findings.filter(
     (finding) => finding.severity === "warning"
@@ -516,8 +1337,13 @@ async function renderFindingsPage(kv, tuning) {
     { 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.`
+      text: findings.length === 0 ? documentRoutes.length === 0 ? "No CMS document results available \u2014 click Refresh to evaluate records." : "No findings reported for the available CMS checks. Inspect assessments for unchecked or failed evaluations." : `${findings.length} findings across ${routes.length} routes \u2014 ${errors.length} errors, ${warnings.length} warnings.`
     },
+    { type: "context", text: "Rendered page markup, semantic sections, generated metadata, duplicate pages and sitewide links are not checked here. Audit the built site for page-level and link findings." },
+    ...incompleteBodies || unknownBodies ? [{ type: "context", text: `${incompleteBodies} document bodies were incomplete or unavailable; coverage is unknown for ${unknownBodies} older or failed evaluations. Inspect individual documents.` }] : [],
+    ...missingAssessments ? [{ type: "context", text: `No content preset assessment was recorded for ${missingAssessments} document(s); absence of findings is not an editorial quality assessment.` }] : [],
+    ...failedAssessments || uncheckedGates ? [{ type: "context", text: `${failedAssessments} document evaluations failed; ${uncheckedGates} preset checks were not checked. Inspect individual documents for details.` }] : [],
+    ...sitewideAssessment?.status === "error" ? [{ type: "context", text: `Sitewide checks unavailable: ${sitewideAssessment.reason}. ${sitewideAssessment.detail}` }] : [],
     { type: "divider" },
     {
       type: "actions",
@@ -542,10 +1368,10 @@ async function renderFindingsPage(kv, tuning) {
     },
     sorted.length === 0 ? {
       type: "context",
-      text: tuning.emptyFindingsText
+      text: documentRoutes.length === 0 ? tuning.emptyFindingsText : "Select a document to inspect its assessment."
     } : findingsTable(sorted)
   ];
-  if (routes.length > 0) {
+  if (documentRoutes.length > 0) {
     blocks.push({
       type: "form",
       fields: [
@@ -553,7 +1379,7 @@ async function renderFindingsPage(kv, tuning) {
           type: "select",
           action_id: "route_picker",
           label: "Document to inspect",
-          options: routes.map((route) => ({ label: route, value: route }))
+          options: documentRoutes.map((route) => ({ label: route, value: route }))
         }
       ],
       submit: { label: "View document SEO", action_id: "view_document" }
@@ -578,55 +1404,13 @@ function findingsTable(rows) {
     }))
   };
 }
-async function renderScoreWidget(kv, tuning) {
-  const documents = await readAllDocuments(kv);
-  if (documents.length === 0) {
-    return {
-      blocks: [
-        { type: "header", text: "SEO score" },
-        {
-          type: "context",
-          text: tuning.emptyScoreText
-        }
-      ]
-    };
-  }
-  const score = await tuning.score(documents, kv);
-  const blocks = [
-    {
-      type: "stats",
-      items: [
-        { label: "Overall", value: `${score.overall_score}` },
-        { label: "Citation", value: `${score.citation_readiness_score}` },
-        {
-          label: tuning.truthLabel(score),
-          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 };
-}
-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 renderScoreWidget(_kv, _tuning, _log) {
+  return {
+    blocks: [
+      { type: "header", text: "SEO score unavailable" },
+      { type: "context", text: "CMS records do not include the rendered site. Run an Aexeo site audit on the built site to assess SEO and page-level signals." }
+    ]
+  };
 }
 async function renderDocumentPanel(kv, route) {
   if (route === void 0) {
@@ -640,7 +1424,11 @@ async function renderDocumentPanel(kv, route) {
       ]
     };
   }
-  const findings = await readFindings(kv, route);
+  const incomplete = (await readAssessment(kv, "*"))?.status === "error";
+  const record = await kv.get(findingsKey(route));
+  const findings = (record?.findings ?? []).filter((finding) => isCmsObservableFinding(finding, record?.body_coverage === "complete") && (!incomplete || !isSiteGraphFinding(finding)));
+  const assessment = record?.assessment;
+  const bodyNotice = record && assessment?.status !== "error" ? cmsBodyCoverageNotice(record.body_coverage) : void 0;
   const errors = findings.filter((finding) => finding.severity === "error");
   const warnings = findings.filter(
     (finding) => finding.severity === "warning"
@@ -651,8 +1439,14 @@ async function renderDocumentPanel(kv, route) {
       { 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.`
+        text: !record ? `No evaluation is available for ${route}. Save the document or refresh to evaluate it.` : assessment?.status === "error" ? `Evaluation failed for ${route}; findings are unavailable for this revision.` : findings.length === 0 ? `No findings for ${route} from the available CMS checks.` : `${findings.length} findings \u2014 ${errors.length} errors, ${warnings.length} warnings.`
       },
+      { type: "context", text: "Rendered page markup, semantic sections, generated metadata, duplicate pages and sitewide links are not checked here. Audit the built site for page-level and link findings." },
+      ...bodyNotice ? [{ type: "context", text: bodyNotice }] : [],
+      ...incomplete ? [{ type: "context", text: "Sitewide and cross-document checks are unavailable; refresh after resolving the CMS input error." }] : [],
+      ...record && assessment === void 0 ? [{ type: "context", text: "No content preset assessment was recorded for this document; absence of findings is not an editorial quality assessment." }] : [],
+      ...assessment?.status === "error" ? [{ type: "context", text: `Evaluation failed: ${assessment.reason}. Findings are unavailable for this revision.` }] : [],
+      ...assessment?.status === "evaluated" ? [{ type: "context", text: `Content preset: ${assessment.preset}. ${summarizeGates(assessment.gates)}. Results cover only these configured checks.` }, ...assessment.gates.map((gate) => ({ type: "context", text: describeGate(gate) }))] : [],
       ...findings.length === 0 ? [] : [{ type: "divider" }, documentFindingsTable(sorted)]
     ]
   };
@@ -664,16 +1458,13 @@ function documentFindingsTable(findings) {
       { key: "rule", label: "Rule", format: "code" },
       { key: "severity", label: "Severity", format: "badge" },
       { key: "message", label: "Message" },
-      { key: "block", label: "Block", format: "code" }
+      { key: "block", label: "Location", 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}`
+      block: finding.aexeo_cms_location ? `CMS path ${JSON.stringify(finding.aexeo_cms_location.path)}, UTF-16 offset ${finding.aexeo_cms_location.utf16_offset}` : finding.aexeo_source_location ? `Projected body: block ${finding.aexeo_source_location.block_index + 1}, span ${finding.aexeo_source_location.span_index + 1}, UTF-16 offset ${finding.aexeo_source_location.utf16_offset}` : finding.aexeo_origin === "content_preset" ? "Projected location unavailable" : `Reported line ${finding.line}`
     }))
   };
 }
@@ -695,11 +1486,71 @@ __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,
+  projectContentInput: () => projectContentInput,
+  projectLinkDestinations: () => projectLinkDestinations,
   scoreIntelligence: () => scoreIntelligence,
   validateFactsManifest: () => validateFactsManifest
 });
+function evaluateContent(document_json, preset_name, sources_json, evidence_json, extensions_json, link_observations_json) {
+  let deferred8_0;
+  let deferred8_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;
+    var ptr4 = isLikeNone(extensions_json) ? 0 : passStringToWasm0(extensions_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len4 = WASM_VECTOR_LEN;
+    var ptr5 = isLikeNone(link_observations_json) ? 0 : passStringToWasm0(link_observations_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len5 = WASM_VECTOR_LEN;
+    const ret = wasm.evaluateContent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
+    var ptr7 = ret[0];
+    var len7 = ret[1];
+    if (ret[3]) {
+      ptr7 = 0;
+      len7 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred8_0 = ptr7;
+    deferred8_1 = len7;
+    return getStringFromWasm0(ptr7, len7);
+  } finally {
+    wasm.__wbindgen_free(deferred8_0, deferred8_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;
@@ -744,6 +1595,50 @@ function generateFactsPrompt(documents_json) {
     wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
   }
 }
+function projectContentInput(document_json, evidence_json) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passStringToWasm0(document_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(evidence_json) ? 0 : passStringToWasm0(evidence_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.projectContentInput(ptr0, len0, ptr1, len1);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function projectLinkDestinations(document_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(document_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.projectLinkDestinations(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
 function scoreIntelligence(documents_json, manifest_json) {
   let deferred4_0;
   let deferred4_1;
@@ -969,6 +1864,18 @@ async function validateFactsManifest2(manifestJson, documentsJson) {
   await ensureInitialized();
   return validateFactsManifest(manifestJson, documentsJson);
 }
+async function evaluateContent2(documentJson, presetName, sourcesJson, evidenceJson, extensionsJson, linkObservationsJson) {
+  await ensureInitialized();
+  return evaluateContent(documentJson, presetName, sourcesJson, evidenceJson, extensionsJson, linkObservationsJson);
+}
+async function projectLinkDestinations2(documentJson) {
+  await ensureInitialized();
+  return projectLinkDestinations(documentJson);
+}
+async function projectContentInput2(documentJson, evidenceJson) {
+  await ensureInitialized();
+  return projectContentInput(documentJson, evidenceJson);
+}
 
 // src/data-route.ts
 async function handleDataRoute(ctx, options) {
@@ -977,6 +1884,9 @@ async function handleDataRoute(ctx, options) {
     summary = await evaluateAndPersistAll(ctx, {
       collections: options.collections,
       evaluator: options.evaluator,
+      blockMappings: options.blockMappings,
+      contentFieldsByCollection: options.contentFieldsByCollection,
+      descriptionFieldsByCollection: options.descriptionFieldsByCollection,
       ...options.suppressionFilter === void 0 ? {} : { suppressionFilter: options.suppressionFilter }
     });
     await persistManifestStateFindings(ctx);
@@ -995,20 +1905,22 @@ async function buildFindingsPayload(ctx) {
   );
   const findings = [];
   const sitewide = [];
+  const sitewideAssessment = entries.find((entry) => entry.key === "findings:*")?.value?.assessment;
   const perRoute = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (entry.value === null) continue;
     const route = entry.key.replace(/^findings:/, "");
     if (route === "*") {
-      sitewide.push(...entry.value.findings);
+      sitewide.push(...entry.value.findings.filter((finding) => isCmsObservableFinding(finding) && !(sitewideAssessment?.status === "error" && isSiteGraphFinding(finding))));
       continue;
     }
     let bucket = perRoute.get(route);
     if (bucket === void 0) {
-      bucket = { findings: [], errors: 0, warnings: 0 };
+      bucket = { findings: [], errors: 0, warnings: 0, ...entry.value.body_coverage === void 0 ? {} : { body_coverage: entry.value.body_coverage }, ...entry.value.assessment === void 0 ? {} : { assessment: entry.value.assessment } };
       perRoute.set(route, bucket);
     }
     for (const finding of entry.value.findings) {
+      if (!isCmsObservableFinding(finding, entry.value.body_coverage === "complete") || sitewideAssessment?.status === "error" && isSiteGraphFinding(finding)) continue;
       bucket.findings.push(finding);
       if (finding.severity === "error") bucket.errors += 1;
       else if (finding.severity === "warning") bucket.warnings += 1;
@@ -1029,7 +1941,9 @@ async function buildFindingsPayload(ctx) {
       publishedUrl: stored2?.meta.publicUrl ?? "",
       findingCount: bucket.findings.length,
       errorCount: bucket.errors,
-      warningCount: bucket.warnings
+      warningCount: bucket.warnings,
+      ...bucket.assessment === void 0 ? {} : { assessment: bucket.assessment },
+      ...bucket.body_coverage === void 0 ? {} : { body_coverage: bucket.body_coverage }
     });
   }
   routes.sort((a, b) => b.errorCount - a.errorCount || a.route.localeCompare(b.route));
@@ -1051,7 +1965,8 @@ async function buildFindingsPayload(ctx) {
       documentsIndexed: documents.size
     },
     layerBreakdown,
-    sitewideFindings: sitewide
+    sitewideFindings: sitewide,
+    ...sitewideAssessment === void 0 ? {} : { sitewideAssessment }
   };
 }
 function computeLayerBreakdown(findings) {
@@ -1245,12 +2160,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",
@@ -1307,7 +2226,7 @@ async function checkWikipedia(input, fetcher) {
       return notFound2("wikipedia");
     }
     const title = String(titles[0]);
-    if (!fuzzyMatch(title, input.name)) {
+    if (!namesEntity(title, input)) {
       return notFound2("wikipedia");
     }
     const articleUrl = String(urls[0] ?? "");
@@ -1337,7 +2256,7 @@ async function checkWikidata(input, fetcher) {
       return notFound2("wikidata");
     }
     const label = top.label ?? input.name;
-    if (!fuzzyMatch(label, input.name)) {
+    if (!namesEntity(label, input)) {
       return notFound2("wikidata");
     }
     return found("wikidata", {
@@ -1426,9 +2345,27 @@ 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 {
@@ -1455,6 +2392,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);
@@ -1500,10 +2447,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, "-");
@@ -1542,6 +2524,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) {
@@ -1664,8 +2647,150 @@ function globToMatcher(pattern) {
   return (route) => re.test(route);
 }
 
-// src/version.ts
-var PACKAGE_VERSION = "0.8.19";
+// src/content.ts
+async function projectContentInput3(document, evidenceSources) {
+  return JSON.parse(await projectContentInput2(JSON.stringify(document), evidenceSources === void 0 ? void 0 : JSON.stringify(evidenceSources)));
+}
+async function projectLinkDestinations3(document) {
+  return JSON.parse(await projectLinkDestinations2(JSON.stringify(document)));
+}
+async function evaluateContent3(document, preset, sources = {}, evidenceSources, onTelemetry, externalResults, linkObservations) {
+  const started = onTelemetry ? performance.now() : 0;
+  const documentJson = JSON.stringify(document);
+  const sourcesJson = JSON.stringify(sources);
+  const result = linkObservations !== void 0 ? await evaluateContent2(documentJson, preset, sourcesJson, evidenceSources === void 0 ? void 0 : JSON.stringify(evidenceSources), externalResults === void 0 ? void 0 : JSON.stringify(externalResults), JSON.stringify(linkObservations)) : externalResults !== void 0 ? await evaluateContent2(documentJson, preset, sourcesJson, evidenceSources === void 0 ? void 0 : JSON.stringify(evidenceSources), JSON.stringify(externalResults)) : 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 };
+    if (report.source_mapping) {
+      event.source_locations_eligible = report.source_mapping.eligible;
+      event.source_locations_unmapped = report.source_mapping.unmapped;
+    }
+    for (const gate of report.gates) {
+      if (gate.required_capability === "link_reachability" && gate.measurements) {
+        const { checked_destinations, not_found_destinations, unchecked_destinations } = gate.measurements;
+        if (checked_destinations !== void 0 && not_found_destinations !== void 0 && unchecked_destinations !== void 0) {
+          event.link_reachability ??= { checked: 0, not_found: 0, unchecked: 0 };
+          event.link_reachability.checked += checked_destinations;
+          event.link_reachability.not_found += not_found_destinations;
+          event.link_reachability.unchecked += unchecked_destinations;
+        }
+      }
+      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, provider, project, onProviderTelemetry, linkProvider, projectLinks, onLinkProviderTelemetry) {
+  if (!preset) return base;
+  return async (documents, context) => {
+    const result = await base(documents, context);
+    if (!result.ok) return result;
+    const findings = [...result.findings];
+    const assessments = { ...result.assessments };
+    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}`);
+        let report = preset.evidenceSources === void 0 ? await evaluate(document, name, preset.sources) : await evaluate(document, name, preset.sources, preset.evidenceSources);
+        let externalResults;
+        let externalFailure = false;
+        if (provider !== void 0 && report.gates.some((gate) => gate.required_capability === "extension")) {
+          const started = onProviderTelemetry ? performance.now() : 0;
+          let status = "error";
+          try {
+            if (!project) throw new Error("content gate projection is unavailable");
+            externalResults = await provider({ input: await project(document, preset.evidenceSources), preset: name, collection });
+            if (!Array.isArray(externalResults)) throw new Error("external gate provider must return an array");
+            report = await evaluate(document, name, preset.sources, preset.evidenceSources, void 0, externalResults);
+            status = "success";
+          } catch {
+            externalResults = void 0;
+            externalFailure = true;
+          } finally {
+            if (onProviderTelemetry) {
+              try {
+                onProviderTelemetry({ duration_ms: performance.now() - started, status });
+              } catch {
+              }
+            }
+          }
+        }
+        if (linkProvider && report.gates.some((gate) => gate.required_capability === "link_reachability")) {
+          const started = onLinkProviderTelemetry ? performance.now() : 0;
+          let status = "error";
+          try {
+            const projection = projectLinks ? await projectLinks(document) : null;
+            if (projection === null) {
+              status = "unavailable";
+            } else {
+              const observations = await linkProvider({ destinations: [...projection.destinations], preset: name, collection });
+              const valid = /* @__PURE__ */ new Set(["reachable", "not_found", "not_checked", "not_applicable"]);
+              if (!Array.isArray(observations) || observations.length !== projection.destinations.length || observations.some((value) => !valid.has(value))) throw new Error("invalid link observations");
+              report = await evaluate(
+                document,
+                name,
+                preset.sources,
+                preset.evidenceSources,
+                void 0,
+                externalResults,
+                { ...projection, observations }
+              );
+              status = "success";
+            }
+          } catch {
+          } finally {
+            if (onLinkProviderTelemetry) {
+              try {
+                onLinkProviderTelemetry({ duration_ms: performance.now() - started, status });
+              } catch {
+              }
+            }
+          }
+        }
+        if (externalFailure) {
+          report = { ...report, gates: report.gates.map((gate) => gate.required_capability === "extension" && gate.status === "not_checked" ? { ...gate, reason: "external gate provider failed" } : gate) };
+        }
+        assessments[document.route] = {
+          status: "evaluated",
+          preset: name,
+          ...report.source_mapping === void 0 ? {} : { source_mapping: report.source_mapping },
+          gates: report.gates.map(({ gate_id, status, blocking, scope, required_capability, reason, measurements }) => ({ gate_id, status, blocking, scope, required_capability, reason, ...measurements === void 0 ? {} : { measurements } }))
+        };
+        const locations = new Map((report.source_locations ?? []).map((location) => [
+          `${location.gate_id}:${location.finding_index}`,
+          location
+        ]));
+        for (const gate of report.gates) findings.push(...gate.findings.map((finding, index2) => {
+          const location = locations.get(`${gate.gate_id}:${index2}`);
+          return {
+            ...finding,
+            aexeo_origin: "content_preset",
+            ...location === void 0 ? {} : { aexeo_source_location: { block_index: location.block_index, span_index: location.span_index, utf16_offset: location.utf16_offset } }
+          };
+        }));
+      }
+      return { ok: true, findings, assessments };
+    } catch (error) {
+      return { ok: false, reason: "content_preset_error", detail: error instanceof Error ? error.message : String(error) };
+    }
+  };
+}
 
 // src/configured.ts
 import { definePlugin } from "emdash";
@@ -1724,17 +2849,22 @@ var inProcessEvaluator = async (documents) => {
     return { ok: false, reason: "wasm_error", detail };
   }
 };
-function createPlugin(options = {}) {
+function createPlugin(options = {}, runtime = {}) {
   const collections = resolveCollections(
     options.collections,
     options.includeCollections,
     options.excludeCollections
   );
   const suppressionFilter = compileSuppressions(options.suppressions);
+  const evaluator = withContentPreset(inProcessEvaluator, options.contentPreset, evaluateContent3, runtime.externalGates, projectContentInput3, runtime.onExternalGateTelemetry, runtime.linkObservations, projectLinkDestinations3, runtime.onLinkProviderTelemetry);
   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
@@ -1742,16 +2872,27 @@ function createPlugin(options = {}) {
       "content:afterSave": (event, ctx) => handleAfterSaveConfigured(
         event,
         ctx,
-        inProcessEvaluator,
-        suppressionFilter
-      )
+        evaluator,
+        suppressionFilter,
+        options.blockMappings,
+        options.contentFieldsByCollection?.[event.content.type],
+        options.descriptionFieldsByCollection?.[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, suppressionFilter)
+        permission: "plugins:read",
+        handler: (ctx) => handleAdminRoute(ctx, collections, suppressionFilter, evaluator, options.blockMappings, options.contentFieldsByCollection, options.descriptionFieldsByCollection)
       },
       // JSON data endpoint for the React adminEntry. Two routes:
       //   POST /_emdash/api/plugins/aexeo-emdash/data    — read current findings
@@ -1761,19 +2902,27 @@ 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,
+          descriptionFieldsByCollection: options.descriptionFieldsByCollection
         })).payload
       },
       refresh: {
+        permission: "plugins:manage",
         handler: (ctx) => handleDataRoute(ctx, {
           collections,
-          evaluator: inProcessEvaluator,
+          evaluator,
           refresh: true,
-          suppressionFilter
+          suppressionFilter,
+          blockMappings: options.blockMappings,
+          contentFieldsByCollection: options.contentFieldsByCollection,
+          descriptionFieldsByCollection: options.descriptionFieldsByCollection
         })
       },
       // /facts route serves the truth-manifest authoring UI. It
@@ -1781,6 +2930,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
@@ -1790,6 +2940,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)
       }
     },
@@ -1821,6 +2972,7 @@ function createPlugin(options = {}) {
   });
 }
 var configured_default = createPlugin;
+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.",
@@ -1828,7 +2980,7 @@ var adminViewTuning = {
   score: async (documents, kv) => scoreLocally(documents, await readStoredFacts(kv)),
   truthLabel: formatTruthLabel
 };
-async function handleAdminRoute(ctx, collections, suppressionFilter) {
+async function handleAdminRoute(ctx, collections, suppressionFilter, evaluator, blockMappings, contentFieldsByCollection, descriptionFieldsByCollection) {
   const body = normalizeInteraction(ctx.input);
   if (body.type === "page_load") {
     return handlePageLoad(ctx, body.page);
@@ -1838,12 +2990,29 @@ async function handleAdminRoute(ctx, collections, suppressionFilter) {
       return renderDocumentPanel(ctx.kv, body.value);
     }
     if (body.action_id === "refresh_findings") {
+      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: inProcessEvaluator,
+        evaluator,
         suppressionFilter,
-        tuning: adminViewTuning
+        tuning: adminViewTuning,
+        blockMappings,
+        contentFieldsByCollection,
+        descriptionFieldsByCollection
       });
     }
     if (body.action_id.startsWith("filter:")) {
@@ -1868,7 +3037,7 @@ async function handlePageLoad(ctx, page) {
     return renderFindingsPage(ctx.kv, adminViewTuning);
   }
   if (normalized === "widget:aexeo-score") {
-    return renderScoreWidget(ctx.kv, adminViewTuning);
+    return renderScoreWidget(ctx.kv, adminViewTuning, ctx.log);
   }
   if (normalized === "document") {
     return renderDocumentPanel(ctx.kv);