@aeptus/aexeo-emdash 0.8.19 → 0.9.1

package/dist/sandbox-entry.js

@@ -1,11 +1,36 @@
+// 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,
@@ -30,14 +55,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) {
@@ -47,8 +90,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: {
@@ -57,7 +105,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 }
     }
   };
 }
@@ -76,38 +127,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) {
@@ -120,20 +523,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",
@@ -191,11 +623,16 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/version.ts
+var PACKAGE_VERSION = "0.9.1";
+
 // src/sidecar.ts
-async function evaluateViaSidecar(http, config, documents) {
+async function evaluateViaSidecar(http, config, documents, collections) {
   const body = {
-    documents
+    documents,
+    responseFormat: 2
   };
+  if (collections !== void 0) body.collections = collections;
   if (config.configJson !== void 0) {
     body.configJson = config.configJson;
   }
@@ -228,6 +665,12 @@ async function evaluateViaSidecar(http, config, documents) {
     }
     return { ok: false, reason: "server_error", detail };
   }
+  const workerVersion = response.headers?.get("x-aexeo-version") ?? "unknown";
+  if (workerVersion !== PACKAGE_VERSION) {
+    config.log?.warn(
+      `Aexeo sidecar is version ${workerVersion} but the plugin is ${PACKAGE_VERSION}; redeploy the Worker so both run the same rules`
+    );
+  }
   let raw;
   try {
     raw = await response.text();
@@ -236,20 +679,36 @@ async function evaluateViaSidecar(http, config, documents) {
     return { ok: false, reason: "invalid_response", detail };
   }
   try {
-    const findings = JSON.parse(raw);
-    if (!Array.isArray(findings)) {
-      return {
-        ok: false,
-        reason: "invalid_response",
-        detail: "sidecar returned non-array body"
-      };
+    const value = JSON.parse(raw);
+    if (Array.isArray(value)) return { ok: true, findings: value };
+    if (!value || typeof value !== "object" || !("findings" in value) || !Array.isArray(value.findings) || !("assessments" in value) || !value.assessments || typeof value.assessments !== "object" || Array.isArray(value.assessments)) {
+      return { ok: false, reason: "invalid_response", detail: "sidecar returned invalid assessment envelope" };
     }
-    return { ok: true, findings };
+    for (const finding of value.findings) {
+      if (finding && typeof finding === "object" && "aexeo_source_location" in finding && !validCounts(finding.aexeo_source_location, ["block_index", "span_index", "utf16_offset"])) {
+        return { ok: false, reason: "invalid_response", detail: "sidecar returned invalid source location" };
+      }
+    }
+    for (const assessment of Object.values(value.assessments)) {
+      if (assessment && typeof assessment === "object" && "source_mapping" in assessment && (!validCounts(assessment.source_mapping, ["eligible", "mapped", "unmapped"]) || assessment.source_mapping.mapped + assessment.source_mapping.unmapped !== assessment.source_mapping.eligible)) {
+        return { ok: false, reason: "invalid_response", detail: "sidecar returned invalid source mapping coverage" };
+      }
+      if (!assessment || typeof assessment !== "object" || !("status" in assessment) || assessment.status !== "evaluated" || !("preset" in assessment) || typeof assessment.preset !== "string" || !("gates" in assessment) || !Array.isArray(assessment.gates) || assessment.gates.some((gate) => !gate || typeof gate !== "object" || !("gate_id" in gate) || typeof gate.gate_id !== "string" || !("status" in gate) || !["passed", "failed", "not_checked"].includes(String(gate.status)) || !("blocking" in gate) || typeof gate.blocking !== "boolean" || !("scope" in gate) || !["document", "collection", "site"].includes(String(gate.scope)) || !("required_capability" in gate) || typeof gate.required_capability !== "string" || !("reason" in gate) || gate.reason !== null && typeof gate.reason !== "string" || "measurements" in gate && (gate.measurements === null || typeof gate.measurements !== "object" || Array.isArray(gate.measurements) || Object.values(gate.measurements).some((v) => typeof v !== "number" || !Number.isFinite(v))))) {
+        return { ok: false, reason: "invalid_response", detail: "sidecar returned invalid gate assessment" };
+      }
+    }
+    return { ok: true, findings: value.findings, assessments: value.assessments };
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     return { ok: false, reason: "invalid_response", detail };
   }
 }
+function validCounts(value, keys) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && keys.every((key) => {
+    const count = value[key];
+    return typeof count === "number" && Number.isSafeInteger(count) && count >= 0;
+  });
+}
 function trimTrailingSlash(url) {
   return url.endsWith("/") ? url.slice(0, -1) : url;
 }
@@ -266,7 +725,28 @@ function normalizeHost(evaluatorHost) {
 var CONFIG_URL_KEY = "config:evaluator_url";
 var CONFIG_TOKEN_KEY = "config:eval_token";
 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",
@@ -285,10 +765,21 @@ async function readSidecarConfig(store) {
   return { url, token };
 }
 async function writeSidecarConfig(store, config) {
-  await store.kv.set(CONFIG_URL_KEY, config.url);
   await writeStoredToken(store, config.token);
+  await store.kv.set(CONFIG_URL_KEY, config.url);
+}
+async function isTokenStoredInPlaintext(store) {
+  return await readLegacyToken(store) !== null;
+}
+async function readLegacyToken(store) {
+  const legacy = await store.kv.get(CONFIG_TOKEN_KEY);
+  return typeof legacy === "string" && legacy.length > 0 ? legacy : null;
 }
 async function readStoredToken(store) {
+  const legacy = await readLegacyToken(store);
+  if (legacy !== null) {
+    return legacy;
+  }
   const { settings } = store;
   if (settings !== void 0) {
     try {
@@ -298,32 +789,131 @@ async function readStoredToken(store) {
       }
     } catch (err) {
       store.log?.warn?.(
-        `aexeo: could not read the encrypted EVAL_TOKEN from plugin settings, falling back to KV: ${describeError(err, "")}`
+        `aexeo: could not read the encrypted EVAL_TOKEN from plugin settings: ${describeError(err, "")}`
       );
     }
   }
-  const legacy = await store.kv.get(CONFIG_TOKEN_KEY);
-  return typeof legacy === "string" && legacy.length > 0 ? legacy : null;
+  return null;
 }
+var TokenStorageError = class extends Error {
+};
 async function writeStoredToken(store, token) {
   const { settings } = store;
-  if (settings !== void 0) {
-    try {
-      await settings.set(SETTINGS_TOKEN_KEY, token);
-      await store.kv.delete(CONFIG_TOKEN_KEY);
-      return;
-    } catch (err) {
-      store.log?.warn?.(
-        `aexeo: could not store the EVAL_TOKEN encrypted in plugin settings; it will be written to plugin KV in plaintext instead. Set EMDASH_ENCRYPTION_KEY on the emdash host to fix this. Detail: ${describeError(err, token)}`
-      );
-    }
+  if (settings === void 0) {
+    throw new TokenStorageError(
+      "This emdash host does not provide encrypted plugin settings, so EVAL_TOKEN was not saved. Upgrade emdash."
+    );
+  }
+  try {
+    await settings.set(SETTINGS_TOKEN_KEY, token);
+    await store.kv.delete(CONFIG_TOKEN_KEY);
+  } catch (err) {
+    throw new TokenStorageError(
+      `EVAL_TOKEN was not saved because the host could not store it encrypted. Set EMDASH_ENCRYPTION_KEY on the emdash host and try again. Detail: ${describeError(err, token)}`
+    );
   }
-  await store.kv.set(CONFIG_TOKEN_KEY, token);
 }
 function describeError(err, secret) {
   const raw = err instanceof Error ? err.message : String(err);
   return secret.length === 0 ? raw : raw.split(secret).join("[redacted]");
 }
+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));
+    }
+  }
+}
+async function readSandboxBlockMappings(ctx) {
+  if (!ctx.settings) return void 0;
+  try {
+    const raw = await ctx.settings.get(SETTINGS_BLOCK_MAPPINGS_KEY);
+    if (raw === null || raw === "") return void 0;
+    if (typeof raw !== "string" || raw.length > 65536) throw new Error("invalid mapping size or type");
+    const value = JSON.parse(raw);
+    if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("mapping must be an object");
+    return value;
+  } catch {
+    ctx.log?.warn?.("Aexeo custom block mappings unavailable; custom content remains unverified");
+    return void 0;
+  }
+}
+async function readSandboxFields(ctx, key, warning) {
+  if (!ctx.settings) return { fields: void 0, unavailable: false };
+  try {
+    const raw = await ctx.settings.get(key);
+    if (raw === null || raw === "") return { fields: void 0, unavailable: false };
+    if (typeof raw !== "string" || raw.length > 65536) throw new Error("invalid selection size or type");
+    const value = JSON.parse(raw);
+    if (value === null || typeof value !== "object" || Array.isArray(value) || !Object.values(value).every((fields) => Array.isArray(fields) && fields.length > 0 && fields.every((field) => typeof field === "string" && field.length > 0))) throw new Error("invalid selection");
+    return { fields: value, unavailable: false };
+  } catch {
+    ctx.log?.warn?.(warning);
+    return { fields: void 0, unavailable: true };
+  }
+}
+function readSandboxContentFieldState(ctx) {
+  return readSandboxFields(ctx, SETTINGS_CONTENT_FIELDS_KEY, "Aexeo content field selection unavailable; body coverage remains unverified");
+}
+async function readSandboxDescriptionFields(ctx) {
+  return (await readSandboxFields(ctx, SETTINGS_DESCRIPTION_FIELDS_KEY, "Aexeo description field selection unavailable; description remains unverified")).fields;
+}
 async function handleAfterSave(event, ctx) {
   const runtime = await readSidecarConfig(ctx);
   if (runtime === null) {
@@ -332,36 +922,131 @@ async function handleAfterSave(event, ctx) {
     );
     return;
   }
+  const [blockMappings, fields, descriptions] = await Promise.all([readSandboxBlockMappings(ctx), readSandboxContentFieldState(ctx), readSandboxDescriptionFields(ctx)]);
   await handleAfterSaveConfigured(
     event,
     ctx,
-    (documents) => evaluateViaSidecar(
+    (documents, context) => evaluateViaSidecar(
       ctx.http,
-      { url: runtime.url, authToken: runtime.token },
-      documents
-    )
+      { url: runtime.url, authToken: runtime.token, log: ctx.log },
+      documents,
+      context?.collections
+    ),
+    void 0,
+    blockMappings,
+    fields.fields?.[event.content.type],
+    descriptions?.[event.content.type],
+    fields.unavailable
   );
 }
