@json-to-office/core-docx 6.0.0 → 6.2.0

package/dist/index.js

@@ -5605,7 +5605,7 @@ async function rasterizeVisualSlide(presentation, dpi, propsServerUrl, serviceCo
     serviceConfig?.serverUrl,
     DEFAULT_RASTERIZE_SERVER_URL
   );
-  const response = await postJsonToService({
+  const body = await postJsonToService({
     url: serverUrl,
     path: "/rasterize",
     body: {
@@ -5617,11 +5617,12 @@ async function rasterizeVisualSlide(presentation, dpi, propsServerUrl, serviceCo
     headers: serviceConfig?.headers,
     serviceLabel: "PPTX rasterization service",
     onUnreachable: (url, cause) => `PPTX rasterization service is not reachable at ${url}. Configure services.pptx with a \`render\` callback or a running \`serverUrl\`.
-Cause: ${cause}`
+Cause: ${cause}`,
+    decode: (response) => response.text()
   });
   let result;
   try {
-    result = await response.json();
+    result = JSON.parse(body);
   } catch {
     throw new Error(
       "PPTX rasterization service returned a non-JSON response (expected { base64DataUri, width, height })."
@@ -5817,9 +5818,9 @@ async function prerasterizeVisuals(root, serviceConfig, options = {}) {
     DEFAULT_RASTERIZE_SERVER_URL
   );
   const postBatch = async (chunk, fonts) => {
-    let response;
+    let body;
     try {
-      response = await postJsonToService2({
+      body = await postJsonToService2({
         url: serverUrl,
         path: "/rasterize/batch",
         body: {
@@ -5832,14 +5833,21 @@ async function prerasterizeVisuals(root, serviceConfig, options = {}) {
         },
         headers: serviceConfig?.headers,
         timeoutMs: BATCH_TIMEOUT_BASE_MS + BATCH_TIMEOUT_PER_SLIDE_MS * chunk.length,
+        // The per-visual fallback below IS this call's retry, and a better
+        // one: it degrades to smaller work instead of repeating the same
+        // large request. Retrying here first would spend three full batch
+        // timeouts — up to seventeen minutes on a 32-slide chunk — before
+        // the fallback that was going to run anyway gets its turn.
+        retries: 0,
         serviceLabel: "PPTX batch rasterization service",
-        onUnreachable: (url, cause) => `PPTX rasterization service is not reachable at ${url}. Cause: ${cause}`
+        onUnreachable: (url, cause) => `PPTX rasterization service is not reachable at ${url}. Cause: ${cause}`,
+        decode: (response) => response.text()
       });
     } catch (error) {
       return { applied: false, schemaRejected: isSchemaRejection(error) };
     }
     try {
-      if (applyBatchResponse(chunk, await response.json(), map)) {
+      if (applyBatchResponse(chunk, JSON.parse(body), map)) {
         return { applied: true };
       }
     } catch {
@@ -5946,7 +5954,7 @@ function containsComponent(root, name) {
 import {
   clampVisualDpi as clampVisualDpi2,
   DEFAULT_VISUAL_DPI as DEFAULT_VISUAL_DPI2,
-  limitChartRequest
+  recordChartCollected
 } from "@json-to-office/shared";
 import {
   isNativeVisualProps as isNativeVisualProps2
@@ -5965,9 +5973,8 @@ import {
   withChartTypography,
   resolveServiceUrl as resolveServiceUrl3,
   postJsonToService as postJsonToService3,
-  chartRequestKey,
-  dedupeChartRequest,
-  recordChartRetry
+  recordChartRetry,
+  sendChartRequest
 } from "@json-to-office/shared";
 var DEFAULT_EXPORT_SERVER_URL = "http://localhost:7801";
 function effectiveChartServerUrl(props, servicesConfig) {
@@ -6008,14 +6015,16 @@ async function generateChart(config, servicesConfig, warnings, cache) {
     // byte-identical to before for callers that omit it.
     ...config.resources ? { resources: config.resources } : {}
   };
-  return dedupeChartRequest(
+  return sendChartRequest({
     cache,
-    chartRequestKey(serverUrl, requestBody),
-    () => postChart(serverUrl, requestBody, config, servicesConfig)
-  );
+    serverUrl,
+    concurrency: servicesConfig?.concurrency,
+    requestBody,
+    send: () => postChart(serverUrl, requestBody, config, servicesConfig)
+  });
 }
 async function postChart(serverUrl, requestBody, config, servicesConfig) {
-  const response = await postJsonToService3({
+  const base64Data = await postJsonToService3({
     url: serverUrl,
     path: "/export",
     body: requestBody,
@@ -6025,16 +6034,13 @@ async function postChart(serverUrl, requestBody, config, servicesConfig) {
     onRetry: recordChartRetry,
     serviceLabel: "Highcharts export server",
     onUnreachable: (url, cause) => `Highcharts Export Server is not running at ${url}. Start it with: npx highcharts-export-server --enableServer true
-Cause: ${cause}`
+Cause: ${cause}`,
+    decode: (response) => response.text()
   });
-  const base64Data = await response.text();
-  const base64DataUri = `data:image/png;base64,${base64Data}`;
-  const width = config.options.chart.width;
-  const height = config.options.chart.height;
   return {
-    base64DataUri,
-    width,
-    height
+    base64DataUri: `data:image/png;base64,${base64Data}`,
+    width: config.options.chart.width,
+    height: config.options.chart.height
   };
 }
 function toChartColor(value, theme) {
@@ -6162,21 +6168,16 @@ async function desugarExternals(document, options) {
       });
     }
     if (node.name === "highcharts") {
-      const props = node.props;
-      const chartConfig = options.services?.highcharts;
+      recordChartCollected();
       return withNodeIdentity(node, {
         name: "image",
-        props: await limitChartRequest(
-          effectiveChartServerUrl(props, chartConfig),
-          chartConfig?.concurrency,
-          () => renderChartToImageProps(
-            props,
-            options.theme,
-            chartConfig,
-            options.chartFonts,
-            options.warnings,
-            chartCache
-          )
+        props: await renderChartToImageProps(
+          node.props,
+          options.theme,
+          options.services?.highcharts,
+          options.chartFonts,
+          options.warnings,
+          chartCache
         )
       });
     }
@@ -12883,6 +12884,7 @@ async function expandBlocksWithPlugins(document, theme, plugins, render, preserv
 init_styleHelpers();
 init_defaults();
 init_widthUtils();
+import probe2 from "probe-image-size";
 
 // src/quality/text-inventory.ts
 function tocDepth(depth) {
@@ -13133,6 +13135,116 @@ function collectDocxTextInventory(children, basePath = "/children") {
   return entries;
 }
 
+// src/quality/text-metrics.ts
+var DEFAULT_ADVANCE = 556;
+var ADVANCE = {
+  " ": 278,
+  A: 667,
+  B: 667,
+  C: 722,
+  D: 722,
+  E: 667,
+  F: 611,
+  G: 778,
+  H: 722,
+  I: 278,
+  J: 500,
+  K: 667,
+  L: 556,
+  M: 833,
+  N: 722,
+  O: 778,
+  P: 667,
+  Q: 778,
+  R: 722,
+  S: 667,
+  T: 611,
+  U: 722,
+  V: 667,
+  W: 944,
+  X: 667,
+  Y: 667,
+  Z: 611,
+  a: 556,
+  b: 556,
+  c: 500,
+  d: 556,
+  e: 556,
+  f: 278,
+  g: 556,
+  h: 556,
+  i: 222,
+  j: 222,
+  k: 500,
+  l: 222,
+  m: 833,
+  n: 556,
+  o: 556,
+  p: 556,
+  q: 556,
+  r: 333,
+  s: 500,
+  t: 278,
+  u: 556,
+  v: 500,
+  w: 722,
+  x: 500,
+  y: 500,
+  z: 500,
+  ".": 278,
+  ",": 278,
+  ":": 278,
+  ";": 278,
+  "!": 278,
+  "?": 556,
+  "'": 191,
+  '"': 355,
+  "-": 333,
+  "\u2013": 556,
+  "\u2014": 1e3,
+  "&": 667,
+  "%": 889,
+  "(": 333,
+  ")": 333,
+  "/": 278,
+  "@": 1015,
+  "#": 556,
+  "+": 584,
+  "=": 584
+};
+function estimateTextWidthPt(text, fontSizePt, trackingPt = 0) {
+  let units = 0;
+  for (const character of text) {
+    units += ADVANCE[character] ?? DEFAULT_ADVANCE;
+  }
+  const width = units / 1e3 * fontSizePt + text.length * trackingPt;
+  return Math.max(0, width);
+}
+function estimateWrappedLines(text, widthPt, fontSizePt, trackingPt = 0) {
+  if (widthPt <= 0) return 1;
+  let lines = 0;
+  for (const paragraph2 of text.split("\n")) {
+    const words = paragraph2.split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+      lines += 1;
+      continue;
+    }
+    let current = "";
+    let used = 0;
+    for (const word of words) {
+      const candidate = current === "" ? word : `${current} ${word}`;
+      if (estimateTextWidthPt(candidate, fontSizePt, trackingPt) <= widthPt) {
+        current = candidate;
+      } else {
+        if (current !== "") used += 1;
+        current = word;
+      }
+    }
+    lines += used + (current === "" ? 0 : 1);
+  }
+  return Math.max(1, lines);
+}
+
 // src/quality/facts.ts
 function asRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
@@ -13944,14 +14056,29 @@ function prepareDocxQualityDocument(document, options = {}) {
     }
     if (node.name === "image" || node.name === "visual") {
       for (const fact of svgTextFacts(props, path4)) addFact(fact);
+      const drawn = drawnRatio(props);
+      const natural = readableRatio(props);
+      addFact({
+        id: `docx:image:${path4}`,
+        kind: "docx/image",
+        path: path4,
+        ...typeof props.alt === "string" && props.alt.trim() !== "" && { alt: props.alt },
+        captioned: isCaptioned(facts, authoredPath(path4)),
+        ...drawn !== void 0 && { drawnRatio: drawn },
+        ...natural !== void 0 && { naturalRatio: natural }
+      });
     }
     if (node.name === "heading") {
       const level = typeof props.level === "number" && Number.isFinite(props.level) ? props.level : 1;
+      const styleKeepNext = asRecord2(
+        typography.styles[`heading${level}`]
+      )?.keepNext;
       addFact({
         id: `docx:heading:${path4}`,
         kind: "docx/heading",
         path: `${path4}/props/level`,
         level,
+        keepNext: props.keepNext === true || props.keepNext === void 0 && styleKeepNext === true,
         ...previousHeadingLevel !== void 0 && {
           previousLevel: previousHeadingLevel
         }
@@ -13966,6 +14093,65 @@ function prepareDocxQualityDocument(document, options = {}) {
     const page = rec.name === "section" ? pageBox(resolved.theme, context.themeName, rec.props?.page) : basePage;
     walkActive(component, `/children/${index}`, page, visit);
   });
+  const wordsOf = (text) => text.split(/\s+/).filter(Boolean).length;
+  const bodyRoles = /* @__PURE__ */ new Set([
+    "body",
+    "list-item",
+    "table-header",
+    "table-cell",
+    "statistic",
+    "caption"
+  ]);
+  const exhibitKinds = /* @__PURE__ */ new Set(["docx/table", "docx/chart", "docx/image"]);
+  resolved.children.forEach((component, index) => {
+    const rec = component;
+    if (rec.name !== "section") return;
+    const prefix = `/children/${index}/`;
+    const own = facts.filter((fact) => fact.path.startsWith(prefix));
+    const texts = own.filter(
+      (fact) => fact.kind === "docx/text"
+    );
+    addFact({
+      id: `docx:section:${index}`,
+      kind: "docx/section",
+      path: `/children/${index}`,
+      index,
+      words: texts.filter((fact) => bodyRoles.has(fact.role)).reduce((total, fact) => total + wordsOf(fact.text), 0),
+      exhibits: own.filter((fact) => exhibitKinds.has(fact.kind)).length,
+      headings: texts.filter((fact) => fact.role === "heading").length
+    });
+    if (hasColumnsComponent(rec)) return;
+    const page = pageBox(
+      resolved.theme,
+      context.themeName,
+      rec.props?.page
+    );
+    const fontSizePt = effectiveFontSize({ name: "paragraph" }, {}, typography)?.fontSizePt ?? 11;
+    const widthPt = page.availableWidthTwips / 20;
+    const averageAdvancePt = estimateTextWidthPt(MEASURE_SAMPLE, fontSizePt) / MEASURE_SAMPLE.length;
+    if (averageAdvancePt > 0)
+      addFact({
+        id: `docx:measure:${index}`,
+        kind: "docx/measure",
+        path: `/children/${index}`,
+        index,
+        charactersPerLine: Math.round(widthPt / averageAdvancePt),
+        widthTwips: page.availableWidthTwips,
+        fontSizePt
+      });
+  });
+  const headingCount = facts.filter(
+    (fact) => fact.kind === "docx/text" && fact.role === "heading"
+  ).length;
+  addFact({
+    id: "docx:outline",
+    kind: "docx/outline",
+    path: "/props",
+    headings: headingCount,
+    contents: facts.some(
+      (fact) => fact.kind === "docx/text" && fact.role === "toc-entry"
+    )
+  });
   return {
     format: "docx",
     model: {
@@ -13996,6 +14182,52 @@ function prepareDocxQualityDocument(document, options = {}) {
     }
   };
 }
+function hasColumnsComponent(node) {
+  if (Array.isArray(node)) return node.some(hasColumnsComponent);
+  const rec = asRecord2(node);
+  if (!rec) return false;
+  if (rec.name === "columns") return true;
+  return Object.values(rec).some(hasColumnsComponent);
+}
+var CAPTION_LABEL = /^\s*(?:\*\*)?\s*(figure|exhibit|table|chart|image)\b/i;
+function isCaptioned(facts, image) {
+  return facts.some((fact) => {
+    if (fact.kind !== "docx/text") return false;
+    const text = fact;
+    const near = siblingOf(text.path) === siblingOf(image) || text.path.startsWith(`${image}/`) || image.startsWith(`${text.path}/`);
+    return near && (text.role === "caption" || CAPTION_LABEL.test(text.text));
+  });
+}
+function siblingOf(pointer) {
+  return pointer.slice(0, pointer.lastIndexOf("/"));
+}
+var MEASURE_SAMPLE = "the quick brown fox jumps over the lazy dog and then settles under it ";
+function drawnRatio(props) {
+  const width = finiteNumber(props.width);
+  const height = finiteNumber(props.height);
+  return width !== void 0 && height !== void 0 && height > 0 ? width / height : void 0;
+}
+function readableRatio(props) {
+  if (typeof props.svg === "string") {
+    const box = /viewBox\s*=\s*["']\s*[-\d.]+[ ,]+[-\d.]+[ ,]+([\d.]+)[ ,]+([\d.]+)/.exec(
+      props.svg
+    );
+    const width = box ? Number(box[1]) : NaN;
+    const height = box ? Number(box[2]) : NaN;
+    return Number.isFinite(width) && Number.isFinite(height) && height > 0 ? width / height : void 0;
+  }
+  if (typeof props.base64 !== "string") return void 0;
+  const comma = props.base64.indexOf(",");
+  if (comma < 0) return void 0;
+  try {
+    const size = probe2.sync(
+      Buffer.from(props.base64.slice(comma + 1), "base64")
+    );
+    return size && size.height > 0 ? size.width / size.height : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function slotIsFilled(value) {
   if (typeof value === "string") return value.trim() !== "";
   return value !== void 0 && value !== null && value !== false && (!Array.isArray(value) || value.length > 0);
@@ -14397,122 +14629,16 @@ import {
   nearestPaletteToken,
   offPaletteFinding,
   placeholderFinding,
+  DEFAULT_IMAGE_ASPECT_TOLERANCE,
+  driftingSizes,
+  imageAspectFinding,
+  offScaleFindings,
   QUALITY_CODES,
+  roleDriftFindings,
+  sizeCountFinding,
   QualityEngine,
   tableInfoDesignFindings
 } from "@json-to-office/quality";
-
-// src/quality/text-metrics.ts
-var DEFAULT_ADVANCE = 556;
-var ADVANCE = {
-  " ": 278,
-  A: 667,
-  B: 667,
-  C: 722,
-  D: 722,
-  E: 667,
-  F: 611,
-  G: 778,
-  H: 722,
-  I: 278,
-  J: 500,
-  K: 667,
-  L: 556,
-  M: 833,
-  N: 722,
-  O: 778,
-  P: 667,
-  Q: 778,
-  R: 722,
-  S: 667,
-  T: 611,
-  U: 722,
-  V: 667,
-  W: 944,
-  X: 667,
-  Y: 667,
-  Z: 611,
-  a: 556,
-  b: 556,
-  c: 500,
-  d: 556,
-  e: 556,
-  f: 278,
-  g: 556,
-  h: 556,
-  i: 222,
-  j: 222,
-  k: 500,
-  l: 222,
-  m: 833,
-  n: 556,
-  o: 556,
-  p: 556,
-  q: 556,
-  r: 333,
-  s: 500,
-  t: 278,
-  u: 556,
-  v: 500,
-  w: 722,
-  x: 500,
-  y: 500,
-  z: 500,
-  ".": 278,
-  ",": 278,
-  ":": 278,
-  ";": 278,
-  "!": 278,
-  "?": 556,
-  "'": 191,
-  '"': 355,
-  "-": 333,
-  "\u2013": 556,
-  "\u2014": 1e3,
-  "&": 667,
-  "%": 889,
-  "(": 333,
-  ")": 333,
-  "/": 278,
-  "@": 1015,
-  "#": 556,
-  "+": 584,
-  "=": 584
-};
-function estimateTextWidthPt(text, fontSizePt, trackingPt = 0) {
-  let units = 0;
-  for (const character of text) {
-    units += ADVANCE[character] ?? DEFAULT_ADVANCE;
-  }
-  const width = units / 1e3 * fontSizePt + text.length * trackingPt;
-  return Math.max(0, width);
-}
-function estimateWrappedLines(text, widthPt, fontSizePt, trackingPt = 0) {
-  if (widthPt <= 0) return 1;
-  let lines = 0;
-  for (const paragraph2 of text.split("\n")) {
-    const words = paragraph2.split(/\s+/).filter(Boolean);
-    if (words.length === 0) {
-      lines += 1;
-      continue;
-    }
-    let current = "";
-    let used = 0;
-    for (const word of words) {
-      const candidate = current === "" ? word : `${current} ${word}`;
-      if (estimateTextWidthPt(candidate, fontSizePt, trackingPt) <= widthPt) {
-        current = candidate;
-      } else {
-        if (current !== "") used += 1;
-        current = word;
-      }
-    }
-    lines += used + (current === "" ? 0 : 1);
-  }
-  return Math.max(1, lines);
-}
-
-// src/quality/rules.ts
 var WIDTH_TOLERANCE_TWIPS = 10;
 function numberParameter(parameters, name, fallback) {
   const value = parameters[name];
@@ -15169,44 +15295,23 @@ var docxRunningHeadRule = {
     });
   }
 };
-var SIZE_TOLERANCE_PT = 0.25;
 function themeFact(facts) {
   return facts.find(
     (fact) => fact.kind === "docx/theme"
   );
 }
-function textSizeFacts(facts) {
-  return facts.filter(
-    (fact) => fact.kind === "docx/text-size"
-  );
-}
-function roleDriftFacts(facts, theme) {
-  const byRole = /* @__PURE__ */ new Map();
-  for (const fact of textSizeFacts(facts)) {
-    byRole.set(fact.role, [...byRole.get(fact.role) ?? [], fact]);
-  }
-  const drifting = /* @__PURE__ */ new Map();
-  for (const [role, members] of byRole) {
-    const sizes = [...new Set(members.map((fact) => fact.fontSizePt))].sort(
-      (a, b) => a - b
-    );
-    if (sizes.length < 2) continue;
-    const expected = theme?.roleSizesPt[role];
-    if (expected === void 0) continue;
-    for (const fact of members) {
-      if (fact.sizePath !== void 0 && !fact.generated && Math.abs(fact.fontSizePt - expected) > SIZE_TOLERANCE_PT)
-        drifting.set(fact, { expected, sizes });
-    }
-  }
-  return drifting;
-}
-function nearestSize(size, scale) {
-  let best;
-  for (const candidate of scale) {
-    if (best === void 0 || Math.abs(candidate - size) < Math.abs(best - size))
-      best = candidate;
-  }
-  return best;
+var DOCX_TYPE_VOCABULARY = {
+  subject: "document",
+  keepTo: "Keep to the theme styles \u2014 title, headings, body, label, source \u2014 and drop the ad-hoc sizes."
+};
+function paintedSizes(facts) {
+  return facts.filter((fact) => fact.kind === "docx/text-size").map((fact) => ({
+    path: fact.path,
+    role: fact.role,
+    fontSizePt: fact.fontSizePt,
+    ...fact.sizePath !== void 0 && { sizePath: fact.sizePath },
+    generated: fact.generated
+  }));
 }
 var docxTypeScaleRule = {
   id: "docx/type-scale",
@@ -15219,43 +15324,15 @@ var docxTypeScaleRule = {
   defaultEnabled: false,
   evaluate: ({ facts }) => {
     const theme = themeFact(facts);
-    const scale = theme?.typeScalePt ?? [];
-    if (scale.length === 0) return [];
-    const drifting = roleDriftFacts(facts, theme);
-    const offScale = textSizeFacts(facts).filter(
-      (fact) => fact.sizePath !== void 0 && !fact.generated && !drifting.has(fact) && !scale.some(
-        (size) => Math.abs(size - fact.fontSizePt) <= SIZE_TOLERANCE_PT
-      )
+    if (!theme) return [];
+    const sizes = paintedSizes(facts);
+    return offScaleFindings(
+      sizes,
+      theme.typeScalePt,
+      theme.themeName,
+      DOCX_TYPE_VOCABULARY,
+      driftingSizes(sizes, theme.roleSizesPt)
     );
-    const groups = /* @__PURE__ */ new Map();
-    for (const fact of offScale) {
-      const key = `${fact.role}@${fact.fontSizePt}`;
-      groups.set(key, [...groups.get(key) ?? [], fact]);
-    }
-    return [...groups.values()].map((members) => {
-      const [first] = members;
-      const nearest = nearestSize(first.fontSizePt, scale);
-      const sizePaths = members.map((fact) => fact.sizePath);
-      const count = members.length === 1 ? "" : ` (${members.length} places, patched together)`;
-      return {
-        path: sizePaths[0],
-        ...sizePaths.length > 1 && { relatedPaths: sizePaths.slice(1) },
-        message: `${first.fontSizePt}pt is not a size the ${theme.themeName} theme paints; the nearest on its scale is ${nearest}pt${count}.`,
-        suggestion: `Use ${nearest}pt, or drop the size and let the "${first.role}" style set it.`,
-        context: { role: first.role, scale, paths: sizePaths },
-        evidence: {
-          actual: first.fontSizePt,
-          expected: nearest,
-          unit: "pt",
-          values: { source: "theme" }
-        },
-        fixes: sizePaths.map((path4) => ({
-          op: "replace",
-          path: path4,
-          value: nearest
-        }))
-      };
-    });
   }
 };
 var docxSizeCountRule = {
@@ -15268,34 +15345,13 @@ var docxSizeCountRule = {
   formats: ["docx"],
   defaultEnabled: false,
   defaultParameters: { maximumSizes: 8 },
-  evaluate: ({ facts, configuration, profile }) => {
-    const maximum = numberParameter(
-      configuration.parameters,
-      "maximumSizes",
-      8
-    );
-    const firstPathBySize = /* @__PURE__ */ new Map();
-    for (const fact of textSizeFacts(facts)) {
-      const size = Math.round(fact.fontSizePt * 4) / 4;
-      if (!firstPathBySize.has(size)) firstPathBySize.set(size, fact.path);
-    }
-    if (firstPathBySize.size <= maximum) return [];
-    const sizes = [...firstPathBySize.keys()].sort((a, b) => a - b);
-    return [
-      {
-        path: themeFact(facts)?.path ?? "/props",
-        relatedPaths: sizes.map((size) => firstPathBySize.get(size)),
-        message: `The document paints ${sizes.length} distinct text sizes (${sizes.join(", ")}pt); the ${profile?.id ?? "selected"} profile allows ${maximum}.`,
-        suggestion: "Keep to the theme styles \u2014 title, headings, body, label, source \u2014 and drop the ad-hoc sizes.",
-        context: { sizes, maximum },
-        evidence: {
-          actual: sizes.length,
-          expected: maximum,
-          values: { source: "profile" }
-        }
-      }
-    ];
-  }
+  evaluate: ({ facts, configuration, profile }) => sizeCountFinding(
+    paintedSizes(facts),
+    numberParameter(configuration.parameters, "maximumSizes", 8),
+    themeFact(facts)?.path ?? "/props",
+    profile?.id,
+    DOCX_TYPE_VOCABULARY
+  )
 };
 var docxRoleDriftRule = {
   id: "docx/role-drift",
@@ -15308,29 +15364,220 @@ var docxRoleDriftRule = {
   defaultEnabled: false,
   evaluate: ({ facts }) => {
     const theme = themeFact(facts);
-    const findings = [];
-    for (const [fact, { expected, sizes }] of roleDriftFacts(facts, theme)) {
-      const keeper = textSizeFacts(facts).find(
-        (member) => member.role === fact.role && Math.abs(member.fontSizePt - expected) <= SIZE_TOLERANCE_PT
-      );
-      const others = sizes.filter((size) => size !== fact.fontSizePt);
-      const sizePath = fact.sizePath;
-      findings.push({
-        path: sizePath,
-        ...keeper && { relatedPaths: [keeper.path] },
-        message: `"${fact.role}" is painted at ${fact.fontSizePt}pt here and at ${others.join("pt, ")}pt elsewhere; the theme sets it at ${expected}pt.`,
-        suggestion: `Drop the size so "${fact.role}" paints at the theme's ${expected}pt.`,
-        context: { role: fact.role, sizes },
+    return theme ? roleDriftFindings(paintedSizes(facts), theme.roleSizesPt) : [];
+  }
+};
+var docxBodyMeasureRule = {
+  id: "docx/body-measure",
+  description: "A section whose body copy runs outside the readable measure. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.BODY_MEASURE,
+  category: "legibility",
+  defaultSeverity: "warning",
+  defaultCertainty: "estimated",
+  formats: ["docx"],
+  defaultEnabled: false,
+  defaultParameters: { minimumCharacters: 45, maximumCharacters: 90 },
+  evaluate: ({ facts, configuration }) => {
+    const minimum = numberParameter(
+      configuration.parameters,
+      "minimumCharacters",
+      45
+    );
+    const maximum = numberParameter(
+      configuration.parameters,
+      "maximumCharacters",
+      90
+    );
+    const words = new Map(
+      facts.filter((fact) => fact.kind === "docx/section").map((fact) => [fact.index, fact.words])
+    );
+    return facts.filter((fact) => fact.kind === "docx/measure").filter((fact) => (words.get(fact.index) ?? 0) >= 40).filter(
+      (fact) => fact.charactersPerLine < minimum || fact.charactersPerLine > maximum
+    ).map((fact) => {
+      const wide = fact.charactersPerLine > maximum;
+      return {
+        path: fact.path,
+        message: `Body copy runs about ${fact.charactersPerLine} characters a line at ${fact.fontSizePt}pt; a readable measure is ${minimum}\u2013${maximum}.`,
+        suggestion: wide ? "Widen the margins, set the body a size larger, or put the text in columns." : "Narrow the margins or set the body a size smaller.",
+        context: {
+          charactersPerLine: fact.charactersPerLine,
+          minimum,
+          maximum
+        },
         evidence: {
-          actual: fact.fontSizePt,
-          expected,
-          unit: "pt",
-          values: { role: fact.role, source: "theme" }
+          actual: fact.charactersPerLine,
+          expected: wide ? maximum : minimum,
+          unit: "characters",
+          values: { source: "profile" }
+        }
+      };
+    });
+  }
+};
+var docxSectionContentRule = {
+  id: "docx/section-content",
+  description: "A section that renders nothing, or one that carries body copy under no heading. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.SECTION_EMPTY,
+  category: "hierarchy",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultEnabled: false,
+  defaultParameters: { minimumWordsForHeading: 60 },
+  evaluate: ({ facts, configuration }) => {
+    const minimumWords = numberParameter(
+      configuration.parameters,
+      "minimumWordsForHeading",
+      60
+    );
+    const sections = facts.filter(
+      (fact) => fact.kind === "docx/section"
+    );
+    return sections.flatMap((fact) => {
+      if (fact.words === 0 && fact.exhibits === 0)
+        return [
+          {
+            path: fact.path,
+            code: QUALITY_CODES.SECTION_EMPTY,
+            message: "This section renders nothing: no text, no table, no figure. It still starts a page.",
+            suggestion: "Fill the section, or remove it so the document does not open a page on nothing.",
+            context: { index: fact.index }
+          }
+        ];
+      if (fact.headings === 0 && fact.words >= minimumWords)
+        return [
+          {
+            path: fact.path,
+            code: QUALITY_CODES.SECTION_UNTITLED,
+            message: `This section runs to ${fact.words} words under no heading, so nothing names it in the outline or the contents.`,
+            suggestion: "Open the section with a heading \u2014 a section-opener block, or a level-1 heading.",
+            context: { index: fact.index, words: fact.words },
+            evidence: {
+              actual: 0,
+              expected: 1,
+              unit: "headings",
+              values: { source: "profile" }
+            }
+          }
+        ];
+      return [];
+    });
+  }
+};
+var docxHeadingKeepNextRule = {
+  id: "docx/heading-keep-next",
+  description: "A heading that is not bound to the content under it, so a page break can strand it; the fix sets keepNext on an authored heading. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.HEADING_ORPHAN,
+  category: "hierarchy",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultEnabled: false,
+  evaluate: ({ facts }) => facts.filter(
+    (fact) => fact.kind === "docx/heading" && !fact.keepNext
+  ).map((fact) => {
+    const heading = /\/props\/level$/.test(fact.path) ? fact.path.replace(/\/props\/level$/, "") : void 0;
+    return {
+      path: heading ?? fact.path,
+      message: "This heading is not bound to the content under it: a page break can leave it alone at the foot of a page.",
+      suggestion: heading ? "Set keepNext on the heading, or give the theme\u2019s heading style keepNext so every level is bound." : "Give the theme\u2019s heading style keepNext, or set it in the block definition that draws this heading.",
+      context: { level: fact.level },
+      evidence: { values: { source: "profile" } },
+      ...heading && {
+        fixes: [
+          {
+            op: "add",
+            path: `${heading}/props/keepNext`,
+            value: true
+          }
+        ]
+      }
+    };
+  })
+};
+var docxFigureLabelRule = {
+  id: "docx/figure-label",
+  description: "An image with neither a caption beside it nor alt text on it. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.FIGURE_UNLABELLED,
+  category: "accessibility",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultEnabled: false,
+  evaluate: ({ facts }) => facts.filter(
+    (fact) => fact.kind === "docx/image" && fact.alt === void 0 && !fact.captioned
+  ).map((fact) => ({
+    path: fact.path,
+    message: "This figure carries neither a caption nor alt text, so nothing in the document says what it shows.",
+    suggestion: "Put the image in a figure block, which numbers and captions it, or write alt text on the image.",
+    context: {}
+  }))
+};
+var docxImageAspectRule = {
+  id: "docx/image-aspect",
+  description: "An image drawn at an aspect the asset does not have, where the asset can be read from the document.",
+  code: QUALITY_CODES.IMAGE_ASPECT,
+  category: "integrity",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultParameters: { tolerance: DEFAULT_IMAGE_ASPECT_TOLERANCE },
+  evaluate: ({ facts, configuration }) => {
+    const tolerance = numberParameter(
+      configuration.parameters,
+      "tolerance",
+      DEFAULT_IMAGE_ASPECT_TOLERANCE
+    );
+    return facts.filter(
+      (fact) => fact.kind === "docx/image" && fact.drawnRatio !== void 0 && fact.naturalRatio !== void 0
+    ).flatMap((fact) => {
+      const finding = imageAspectFinding(
+        {
+          path: fact.path,
+          drawn: fact.drawnRatio,
+          natural: fact.naturalRatio
         },
-        fixes: [{ op: "replace", path: sizePath, value: expected }]
-      });
-    }
-    return findings;
+        "page",
+        tolerance
+      );
+      return finding ? [finding] : [];
+    });
+  }
+};
+var docxContentsRule = {
+  id: "docx/contents-missing",
+  description: "More headings than minimumHeadings with no table of contents. Off at 0.",
+  code: QUALITY_CODES.CONTENTS_MISSING,
+  category: "hierarchy",
+  defaultSeverity: "info",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultParameters: { minimumHeadings: 0 },
+  evaluate: ({ facts, configuration, profile }) => {
+    const minimum = numberParameter(
+      configuration.parameters,
+      "minimumHeadings",
+      0
+    );
+    if (minimum <= 0) return [];
+    const outline = facts.find(
+      (fact) => fact.kind === "docx/outline"
+    );
+    if (!outline || outline.contents || outline.headings < minimum) return [];
+    return [
+      {
+        path: outline.path,
+        message: `The document carries ${outline.headings} headings and no table of contents; the ${profile?.id ?? "selected"} profile expects one from ${minimum}.`,
+        suggestion: "Add a `toc` component after the cover. Word fills it from the headings already there.",
+        context: { headings: outline.headings, minimum },
+        evidence: {
+          actual: outline.headings,
+          expected: minimum,
+          unit: "headings",
+          values: { source: "profile" }
+        }
+      }
+    ];
   }
 };
 var DOCX_QUALITY_RULES = {
@@ -15353,14 +15600,26 @@ var DOCX_QUALITY_RULES = {
     docxExhibitRequiredRule,
     docxTypeScaleRule,
     docxSizeCountRule,
-    docxRoleDriftRule
+    docxRoleDriftRule,
+    docxBodyMeasureRule,
+    docxSectionContentRule,
+    docxHeadingKeepNextRule,
+    docxFigureLabelRule,
+    docxImageAspectRule,
+    docxContentsRule
   ]
 };
+var REPORT_MEASURE = {
+  "docx/body-measure": {
+    enabled: true,
+    parameters: { maximumCharacters: 125 }
+  }
+};
 var DOCX_QUALITY_PROFILES = {
   "client-report": {
     id: "client-report",
     formats: ["docx"],
-    description: "Client or public-administration report: a running head with page numbers on every section after the cover, a takeaway and a source wherever a block declares them, no heading skipped, every size on the theme scale with at most eight in play, no page rendered empty or left half blank under the running head, and at least one chart or table.",
+    description: "Client or public-administration report: a running head with page numbers on every section after the cover, a takeaway and a source wherever a block declares them, no heading skipped, every size on the theme scale with at most eight in play, a readable measure, no empty or untitled section, every heading bound to what follows and every figure named, no page rendered empty or left half blank under the running head, and at least one chart or table.",
     rules: {
       "docx/required-chrome": {
         parameters: { required: ["takeaway", "source"] }
@@ -15384,7 +15643,11 @@ var DOCX_QUALITY_PROFILES = {
       // judge calls a page two-thirds blank a defect.
       "rendered/page-underfilled": { severity: "warning" },
       // A client report argues numbers: at least one chart or real table.
-      "docx/exhibit-required": { enabled: true }
+      "docx/exhibit-required": { enabled: true },
+      ...REPORT_MEASURE,
+      "docx/section-content": { enabled: true },
+      "docx/heading-keep-next": { enabled: true },
+      "docx/figure-label": { enabled: true }
     }
   },
   "executive-report": {
@@ -15392,13 +15655,15 @@ var DOCX_QUALITY_PROFILES = {
     formats: ["docx"],
     description: "Short decision document with strict outline continuity.",
     rules: {
-      "docx/heading-hierarchy": { severity: "warning" }
+      "docx/heading-hierarchy": { severity: "warning" },
+      "docx/section-content": { enabled: true },
+      "docx/heading-keep-next": { enabled: true }
     }
   },
   "technical-report": {
     id: "technical-report",
     formats: ["docx"],
-    description: "Technical report or memo: numbered sections under a running head with page numbers on every section after the cover, a source wherever a block declares one, no heading skipped, every size on the theme scale with at most nine in play, no page rendered empty or left half blank, and at least one chart or table.",
+    description: "Technical report or memo: numbered sections under a running head with page numbers on every section after the cover, a source wherever a block declares one, no heading skipped, every size on the theme scale with at most nine in play, a readable measure, no empty or untitled section, every heading bound to what follows, every figure named, a contents page past eight headings, no page rendered empty or left half blank, and at least one chart or table.",
     rules: {
       // A figure or table in a technical report cites where its numbers come
       // from; the takeaway is the client report's ask, the caption is the
@@ -15419,7 +15684,17 @@ var DOCX_QUALITY_PROFILES = {
       "rendered/empty-page": { severity: "warning" },
       "rendered/page-underfilled": { severity: "warning" },
       // A technical report argues from measurements: a runs table, a chart.
-      "docx/exhibit-required": { enabled: true }
+      "docx/exhibit-required": { enabled: true },
+      ...REPORT_MEASURE,
+      "docx/section-content": { enabled: true },
+      "docx/heading-keep-next": { enabled: true },
+      "docx/figure-label": { enabled: true },
+      // Numbered sections are meant to be reached by number: past eight
+      // headings a technical report owes the reader a contents page.
+      "docx/contents-missing": {
+        severity: "warning",
+        parameters: { minimumHeadings: 8 }
+      }
     }
   },
   general: {