@aeptus/aexeo-emdash 0.9.0 → 0.9.1

package/dist/configured.js

@@ -4,8 +4,30 @@ 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, blockMappings, contentFields) {
+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, {
@@ -13,7 +35,8 @@ async function adaptContentItemWithContext(content, contentApi, defaultLocale, b
     publicUrl,
     ...defaultLocale === void 0 ? {} : { defaultLocale },
     ...blockMappings === void 0 ? {} : { blockMappings },
-    ...contentFields === void 0 ? {} : { contentFields }
+    ...contentFields === void 0 ? {} : { contentFields },
+    ...descriptionFields === void 0 ? {} : { descriptionFields }
   });
   const translationSet = await contentApi.getTranslations(
     content.type,
@@ -38,14 +61,32 @@ async function adaptContentItemWithContext(content, contentApi, defaultLocale, b
   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) {
@@ -60,6 +101,8 @@ function adaptContentItem(content, options = {}) {
     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: {
@@ -69,6 +112,8 @@ function adaptContentItem(content, options = {}) {
       status: content.status,
       title,
       publicUrl: options.publicUrl ?? null,
+      ...bodySourcePaths === void 0 ? {} : { bodySourcePaths },
+      ...bodySourceSpanPaths === void 0 ? {} : { bodySourceSpanPaths },
       ...content.updatedAt === void 0 ? {} : { updatedAt: content.updatedAt }
     }
   };
@@ -88,6 +133,100 @@ function routeFromPublicUrl(publicUrl) {
 function stringOrEmpty(value) {
   return typeof value === "string" ? value : "";
 }
+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"];
@@ -96,10 +235,17 @@ function extractSelectedContent(data, fields, mappings) {
   let observed = false;
   for (const field of fields) {
     const value = data[field];
-    if (value === void 0 || value === null) continue;
+    if (value === void 0) {
+      capabilities = [];
+      continue;
+    }
     observed = true;
+    if (value === null) continue;
     const part = extractFirstPortableText({ content: value }, mappings);
-    if (part === null) return { blocks, capabilities: [] };
+    if (part === null) {
+      capabilities = [];
+      continue;
+    }
     blocks.push(...part.blocks);
     capabilities = capabilities.filter((capability) => part.capabilities === void 0 || part.capabilities.includes(capability));
   }
@@ -110,9 +256,14 @@ function extractPortableText(data, mappings) {
   const result = extractFirstPortableText(data, mappings);
   if (result === null) return null;
   const candidates = Object.entries(data).filter(
-    ([field, value]) => isPortableTextArray(value) || isEmdashBlocksArray(value, field) || (field === "body" || field === "content") && typeof value === "string" && value.trim().length > 0
+    ([field, value]) => isPortableTextArray(value) || isMixedPortableTextArray(value) || isEmdashBlocksArray(value, field) || (field === "body" || field === "content") && typeof value === "string" && value.trim().length > 0
   );
-  return candidates.length > 1 ? { blocks: result.blocks, capabilities: [] } : result;
+  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;
@@ -120,7 +271,8 @@ function extractFirstPortableText(data, mappings) {
     const value = data[slug];
     if (Array.isArray(value) && value.length === 0 || typeof value === "string" && value.trim().length === 0) foundEmptyBody = true;
     if (isPortableTextArray(value)) return { blocks: value };
-    if (isEmdashBlocksArray(value, slug)) return mapCustomBlocks(value, mappings);
+    if (isMixedPortableTextArray(value)) return mapMixedPortableText(value, mappings);
+    if (isEmdashBlocksArray(value, slug)) return mapMixedPortableText(value, mappings);
     if (typeof value === "string" && value.trim().length > 0) {
       return { blocks: [portableTextBlock(value.trim(), `${slug}-text`)], capabilities: ["text"] };
     }
@@ -128,32 +280,184 @@ function extractFirstPortableText(data, mappings) {
   const blocks = data["blocks"];
   if (Array.isArray(blocks) && blocks.length === 0) foundEmptyBody = true;
   if (isPortableTextArray(blocks)) return { blocks };
-  if (isEmdashBlocksArray(blocks, "blocks")) return mapCustomBlocks(blocks, mappings);
+  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 { blocks: value };
-    if (isEmdashBlocksArray(value, field)) return mapCustomBlocks(value, mappings);
+    if (isMixedPortableTextArray(value)) return mapMixedPortableText(value, mappings);
+    if (isEmdashBlocksArray(value, field)) return mapMixedPortableText(value, mappings);
   }
   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) {
+function mapCustomBlocks(blocks, mappings, depth = 0) {
+  if (depth > 8) return { blocks: [], capabilities: [] };
   const unavailable = () => ({ blocks: blocksToPortableText(blocks), capabilities: [] });
   const result = [];
-  const mapFields = (record, fields, depth) => {
-    if (depth > 8 || fields.length === 0) return false;
+  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;
@@ -165,8 +469,16 @@ function mapCustomBlocks(blocks, mappings) {
         continue;
       }
       if (entry.kind === "richText") {
-        if (!Array.isArray(value) || value.length > 0 && !isPortableTextArray(value)) return false;
-        result.push(...value);
+        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" });
@@ -181,7 +493,7 @@ function mapCustomBlocks(blocks, mappings) {
       } else if (entry.kind === "repeat") {
         if (!Array.isArray(value) || !Array.isArray(entry.fields)) return false;
         for (const item of value) {
-          if (!isRecord(item) || !mapFields(item, entry.fields, depth + 1)) return false;
+          if (!isRecord(item) || !mapFields(item, entry.fields, depth2 + 1)) return false;
         }
       } else {
         return false;
@@ -190,10 +502,20 @@ function mapCustomBlocks(blocks, mappings) {
     return true;
   };
   for (const block of blocks) {
-    const fields = mappings?.[String(block["_type"])];
-    if (!Array.isArray(fields) || !mapFields(block, fields, 0)) return unavailable();
-  }
-  return { blocks: result };
+    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 = [];
@@ -207,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",
@@ -279,12 +630,13 @@ function isRecord(value) {
 }
 
 // src/version.ts
-var PACKAGE_VERSION = "0.9.0";
+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",
@@ -292,6 +644,12 @@ var PLUGIN_SETTINGS_SCHEMA = {
     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)",
@@ -307,14 +665,54 @@ var PLUGIN_SETTINGS_SCHEMA = {
 function recordContentCoverage(ctx, documents) {
   const counts = { documents: documents.length, complete: 0, partial: 0, unavailable: 0 };
   for (const document of documents) {
-    if (document.body === void 0 || document.body_capabilities?.length === 0) counts.unavailable++;
-    else if (document.body_capabilities === void 0 || ["text", "headings", "paragraphs", "links"].every(
-      (capability) => document.body_capabilities?.includes(capability)
-    )) counts.complete++;
-    else counts.partial++;
+    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 {
   }
 }
@@ -347,15 +745,63 @@ var SITE_GRAPH_RULE_IDS = /* @__PURE__ */ new Set([
   "CNT005"
   // visible text duplicated on another route
 ]);
-async function handleAfterSaveConfigured(event, ctx, evaluator, suppressionFilter, blockMappings, contentFields) {
-  const adapted = await adaptContentItemWithContext(
-    event.content,
-    ctx.content,
-    ctx.site?.locale,
-    blockMappings,
-    contentFields
+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 };
@@ -363,20 +809,28 @@ async function handleAfterSaveConfigured(event, ctx, evaluator, suppressionFilte
     log?.info?.(`Aexeo afterSave skipped: ${document.route} has a newer save`);
     return;
   }
-  const result = await evaluator([document], { collections: [adapted.meta.collection] });
+  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 storedGraphFindings = (await readFindings(kv, document.route)).filter(
-    (finding) => SITE_GRAPH_RULE_IDS.has(finding.rule_id)
+    (finding) => isSiteGraphFinding(finding) && isCmsObservableFinding(finding, hasCompleteBody(document))
   );
   const pageFindings = [
     ...result.findings.filter(
-      (finding) => finding.scope === "page" && !SITE_GRAPH_RULE_IDS.has(finding.rule_id)
-    ),
+      (finding) => finding.scope === "page" && !isSiteGraphFinding(finding) && isCmsObservableFinding(finding, hasCompleteBody(document))
+    ).map((finding) => withCmsSourceLocation(finding, stored)),
     ...storedGraphFindings
   ];
   const filtered = suppressionFilter === void 0 ? pageFindings : suppressionFilter.apply(
@@ -387,16 +841,51 @@ async function handleAfterSaveConfigured(event, ctx, evaluator, suppressionFilte
     },
     pageFindings
   );
-  if (await isSuperseded(kv, document.route, adapted.meta.updatedAt)) {
+  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;
@@ -412,8 +901,10 @@ async function evaluateAndPersistAll(ctx, options) {
   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, {
@@ -421,22 +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,
-            options.blockMappings,
-            options.contentFieldsByCollection?.[collection]
-          );
-          documents.push(adapted.document);
-          documentCollections.push(adapted.meta.collection);
-          documentRoutes.add(adapted.document.route);
-          adaptedByRoute.set(adapted.document.route, {
-            document: adapted.document,
-            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}`);
@@ -444,36 +948,100 @@ 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()) {
     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, { collections: documentCollections });
+  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, route, stored.meta.updatedAt)) {
+    if (stored !== void 0 && await isSuperseded(kv, stored)) {
       continue;
     }
     const context = {
@@ -482,16 +1050,37 @@ async function evaluateAndPersistAll(ctx, options) {
       ...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) {
+  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);
@@ -499,9 +1088,11 @@ function isOlderRevision(revision, other) {
 async function readStoredDocument(kv, route) {
   return toStoredDocument(await kv.get(documentKey(route)));
 }
-async function isSuperseded(kv, route, revision) {
-  const current = await readStoredDocument(kv, route);
-  return current === null || isOlderRevision(revision, current.meta.updatedAt);
+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;
@@ -593,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) {
@@ -632,6 +1240,8 @@ async function handleRefresh(options) {
       evaluator: options.evaluator,
       blockMappings: options.blockMappings,
       contentFieldsByCollection: options.contentFieldsByCollection,
+      contentFieldsUnavailable: options.contentFieldsUnavailable,
+      descriptionFieldsByCollection: options.descriptionFieldsByCollection,
       // Always forwarded. See RefreshOptions.suppressionFilter.
       suppressionFilter: options.suppressionFilter
     });
@@ -667,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;
@@ -699,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"
@@ -710,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",
@@ -736,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: [
@@ -747,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" }
@@ -772,75 +1404,13 @@ function findingsTable(rows) {
     }))
   };
 }
-async function renderScoreWidget(kv, tuning, log) {
-  const documents = await readAllDocuments(kv);
-  if (documents.length === 0) {
-    return {
-      blocks: [
-        { type: "header", text: "SEO score" },
-        {
-          type: "context",
-          text: tuning.emptyScoreText
-        }
-      ]
-    };
-  }
-  let score;
-  try {
-    score = await tuning.score(documents, kv);
-  } catch (error) {
-    log?.error("Aexeo score widget failed to initialize", { error });
-    return {
-      blocks: [
-        { type: "banner", title: "SEO score is temporarily unavailable", variant: "alert" },
-        { type: "context", text: "The authoring interface remains available. Retry after the evaluator runtime has been checked." }
-      ]
-    };
-  }
-  if (score === null) {
-    return {
-      blocks: [
-        { type: "header", text: "SEO score" },
-        {
-          type: "context",
-          text: "The site score is unavailable in sandboxed mode. Findings are not affected."
-        }
-      ]
-    };
-  }
-  const blocks = [
-    {
-      type: "stats",
-      items: [
-        {
-          label: "Citation",
-          value: score.citation_readiness_score?.toString() ?? "unknown"
-        },
-        {
-          label: tuning.truthLabel(score),
-          value: score.truth_consistency_score?.toString() ?? "unknown"
-        },
-        {
-          label: "Answers",
-          value: `${score.answer_pack.routes_with_answer_blocks}/${score.answer_pack.routes_analyzed} routes`
-        }
-      ]
-    }
-  ];
-  if (score.blockers.length > 0) {
-    blocks.push({
-      type: "context",
-      text: topBlockersLine(score)
-    });
-  }
-  return { blocks };
-}
-function topBlockersLine(score) {
-  const top = score.blockers.slice(0, 3).map((blocker) => blocker.message);
-  if (top.length === 0) {
-    return "No blockers identified.";
-  }
-  return `Top blockers: ${top.join(" \u2022 ")}`;
+async function 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) {
@@ -854,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"
@@ -865,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)]
     ]
   };
@@ -878,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}`
     }))
   };
 }
@@ -913,12 +1490,14 @@ __export(aexeo_emdash_bridge_bg_exports, {
   evaluateContentCollection: () => evaluateContentCollection,
   evaluateDocuments: () => evaluateDocuments,
   generateFactsPrompt: () => generateFactsPrompt,
+  projectContentInput: () => projectContentInput,
+  projectLinkDestinations: () => projectLinkDestinations,
   scoreIntelligence: () => scoreIntelligence,
   validateFactsManifest: () => validateFactsManifest
 });
-function evaluateContent(document_json, preset_name, sources_json, evidence_json) {
-  let deferred6_0;
-  let deferred6_1;
+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;
@@ -928,19 +1507,23 @@ function evaluateContent(document_json, preset_name, sources_json, evidence_json
     var len2 = WASM_VECTOR_LEN;
     var ptr3 = isLikeNone(evidence_json) ? 0 : passStringToWasm0(evidence_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     var len3 = WASM_VECTOR_LEN;
-    const ret = wasm.evaluateContent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
-    var ptr5 = ret[0];
-    var len5 = ret[1];
+    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]) {
-      ptr5 = 0;
-      len5 = 0;
+      ptr7 = 0;
+      len7 = 0;
       throw takeFromExternrefTable0(ret[2]);
     }
-    deferred6_0 = ptr5;
-    deferred6_1 = len5;
-    return getStringFromWasm0(ptr5, len5);
+    deferred8_0 = ptr7;
+    deferred8_1 = len7;
+    return getStringFromWasm0(ptr7, len7);
   } finally {
-    wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+    wasm.__wbindgen_free(deferred8_0, deferred8_1, 1);
   }
 }
 function evaluateContentCollection(documents_json, preset_name, sources_json) {
@@ -1012,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;
@@ -1237,9 +1864,17 @@ async function validateFactsManifest2(manifestJson, documentsJson) {
   await ensureInitialized();
   return validateFactsManifest(manifestJson, documentsJson);
 }
-async function evaluateContent2(documentJson, presetName, sourcesJson, evidenceJson) {
+async function evaluateContent2(documentJson, presetName, sourcesJson, evidenceJson, extensionsJson, linkObservationsJson) {
   await ensureInitialized();
-  return evaluateContent(documentJson, presetName, sourcesJson, evidenceJson);
+  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
@@ -1251,6 +1886,7 @@ async function handleDataRoute(ctx, options) {
       evaluator: options.evaluator,
       blockMappings: options.blockMappings,
       contentFieldsByCollection: options.contentFieldsByCollection,
+      descriptionFieldsByCollection: options.descriptionFieldsByCollection,
       ...options.suppressionFilter === void 0 ? {} : { suppressionFilter: options.suppressionFilter }
     });
     await persistManifestStateFindings(ctx);
@@ -1269,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;
@@ -1303,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));
@@ -1325,7 +1965,8 @@ async function buildFindingsPayload(ctx) {
       documentsIndexed: documents.size
     },
     layerBreakdown,
-    sitewideFindings: sitewide
+    sitewideFindings: sitewide,
+    ...sitewideAssessment === void 0 ? {} : { sitewideAssessment }
   };
 }
 function computeLayerBreakdown(findings) {
@@ -2007,15 +2648,34 @@ function globToMatcher(pattern) {
 }
 
 // src/content.ts
-async function evaluateContent3(document, preset, sources = {}, evidenceSources, onTelemetry) {
+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 = evidenceSources === void 0 ? await evaluateContent2(documentJson, preset, sourcesJson) : await evaluateContent2(documentJson, preset, sourcesJson, JSON.stringify(evidenceSources));
+  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) {
@@ -2030,12 +2690,13 @@ async function evaluateContent3(document, preset, sources = {}, evidenceSources,
 }
 
 // src/content-evaluator.ts
-function withContentPreset(base, preset, evaluate) {
+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];
@@ -2046,16 +2707,85 @@ function withContentPreset(base, preset, evaluate) {
         const selected = collection !== void 0 && preset.byCollection !== void 0 && Object.hasOwn(preset.byCollection, collection) ? preset.byCollection[collection] : void 0;
         const name = selected ?? preset.name;
         if (!name) throw new Error(`empty preset name for collection ${collection}`);
-        const report = preset.evidenceSources === void 0 ? await evaluate(document, name, preset.sources) : await evaluate(document, name, preset.sources, preset.evidenceSources);
-        const incomplete = report.gates.filter((gate) => gate.status === "not_checked");
-        if (incomplete.length) return {
-          ok: false,
-          reason: "content_preset_incomplete",
-          detail: `${document.route}: ${incomplete.map((gate) => `${gate.gate_id}: ${gate.reason}`).join(", ")}`
+        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 } }))
         };
-        for (const gate of report.gates) findings.push(...gate.findings);
+        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 };
+      return { ok: true, findings, assessments };
     } catch (error) {
       return { ok: false, reason: "content_preset_error", detail: error instanceof Error ? error.message : String(error) };
     }
@@ -2119,14 +2849,14 @@ 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);
+  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,
@@ -2145,7 +2875,8 @@ function createPlugin(options = {}) {
         evaluator,
         suppressionFilter,
         options.blockMappings,
-        options.contentFieldsByCollection?.[event.content.type]
+        options.contentFieldsByCollection?.[event.content.type],
+        options.descriptionFieldsByCollection?.[event.content.type]
       ),
       "content:afterDelete": (event, ctx) => handleAfterDelete(event, ctx)
     },
@@ -2161,7 +2892,7 @@ function createPlugin(options = {}) {
       // refresh_findings action, which handleAdminRoute gates itself.
       admin: {
         permission: "plugins:read",
-        handler: (ctx) => handleAdminRoute(ctx, collections, suppressionFilter, evaluator, options.blockMappings, options.contentFieldsByCollection)
+        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
@@ -2178,7 +2909,8 @@ function createPlugin(options = {}) {
           refresh: false,
           suppressionFilter,
           blockMappings: options.blockMappings,
-          contentFieldsByCollection: options.contentFieldsByCollection
+          contentFieldsByCollection: options.contentFieldsByCollection,
+          descriptionFieldsByCollection: options.descriptionFieldsByCollection
         })).payload
       },
       refresh: {
@@ -2189,7 +2921,8 @@ function createPlugin(options = {}) {
           refresh: true,
           suppressionFilter,
           blockMappings: options.blockMappings,
-          contentFieldsByCollection: options.contentFieldsByCollection
+          contentFieldsByCollection: options.contentFieldsByCollection,
+          descriptionFieldsByCollection: options.descriptionFieldsByCollection
         })
       },
       // /facts route serves the truth-manifest authoring UI. It
@@ -2247,7 +2980,7 @@ var adminViewTuning = {
   score: async (documents, kv) => scoreLocally(documents, await readStoredFacts(kv)),
   truthLabel: formatTruthLabel
 };
-async function handleAdminRoute(ctx, collections, suppressionFilter, evaluator, blockMappings, contentFieldsByCollection) {
+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);
@@ -2278,7 +3011,8 @@ async function handleAdminRoute(ctx, collections, suppressionFilter, evaluator,
         suppressionFilter,
         tuning: adminViewTuning,
         blockMappings,
-        contentFieldsByCollection
+        contentFieldsByCollection,
+        descriptionFieldsByCollection
       });
     }
     if (body.action_id.startsWith("filter:")) {