-async function handleAfterSaveConfigured(event, ctx, evaluator, suppressionFilter) {
-  const adapted = await adaptContentItemWithContext(
-    event.content,
-    ctx.content,
-    ctx.site?.locale
+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,
@@ -370,12 +1055,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;
@@ -386,11 +1110,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, {
@@ -398,19 +1126,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}`);
@@ -418,66 +1162,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);
@@ -513,9 +1374,6 @@ function documentKey(route) {
   const normalized = route === "" || route === "/" ? "/" : route;
   return `document:${normalized}`;
 }
-async function readAllDocuments(kv) {
-  return (await readAllStoredDocuments(kv)).map((s) => s.document);
-}
 async function readAllStoredDocuments(kv) {
   const entries = await kv.list("document:");
   const out = [];
@@ -532,6 +1390,10 @@ async function readFindings(kv, route) {
   }
   return stored.findings;
 }
+async function readAssessment(kv, route) {
+  const stored = await kv.get(findingsKey(route));
+  return stored?.assessment;
+}
 
 // src/sidecar-url.ts
 function validateSidecarUrl(raw, allowedHosts = []) {
@@ -552,6 +1414,12 @@ function validateSidecarUrl(raw, allowedHosts = []) {
     };
   }
   const host = parsed.hostname.toLowerCase();
+  if (host.endsWith(".")) {
+    return {
+      ok: false,
+      error: `Sidecar URL host must not end with a dot: ${host}`
+    };
+  }
   if (isBlockedHost(host)) {
     return {
       ok: false,
@@ -628,15 +1496,20 @@ function hostMatchesAllowlist(host, allowedHosts) {
 
 // src/evaluator-sandbox.ts
 async function scoreSite(_documents) {
-  return {
-    overall_score: 0,
-    citation_readiness_score: 0,
-    truth_consistency_score: 0,
-    answer_pack_score: 0,
-    external_trust_alignment_score: null,
-    route_scores: [],
-    blockers: []
-  };
+  return null;
+}
+
+// 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
@@ -675,6 +1548,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
     });
@@ -710,21 +1587,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;
@@ -742,7 +1636,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"
@@ -753,8 +1647,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",
@@ -779,10 +1678,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: [
@@ -790,7 +1689,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" }
@@ -815,55 +1714,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) {
@@ -877,7 +1734,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"
@@ -888,8 +1749,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)]
     ]
   };
@@ -901,16 +1768,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}`
     }))
   };
 }
@@ -1061,7 +1925,7 @@ async function handleBlockAction(ctx, actionId, value) {
   return notFound(actionId);
 }
 async function handleRefresh2(ctx) {
-  const sandboxEvaluator = async (documents) => {
+  const sandboxEvaluator = async (documents, context) => {
     const runtime = await readSidecarConfig(ctx.ctx);
     if (runtime === null) {
       return {
@@ -1072,10 +1936,12 @@ async function handleRefresh2(ctx) {
     }
     return evaluateViaSidecar(
       ctx.ctx.http,
-      { url: runtime.url, authToken: runtime.token },
-      documents
+      { url: runtime.url, authToken: runtime.token, log: ctx.ctx.log },
+      documents,
+      context?.collections
     );
   };
+  const contentFields = await readSandboxContentFieldState(ctx.ctx);
   return handleRefresh({
     ctx: ctx.ctx,
     // The sandboxed descriptor takes no collection knobs, so the sweep
@@ -1083,18 +1949,30 @@ async function handleRefresh2(ctx) {
     collections: DEFAULT_COLLECTIONS,
     evaluator: sandboxEvaluator,
     suppressionFilter: sandboxSuppressionFilter,
+    blockMappings: await readSandboxBlockMappings(ctx.ctx),
+    contentFieldsByCollection: contentFields.fields,
+    contentFieldsUnavailable: contentFields.unavailable,
+    descriptionFieldsByCollection: await readSandboxDescriptionFields(ctx.ctx),
     tuning: adminViewTuning
   });
 }
 async function renderSetupPage(ctx, options = {}) {
   const existing = await readSidecarConfig(ctx.ctx);
+  const tokenInPlaintext = await isTokenStoredInPlaintext(ctx.ctx);
   const blocks = [
     { type: "header", text: "Aexeo setup" },
     {
       type: "context",
-      text: "Paste the URL and auth token of your deployed aexeo-crawl-worker. The token is stored encrypted by the emdash host; both values are read at runtime, so no rebuild is required after a change. Rotate the token here whenever you redeploy the sidecar with a new secret."
+      text: "Paste the URL and auth token of your deployed aexeo-crawl-worker. Saving stores the token encrypted by the emdash host, and fails if the host cannot encrypt it. Both values are read at runtime, so no rebuild is required after a change. Rotate the token here whenever you redeploy the sidecar with a new secret."
     }
   ];
+  if (tokenInPlaintext) {
+    blocks.push({
+      type: "banner",
+      title: "EVAL_TOKEN is currently stored unencrypted in plugin KV. Save this form to encrypt it.",
+      variant: "alert"
+    });
+  }
   if (options.bannerError !== void 0) {
     blocks.push({
       type: "banner",
@@ -1135,7 +2013,7 @@ async function renderSetupPage(ctx, options = {}) {
     { type: "divider" },
     {
       type: "context",
-      text: existing === null ? "Status: not configured. Refresh on the findings page will fail until both fields are saved." : `Status: configured. Sidecar at ${existing.url}. Token stored \u2014 paste a new one above to rotate.`
+      text: existing === null ? "Status: not configured. Refresh on the findings page will fail until both fields are saved." : `Status: configured. Sidecar at ${existing.url}. Token stored ${tokenInPlaintext ? "unencrypted" : "encrypted"} \u2014 paste a new one above to rotate.`
     }
   );
   return { blocks };
@@ -1172,14 +2050,23 @@ async function handleSetupSubmit(ctx, values) {
     url: validated.url,
     token: resolvedToken
   };
-  await writeSidecarConfig(ctx.ctx, next);
+  try {
+    await writeSidecarConfig(ctx.ctx, next);
+  } catch (err) {
+    if (!(err instanceof TokenStorageError)) throw err;
+    return renderSetupPage(ctx, {
+      bannerError: err.message,
+      initialUrl: validated.url
+    });
+  }
   return renderSetupPage(ctx, {
     bannerSuccess: "Configuration saved. Click Refresh on the findings page to evaluate."
   });
 }
 var sandbox_entry_default = definePlugin({
   hooks: {
-    "content:afterSave": handleAfterSave
+    "content:afterSave": handleAfterSave,
+    "content:afterDelete": handleAfterDelete
   },
   routes: {
     admin: { handler: handleAdminRoute }