@jasonbelmonti/markdown-engine 3.5.0 → 3.8.0

package/dist-bundled/markdown-engine-cli.mjs

@@ -7531,14 +7531,14 @@ function lists(document3, query = {}) {
   });
 }
 function links(document3, query = {}) {
-  return (document3.links ?? []).filter((link2) => {
-    if (query.targetId !== void 0 && link2.target.id !== query.targetId) {
+  return (document3.links ?? []).filter((link3) => {
+    if (query.targetId !== void 0 && link3.target.id !== query.targetId) {
       return false;
     }
-    if (query.url !== void 0 && link2.url !== query.url) {
+    if (query.url !== void 0 && link3.url !== query.url) {
       return false;
     }
-    return query.text === void 0 || link2.text === query.text;
+    return query.text === void 0 || link3.text === query.text;
   });
 }
 function linkReferences(document3, query = {}) {
@@ -8047,7 +8047,8 @@ function tableColumnTargets(document3, source) {
   }
   const resolvedColumns = tableResolution.tables.flatMap((table) => {
     const columnIndex = columnIndexForHeader(table, source.column);
-    return columnIndex === void 0 ? [] : [{ table, columnIndex }];
+    const predicateColumnMissing = source.rowWhere !== void 0 && columnIndexForHeader(table, source.rowWhere.column) === void 0;
+    return columnIndex === void 0 || predicateColumnMissing ? [] : [{ table, columnIndex }];
   });
   if (resolvedColumns.length === 0) {
     return {
@@ -8060,7 +8061,7 @@ function tableColumnTargets(document3, source) {
     status: "resolved",
     source,
     targets: resolvedColumns.flatMap(
-      ({ table, columnIndex }) => tableCellTargetsForColumn(document3, table, columnIndex)
+      ({ table, columnIndex }) => tableCellTargetsForColumn(document3, table, columnIndex, source.rowWhere)
     )
   };
 }
@@ -8110,9 +8111,11 @@ function rowMatchesPredicate(table, cells, predicate) {
 function columnIndexForHeader(table, column) {
   return headerCells(table).find((cell) => cell.text === column)?.columnIndex;
 }
-function tableCellTargetsForColumn(document3, table, columnIndex) {
-  return dataRows(table).flatMap((row) => {
-    const cell = row.cells.find((candidate) => candidate.columnIndex === columnIndex);
+function tableCellTargetsForColumn(document3, table, columnIndex, rowWhere) {
+  return dataRows(table).filter((row) => rowMatchesPredicate(table, row.cells, rowWhere)).flatMap((row) => {
+    const cell = row.cells.find(
+      (candidate) => candidate.columnIndex === columnIndex
+    );
     return cell === void 0 ? [] : [tableCellSelectionTarget(document3, table, cell)];
   });
 }
@@ -9000,11 +9003,11 @@ function linkTargets(document3, selector) {
   return documentQueries.links(document3, {
     ...selector.text !== void 0 ? { text: selector.text } : {},
     ...selector.url !== void 0 ? { url: selector.url } : {}
-  }).filter((link2) => targetMatchesSection(document3, link2.target.id, selector.section)).map((link2) => ({
+  }).filter((link3) => targetMatchesSection(document3, link3.target.id, selector.section)).map((link3) => ({
     kind: "link",
-    link: link2,
-    text: link2.text,
-    ...sourceFromTarget(document3, link2.target)
+    link: link3,
+    text: link3.text,
+    ...sourceFromTarget(document3, link3.target)
   }));
 }
 function listTargets(document3, selector) {
@@ -9603,8 +9606,16 @@ function sourceLengthRequirement(assertion) {
 // src/declarative-validation/assertions/table-column-coverage.ts
 function evaluateTableColumnCoverage(assertion, context) {
   const options = idTokenOptions(assertion);
-  const sourceIds = sourceIdsForCoverage(assertion, context, options);
+  const sourceResolution = resolveTableColumnIdTokens(
+    context.selection.document,
+    assertion.source,
+    options
+  );
+  const sourceIds = sourceResolution.status === "resolved" ? uniqueSourceIds2(sourceResolution.tokens) : [];
   if (sourceIds.length === 0) {
+    if (assertion.allowEmptySource === true && sourceResolution.status === "resolved") {
+      return [];
+    }
     return [emptySelectionDiagnostic(context.rule, context.assertionIndex)];
   }
   const targetResolution = resolveTableColumnIdTokens(
@@ -9614,12 +9625,22 @@ function evaluateTableColumnCoverage(assertion, context) {
   );
   if (targetResolution.status === "missingSection") {
     return sourceIds.map(
-      (sourceId, sourceIdOrder) => missingTargetSectionDiagnostic(assertion, context, sourceId, sourceIdOrder)
+      (sourceId, sourceIdOrder) => missingTargetSectionDiagnostic(
+        assertion,
+        context,
+        sourceId,
+        sourceIdOrder
+      )
     );
   }
   if (targetResolution.status === "missingColumn") {
     return sourceIds.map(
-      (sourceId, sourceIdOrder) => missingTargetColumnDiagnostic(assertion, context, sourceId, sourceIdOrder)
+      (sourceId, sourceIdOrder) => missingTargetColumnDiagnostic(
+        assertion,
+        context,
+        sourceId,
+        sourceIdOrder
+      )
     );
   }
   const targetComparisonValues = new Set(
@@ -9641,17 +9662,6 @@ function evaluateTableColumnCoverage(assertion, context) {
   }
   return diagnostics;
 }
-function sourceIdsForCoverage(assertion, context, options) {
-  const sourceResolution = resolveTableColumnIdTokens(
-    context.selection.document,
-    {
-      section: assertion.source.section,
-      column: assertion.source.column
-    },
-    options
-  );
-  return sourceResolution.status === "resolved" ? uniqueSourceIds2(sourceResolution.tokens) : [];
-}
 function uniqueSourceIds2(tokens) {
   const sourceIdsByComparisonValue = /* @__PURE__ */ new Map();
   for (const token of tokens) {
@@ -9741,6 +9751,49 @@ function targetColumnSource(assertion) {
   };
 }
 
+// src/declarative-validation/assertions/table-rows-complete.ts
+function evaluateTableRowsComplete(context) {
+  if (context.selection.targets.length === 0) {
+    return [emptySelectionDiagnostic(context.rule, context.assertionIndex)];
+  }
+  return context.selection.targets.flatMap(
+    (target, targetOrder) => target.kind === "table" ? incompleteRows(target.table, context, targetOrder) : []
+  );
+}
+function incompleteRows(table, context, targetOrder) {
+  const expected = columnIndexes(table.cells.filter((cell) => cell.header));
+  const rows = /* @__PURE__ */ new Map();
+  for (const cell of table.cells) {
+    if (!cell.header) {
+      const cells = rows.get(cell.rowIndex) ?? [];
+      cells.push(cell);
+      rows.set(cell.rowIndex, cells);
+    }
+  }
+  return [...rows].sort(([left], [right]) => left - right).flatMap(([rowIndex, cells]) => {
+    const actual = columnIndexes(cells);
+    if (expected.length === actual.length && expected.every((column, i) => column === actual[i])) {
+      return [];
+    }
+    const sourceRange = [...cells].sort((left, right) => left.columnIndex - right.columnIndex).find((cell) => cell.sourceRange !== void 0)?.sourceRange;
+    return [validationDiagnostic(
+      "profile.validation.assertionFailed",
+      `Selected table "${table.target.id}" body row ${rowIndex} must have column positions ${JSON.stringify(expected)}; found ${JSON.stringify(actual)}.`,
+      context.rule,
+      {
+        assertionIndex: context.assertionIndex,
+        targetOrder,
+        targetKey: `table:${table.target.id}:row:${rowIndex}`,
+        diagnosticOrder: rowIndex,
+        ...sourceRange === void 0 ? {} : { sourceRange }
+      }
+    )];
+  });
+}
+function columnIndexes(cells) {
+  return cells.map((cell) => cell.columnIndex).sort((left, right) => left - right);
+}
+
 // src/declarative-validation/assertions/table-columns-exact.ts
 function evaluateTableColumnsExact(assertion, context) {
   if (context.selection.targets.length === 0) {
@@ -9824,6 +9877,40 @@ function tableColumnSortKey(table, diagnosticOrder, column) {
   return `table:${table.target.id}:column:${paddedDiagnosticOrder}:${column}`;
 }
 
+// src/declarative-validation/assertions/visible-text.ts
+function visibleText(document3, target) {
+  const textAt = (nodeTarget) => documentQueries.nodes(document3, { targetId: nodeTarget.id }).map(nodeText2).join("");
+  switch (target.kind) {
+    case "document":
+      return document3.children.map(nodeText2).join("\n");
+    case "section":
+      return [
+        textAt(target.section.headingTarget),
+        ...target.section.bodyTargets.map(textAt)
+      ].join("\n");
+    case "heading":
+      return textAt(target.section.headingTarget);
+    case "table":
+      return textAt(target.table.target);
+    case "tableRow":
+      return target.cells.map((cell) => textAt(cell.target)).join(" ");
+    case "tableCell":
+      return textAt(target.cell.target);
+    case "textSpan":
+      return textAt(target.span.target);
+    case "link":
+      return textAt(target.link.target);
+    case "list":
+      return textAt(target.list.target);
+  }
+}
+function nodeText2(node2) {
+  if (node2.type === "html" || node2.type === "definition" || node2.type === "yaml") {
+    return "";
+  }
+  return node2.children === void 0 ? node2.text ?? "" : node2.children.map(nodeText2).join("");
+}
+
 // src/declarative-validation/assertions/literal-text.ts
 function countNonOverlappingLiteralOccurrences(text5, literal) {
   let count = 0;
@@ -9850,6 +9937,16 @@ function evaluateText(assertion, context) {
 }
 function evaluateTextTarget(assertion, context, target, targetOrder) {
   const diagnostics = [];
+  if (assertion.nonBlank === true && visibleText(context.selection.document, target).trim().length === 0) {
+    diagnostics.push(
+      validationDiagnostic(
+        "profile.validation.textBlank",
+        `Selected ${target.kind} must contain non-whitespace text outside raw HTML.`,
+        context.rule,
+        { assertionIndex: context.assertionIndex, target, targetOrder }
+      )
+    );
+  }
   if (assertion.contains !== void 0 && !target.text.includes(assertion.contains)) {
     diagnostics.push(
       validationDiagnostic(
@@ -10083,6 +10180,8 @@ function evaluateAssertion(assertion, context) {
       return evaluateFrontmatterRequired(assertion, context);
     case "tableColumnsRequired":
       return evaluateTableColumnsRequired(assertion, context);
+    case "tableRowsComplete":
+      return evaluateTableRowsComplete(context);
     case "tableColumnsExact":
       return evaluateTableColumnsExact(assertion, context);
     case "ids":
@@ -10625,6 +10724,48 @@ function stringArray(value) {
   return values;
 }
 
+// src/declarative-validation/profile/cell-predicate-schema.ts
+function cellPredicateFromValue(value, key, diagnostics) {
+  if (!isPlainRecord(value)) {
+    diagnostics.push(invalidShape(`Selector ${key} must be an object.`));
+    return void 0;
+  }
+  unsupportedKeys(value, ["column", "equals", "includes"], diagnostics);
+  const column = requiredNonEmptyStringField(
+    value.column,
+    `Selector ${key}.column`,
+    diagnostics,
+    (field) => `${field} must be a non-empty string.`
+  );
+  if (column === void 0) {
+    return void 0;
+  }
+  const predicate = {
+    ...optionalPredicateString(value, "equals", diagnostics),
+    ...optionalPredicateString(value, "includes", diagnostics)
+  };
+  if (predicate.equals === void 0 && predicate.includes === void 0) {
+    diagnostics.push(
+      invalidShape(
+        `Selector ${key} must include at least one of equals or includes.`
+      )
+    );
+    return void 0;
+  }
+  return {
+    column,
+    ...predicate
+  };
+}
+function optionalPredicateString(record, key, diagnostics) {
+  return optionalStringField(
+    record,
+    key,
+    diagnostics,
+    (field) => `Selector ${field} must be a non-empty string when provided.`
+  );
+}
+
 // src/declarative-validation/profile/selector-schema.ts
 function selectorFromValue(value, diagnostics) {
   if (!isPlainRecord(value)) {
@@ -10746,33 +10887,6 @@ function optionalCellPredicate(record, key, diagnostics) {
   const predicate = cellPredicateFromValue(value, key, diagnostics);
   return predicate === void 0 ? {} : { [key]: predicate };
 }
-function cellPredicateFromValue(value, key, diagnostics) {
-  if (!isPlainRecord(value)) {
-    diagnostics.push(invalidShape(`Selector ${key} must be an object.`));
-    return void 0;
-  }
-  unsupportedKeys(value, ["column", "equals", "includes"], diagnostics);
-  const column = requiredSelectorString(value.column, `${key}.column`, diagnostics);
-  if (column === void 0) {
-    return void 0;
-  }
-  const predicate = {
-    ...optionalSelectorString(value, "equals", diagnostics),
-    ...optionalSelectorString(value, "includes", diagnostics)
-  };
-  if (predicate.equals === void 0 && predicate.includes === void 0) {
-    diagnostics.push(
-      invalidShape(
-        `Selector ${key} must include at least one of equals or includes.`
-      )
-    );
-    return void 0;
-  }
-  return {
-    column,
-    ...predicate
-  };
-}
 function optionalBoolean(record, key, diagnostics) {
   return optionalBooleanField(
     record,
@@ -11122,7 +11236,22 @@ function pushObjectDiagnostic(fieldName, value, ruleId, diagnostics) {
 }
 function pushTextShapeDiagnostics(assertion, ruleId, diagnostics) {
   let valid = true;
-  if (assertion?.contains !== void 0 && !pushNonEmptyStringDiagnostic("contains", assertion.contains, ruleId, diagnostics)) {
+  if (assertion?.nonBlank !== void 0 && assertion.nonBlank !== true) {
+    diagnostics.push(
+      compileDiagnostic(
+        "profile.config.invalidShape",
+        "text.nonBlank must be true when provided.",
+        ruleId
+      )
+    );
+    valid = false;
+  }
+  if (assertion?.contains !== void 0 && !pushNonEmptyStringDiagnostic(
+    "contains",
+    assertion.contains,
+    ruleId,
+    diagnostics
+  )) {
     valid = false;
   }
   if (assertion?.excludes !== void 0 && closedStringArray("excludes", assertion.excludes, ruleId, diagnostics) === void 0) {
@@ -11191,7 +11320,13 @@ function closedTableColumnCoverage(value, ruleId, diagnostics) {
   const record = value;
   const hasSupportedKeys = pushUnsupportedKeyDiagnostics(
     record,
-    ["source", "target", "require"],
+    ["source", "target", "require", "allowEmptySource"],
+    diagnostics
+  );
+  pushOptionalBooleanDiagnostic(
+    "tableColumnCoverage.allowEmptySource",
+    record.allowEmptySource,
+    ruleId,
     diagnostics
   );
   const source = closedTableColumnCoverageSource(
@@ -11217,7 +11352,8 @@ function closedTableColumnCoverage(value, ruleId, diagnostics) {
   return hasSupportedKeys && diagnostics.length === diagnosticCountBefore && source !== void 0 && target !== void 0 && require2 !== void 0 ? {
     source,
     target,
-    require: require2
+    require: require2,
+    ...record.allowEmptySource === void 0 ? {} : { allowEmptySource: record.allowEmptySource }
   } : void 0;
 }
 function closedTableColumnCoverageSource(value, ruleId, diagnostics) {
@@ -11232,7 +11368,7 @@ function closedTableColumnCoverageSource(value, ruleId, diagnostics) {
   const source = value;
   const hasSupportedKeys = pushUnsupportedKeyDiagnostics(
     source,
-    ["section", "column", "prefix", "caseSensitive"],
+    ["section", "column", "prefix", "caseSensitive", "rowWhere"],
     diagnostics
   );
   const hasValidFields = pushNonEmptyStringDiagnostic(
@@ -11256,7 +11392,9 @@ function closedTableColumnCoverageSource(value, ruleId, diagnostics) {
     ruleId,
     diagnostics
   );
-  return hasSupportedKeys && hasValidFields ? {
+  const rowWhere = source.rowWhere === void 0 ? void 0 : cellPredicateFromValue(source.rowWhere, "rowWhere", diagnostics);
+  return hasSupportedKeys && hasValidFields && (source.rowWhere === void 0 || rowWhere !== void 0) ? {
+    ...rowWhere === void 0 ? {} : { rowWhere },
     section: source.section,
     column: source.column,
     ...optionalString("prefix", source.prefix),
@@ -11431,7 +11569,7 @@ function optionalNumber2(key, value) {
   return value === void 0 ? {} : { [key]: value };
 }
 function hasTextPredicate(assertion) {
-  return assertion?.contains !== void 0 || assertion?.excludes !== void 0 && assertion.excludes.length > 0;
+  return assertion?.nonBlank === true || assertion?.contains !== void 0 || assertion?.excludes !== void 0 && assertion.excludes.length > 0;
 }
 
 // src/declarative-validation/profile/ids-assertion-contract.ts
@@ -11475,6 +11613,7 @@ function selectorAssertionCompatibilityError(assertionName, selector) {
       return selector.target === "document" ? void 0 : selectorCompatibilityMessage(assertionName, "document");
     case "tableColumnsRequired":
     case "tableColumnsExact":
+    case "tableRowsComplete":
       return selector.target === "table" ? void 0 : selectorCompatibilityMessage(assertionName, "table");
     case "ids":
     case "text":
@@ -11596,12 +11735,29 @@ function hasLengthBound(bounds) {
   return bounds.min !== void 0 || bounds.max !== void 0;
 }
 
+// src/declarative-validation/compiler/table-rows-complete.ts
+var buildTableRowsCompleteAssertion = (assertion, selector, ruleId, syntaxVersion, diagnostics) => {
+  if (assertion.tableRowsComplete === void 0 || syntaxVersion !== PROFILE_SYNTAX_VERSION_V2) {
+    return void 0;
+  }
+  if (assertion.tableRowsComplete !== true) {
+    diagnostics.push(compileDiagnostic(
+      "profile.config.invalidShape",
+      "tableRowsComplete must be true.",
+      ruleId
+    ));
+    return void 0;
+  }
+  return pushCompatibilityDiagnostic("tableRowsComplete", selector, ruleId, diagnostics) ? { kind: "tableRowsComplete" } : void 0;
+};
+
 // src/declarative-validation/compiler/assertion-builders.ts
 var ASSERTION_BUILDERS = [
   buildExistsAssertion,
   buildSectionsRequiredAssertion,
   buildTableColumnsRequiredAssertion,
   buildTableColumnsExactAssertion,
+  buildTableRowsCompleteAssertion,
   buildIdsAssertion,
   buildReferencesAssertion,
   buildTableColumnCoverageAssertion,
@@ -11856,7 +12012,9 @@ function buildTableColumnCoverageAssertion(assertion, selector, ruleId, syntaxVe
   )) {
     return {
       kind: "tableColumnCoverage",
+      ...tableColumnCoverage.allowEmptySource === void 0 ? {} : { allowEmptySource: tableColumnCoverage.allowEmptySource },
       source: {
+        ...tableColumnCoverage.source.rowWhere === void 0 ? {} : { rowWhere: tableColumnCoverage.source.rowWhere },
         section: tableColumnCoverage.source.section,
         column: tableColumnCoverage.source.column,
         caseSensitive: tableColumnCoverage.source.caseSensitive ?? true,
@@ -11895,13 +12053,13 @@ function buildFrontmatterShapeAssertion(assertion, selector, ruleId, syntaxVersi
   }
   return void 0;
 }
-function buildTextAssertion(assertion, selector, ruleId, _syntaxVersion, diagnostics) {
+function buildTextAssertion(assertion, selector, ruleId, syntaxVersion, diagnostics) {
   if (assertion.text === void 0) {
     return void 0;
   }
   if (!pushObjectDiagnostic("text", assertion.text, ruleId, diagnostics) || !pushUnsupportedKeyDiagnostics(
     assertion.text,
-    ["contains", "excludes"],
+    syntaxVersion === PROFILE_SYNTAX_VERSION_V2 ? ["contains", "excludes", "nonBlank"] : ["contains", "excludes"],
     diagnostics
   ) || !pushTextShapeDiagnostics(assertion.text, ruleId, diagnostics)) {
     return void 0;
@@ -11919,6 +12077,7 @@ function buildTextAssertion(assertion, selector, ruleId, _syntaxVersion, diagnos
   if (pushCompatibilityDiagnostic("text", selector, ruleId, diagnostics)) {
     return {
       kind: "text",
+      ...assertion.text.nonBlank === true ? { nonBlank: true } : {},
       ...optionalString("contains", assertion.text.contains),
       ...optionalStringArray("excludes", assertion.text.excludes)
     };
@@ -12026,6 +12185,7 @@ var ASSERTION_KEYS_V2 = [
   "selectionCount",
   "sourceLength",
   "tableColumnsExact",
+  "tableRowsComplete",
   "tableColumnCoverage",
   "frontmatterShape",
   "textFormat"
@@ -12797,6 +12957,7 @@ var SUPPORTED_ASSERTION_KEYS_V2 = [
   "selectionCount",
   "sourceLength",
   "tableColumnsExact",
+  "tableRowsComplete",
   "tableColumnCoverage",
   "frontmatterShape",
   "textFormat"
@@ -12817,12 +12978,13 @@ function assertionFromValue(value, syntaxVersion, diagnostics) {
     ...tableColumnsRequiredFromValue(value.tableColumnsRequired, diagnostics),
     ...idsFromValue(value.ids, syntaxVersion, diagnostics),
     ...referencesFromValue(value.references, diagnostics),
-    ...textAssertionFromValue(value.text, diagnostics),
+    ...textAssertionFromValue(value.text, syntaxVersion, diagnostics),
     ...textOccurrenceCountFromValue(value.textOccurrenceCount, diagnostics),
     ...textLengthFromValue(value.textLength, diagnostics),
     ...supportsV2AssertionSurface(syntaxVersion) ? selectionCountFromValue(value.selectionCount, diagnostics) : {},
     ...supportsV2AssertionSurface(syntaxVersion) ? sourceLengthFromValue(value.sourceLength, diagnostics) : {},
     ...supportsV2AssertionSurface(syntaxVersion) ? tableColumnsExactFromValue(value.tableColumnsExact, diagnostics) : {},
+    ...supportsV2AssertionSurface(syntaxVersion) ? tableRowsCompleteFromValue(value.tableRowsComplete, diagnostics) : {},
     ...frontmatterRequiredFromValue(value.frontmatterRequired, diagnostics),
     ...supportsV2AssertionSurface(syntaxVersion) ? tableColumnCoverageFromValue(value.tableColumnCoverage, diagnostics) : {},
     ...supportsV2AssertionSurface(syntaxVersion) ? frontmatterShapeFromValue2(value.frontmatterShape, diagnostics) : {},
@@ -12833,7 +12995,9 @@ function assertionFromValue(value, syntaxVersion, diagnostics) {
       return void 0;
     }
     diagnostics.push(
-      invalidShape("Rule assert must include at least one supported assertion.")
+      invalidShape(
+        "Rule assert must include at least one supported assertion."
+      )
     );
     return void 0;
   }
@@ -12876,6 +13040,16 @@ function existsFromValue(value, diagnostics) {
   }
   return { exists: true };
 }
+function tableRowsCompleteFromValue(value, diagnostics) {
+  if (value === void 0) {
+    return {};
+  }
+  if (value !== true) {
+    diagnostics.push(invalidShape("tableRowsComplete must be true."));
+    return {};
+  }
+  return { tableRowsComplete: true };
+}
 function sectionsRequiredFromValue(value, diagnostics) {
   if (value === void 0) {
     return {};
@@ -13014,7 +13188,12 @@ function tableColumnCoverageFromValue(value, diagnostics) {
     diagnostics.push(invalidShape("tableColumnCoverage must be an object."));
     return {};
   }
-  unsupportedKeys(value, ["source", "target", "require"], diagnostics);
+  unsupportedKeys(
+    value,
+    ["source", "target", "require", "allowEmptySource"],
+    diagnostics
+  );
+  const emptyPolicy = optionalBoolean2(value, "allowEmptySource", diagnostics);
   const source = tableColumnCoverageSourceFromValue(value.source, diagnostics);
   const target = tableColumnCoverageTargetFromValue(value.target, diagnostics);
   const require2 = value.require === "everySourceId" ? "everySourceId" : void 0;
@@ -13025,6 +13204,7 @@ function tableColumnCoverageFromValue(value, diagnostics) {
   }
   return source === void 0 || target === void 0 || require2 === void 0 ? {} : {
     tableColumnCoverage: {
+      ...emptyPolicy,
       source,
       target,
       require: require2
@@ -13041,7 +13221,7 @@ function tableColumnCoverageSourceFromValue(value, diagnostics) {
   }
   unsupportedKeys(
     value,
-    ["section", "column", "prefix", "caseSensitive"],
+    ["section", "column", "prefix", "caseSensitive", "rowWhere"],
     diagnostics
   );
   const section = requiredAssertionString(
@@ -13054,7 +13234,9 @@ function tableColumnCoverageSourceFromValue(value, diagnostics) {
     "tableColumnCoverage.source.column",
     diagnostics
   );
+  const rowWhere = value.rowWhere === void 0 ? void 0 : cellPredicateFromValue(value.rowWhere, "rowWhere", diagnostics);
   const source = {
+    ...rowWhere === void 0 ? {} : { rowWhere },
     ...optionalTableColumnCoverageSourceString(value, "prefix", diagnostics),
     ...optionalTableColumnCoverageSourceBoolean(
       value,
@@ -13137,7 +13319,7 @@ function frontmatterShapeFromValue2(value, diagnostics) {
   }
   return result.shape === void 0 ? {} : { frontmatterShape: result.shape };
 }
-function textAssertionFromValue(value, diagnostics) {
+function textAssertionFromValue(value, syntaxVersion, diagnostics) {
   if (value === void 0) {
     return {};
   }
@@ -13145,16 +13327,22 @@ function textAssertionFromValue(value, diagnostics) {
     diagnostics.push(invalidShape("text must be an object."));
     return {};
   }
-  unsupportedKeys(value, ["contains", "excludes"], diagnostics);
+  unsupportedKeys(
+    value,
+    syntaxVersion === PROFILE_SYNTAX_VERSION_V2 ? ["contains", "excludes", "nonBlank"] : ["contains", "excludes"],
+    diagnostics
+  );
+  if (value.nonBlank !== void 0 && value.nonBlank !== true) {
+    diagnostics.push(invalidShape("text.nonBlank must be true when provided."));
+  }
   const text5 = {
+    ...value.nonBlank === true ? { nonBlank: true } : {},
     ...optionalAssertionString(value, "contains", diagnostics),
     ...optionalStringArray2(value, "excludes", diagnostics)
   };
   if (!hasTextPredicate2(text5)) {
     diagnostics.push(
-      invalidShape(
-        "text must include contains or a non-empty excludes array."
-      )
+      invalidShape("text must include contains or a non-empty excludes array.")
     );
     return {};
   }
@@ -13299,7 +13487,7 @@ function requiredAssertionString(value, field, diagnostics) {
   );
 }
 function hasTextPredicate2(text5) {
-  return text5?.contains !== void 0 || text5?.excludes !== void 0;
+  return text5?.nonBlank === true || text5?.contains !== void 0 || text5?.excludes !== void 0;
 }
 function isNonNegativeInteger2(value) {
   return Number.isInteger(value) && value >= 0;
@@ -13814,7 +14002,7 @@ function cloneSourceRange2(sourceRange) {
 import { createHash } from "node:crypto";
 
 // src/internal/package-version.ts
-var MARKDOWN_ENGINE_PACKAGE_VERSION = "3.5.0";
+var MARKDOWN_ENGINE_PACKAGE_VERSION = "3.8.0";
 
 // src/internal/stable-json.ts
 function normalizeStableJsonValue(value) {
@@ -19628,10 +19816,10 @@ function resolveAll(constructs2, events, context) {
   const called = [];
   let index2 = -1;
   while (++index2 < constructs2.length) {
-    const resolve2 = constructs2[index2].resolveAll;
-    if (resolve2 && !called.includes(resolve2)) {
-      events = resolve2(events, context);
-      called.push(resolve2);
+    const resolve3 = constructs2[index2].resolveAll;
+    if (resolve3 && !called.includes(resolve3)) {
+      events = resolve3(events, context);
+      called.push(resolve3);
     }
   }
   return events;
@@ -24495,7 +24683,7 @@ function compiler(options) {
     transforms: [],
     canContainEols: ["emphasis", "fragment", "heading", "paragraph", "strong"],
     enter: {
-      autolink: opener(link2),
+      autolink: opener(link3),
       autolinkProtocol: onenterdata,
       autolinkEmail: onenterdata,
       atxHeading: opener(heading2),
@@ -24523,7 +24711,7 @@ function compiler(options) {
       htmlTextData: onenterdata,
       image: opener(image2),
       label: buffer,
-      link: opener(link2),
+      link: opener(link3),
       listItem: opener(listItem2),
       listItemValue: onenterlistitemvalue,
       listOrdered: opener(list3, onenterlistordered),
@@ -25075,7 +25263,7 @@ function compiler(options) {
       alt: null
     };
   }
-  function link2() {
+  function link3() {
     return {
       type: "link",
       title: null,
@@ -25576,9 +25764,9 @@ var VFile = class {
    * @returns {undefined}
    *   Nothing.
    */
-  set dirname(dirname) {
+  set dirname(dirname2) {
     assertPath(this.basename, "dirname");
-    this.path = default2.join(dirname || "", this.basename);
+    this.path = default2.join(dirname2 || "", this.basename);
   }
   /**
    * Get the extname (including dot) (example: `'.js'`).
@@ -26177,7 +26365,7 @@ var Processor = class _Processor extends CallableInstance {
     assertParser("process", this.parser || this.Parser);
     assertCompiler("process", this.compiler || this.Compiler);
     return done ? executor(void 0, done) : new Promise(executor);
-    function executor(resolve2, reject) {
+    function executor(resolve3, reject) {
       const realFile = vfile(file);
       const parseTree = (
         /** @type {HeadTree extends undefined ? Node : HeadTree} */
@@ -26208,8 +26396,8 @@ var Processor = class _Processor extends CallableInstance {
       function realDone(error, file2) {
         if (error || !file2) {
           reject(error);
-        } else if (resolve2) {
-          resolve2(file2);
+        } else if (resolve3) {
+          resolve3(file2);
         } else {
           ok(done, "`done` is defined if `resolve` is not");
           done(void 0, file2);
@@ -26311,7 +26499,7 @@ var Processor = class _Processor extends CallableInstance {
       file = void 0;
     }
     return done ? executor(void 0, done) : new Promise(executor);
-    function executor(resolve2, reject) {
+    function executor(resolve3, reject) {
       ok(
         typeof file !== "function",
         "`file` can\u2019t be a `done` anymore, we checked"
@@ -26325,8 +26513,8 @@ var Processor = class _Processor extends CallableInstance {
         );
         if (error) {
           reject(error);
-        } else if (resolve2) {
-          resolve2(resultingTree);
+        } else if (resolve3) {
+          resolve3(resultingTree);
         } else {
           ok(done, "`done` is defined if `resolve` is not");
           done(void 0, resultingTree, file2);
@@ -26608,7 +26796,7 @@ function toEngineNode(node2, options) {
   const type = typeof node2.type === "string" ? node2.type : "unknown";
   const attributes = nodeAttributes(type, node2, options);
   const sourceRange = toSourceRange(node2.position, options);
-  const text5 = nodeText2(type, node2);
+  const text5 = nodeText3(type, node2);
   const children = childNodes(node2).map((child) => toEngineNode(child, options));
   return {
     type,
@@ -26715,7 +26903,7 @@ function assignStringAttribute(attributes, name, value) {
 function isTableAlignment(alignment) {
   return alignment === "left" || alignment === "right" || alignment === "center" || alignment === null;
 }
-function nodeText2(type, node2) {
+function nodeText3(type, node2) {
   if (typeof node2.value === "string") {
     return node2.value;
   }
@@ -27337,13 +27525,7 @@ function compatibilityModeForDocumentVersion(documentVersion) {
 }
 
 // src/cli/validate-args.ts
-var fileFlag = "--file";
-var fileAssignmentPrefix = `${fileFlag}=`;
-var profileFlag = "--profile";
-var profileAssignmentPrefix = `${profileFlag}=`;
-var formatFlag = "--format";
-var formatAssignmentPrefix = `${formatFlag}=`;
-var validateCliUsage = `Usage: markdown-engine validate --file <markdown-file> --profile <profile-file> [--format json]
+var validateCliUsage = `Usage: markdown-engine validate --file <markdown-file> --profile <profile-file> [--format json] [--output full|summary] [--report-file <new-file>]
 
 Runs declarative validation for one Markdown file and one validation profile.
 
@@ -27351,117 +27533,76 @@ Options:
   --file <markdown-file>         Markdown file to validate.
   --profile <profile-file>       Declarative validation profile to apply.
   --format json                  Output JSON. This is the default and only supported format.
+  --output full|summary          Full JSON (default) or a compact validation summary.
+  --report-file <new-file>       Save full JSON; required for summary. Never overwrites.
   -h, --help                     Show this help message.
 
+Summary includes at most 10 top-level diagnostics, errors first, with explicit
+omission/truncation counts. The report's parent directory must already exist.
+
 Exit status:
   0                              Validation completed with no error diagnostics.
   1                              Profile/config/compile or validation diagnostics failed.
-  2                              Usage, unsupported format, unknown args, or file read error.
+  2                              Usage, unsupported format, unknown args, or file read/write error.
 `;
 function parseValidateCliArgs(args) {
-  const filePaths = [];
-  const profilePaths = [];
-  let format;
+  const values = {
+    "--file": [],
+    "--profile": [],
+    "--format": [],
+    "--output": [],
+    "--report-file": []
+  };
   for (let index2 = 0; index2 < args.length; index2 += 1) {
     const arg = args[index2];
     if (arg === "-h" || arg === "--help") {
       return { kind: "help", usage: validateCliUsage };
     }
-    if (arg === fileFlag) {
-      const value = readRequiredFlagValue(arg, args, index2);
-      if (value.kind === "error") {
-        return validateError(value.message);
-      }
-      filePaths.push(value.value);
-      index2 += 1;
-      continue;
-    }
-    if (arg?.startsWith(fileAssignmentPrefix) === true) {
-      filePaths.push(arg.slice(fileAssignmentPrefix.length));
-      continue;
-    }
-    if (arg === profileFlag) {
-      const value = readRequiredFlagValue(arg, args, index2);
-      if (value.kind === "error") {
-        return validateError(value.message);
-      }
-      profilePaths.push(value.value);
-      index2 += 1;
-      continue;
-    }
-    if (arg?.startsWith(profileAssignmentPrefix) === true) {
-      profilePaths.push(arg.slice(profileAssignmentPrefix.length));
-      continue;
-    }
-    if (arg === formatFlag) {
-      if (format !== void 0) {
-        return validateError("Expected at most one --format selector.");
-      }
-      const value = readRequiredFlagValue(arg, args, index2);
-      if (value.kind === "error") {
-        return validateError(value.message);
-      }
-      const parsedFormat = parseDeclarativeOutputFormat(value.value);
-      if (parsedFormat.kind === "error") {
-        return validateError(parsedFormat.message);
-      }
-      format = parsedFormat.format;
-      index2 += 1;
-      continue;
-    }
-    if (arg?.startsWith(formatAssignmentPrefix) === true) {
-      if (format !== void 0) {
-        return validateError("Expected at most one --format selector.");
-      }
-      const parsedFormat = parseDeclarativeOutputFormat(
-        arg.slice(formatAssignmentPrefix.length)
-      );
-      if (parsedFormat.kind === "error") {
-        return validateError(parsedFormat.message);
-      }
-      format = parsedFormat.format;
-      continue;
-    }
-    return validateError(`Unknown argument: ${arg ?? ""}`);
-  }
-  if (filePaths.length === 0) {
-    return validateError("Expected exactly one --file target.");
-  }
-  if (filePaths.length > 1) {
-    return validateError("Expected one Markdown file target, received multiple.");
-  }
-  if (profilePaths.length === 0) {
-    return validateError("Expected exactly one --profile target.");
-  }
-  if (profilePaths.length > 1) {
-    return validateError("Expected one profile file target, received multiple.");
-  }
-  const [filePath] = filePaths;
-  const [profilePath] = profilePaths;
-  if (filePath === void 0 || filePath.trim() === "") {
-    return validateError("File path cannot be empty.");
-  }
-  if (profilePath === void 0 || profilePath.trim() === "") {
-    return validateError("Profile path cannot be empty.");
+    const equals = arg.indexOf("=");
+    const flag = equals === -1 ? arg : arg.slice(0, equals);
+    if (!Object.hasOwn(values, flag)) return validateError(`Unknown argument: ${arg}`);
+    const entries = values[flag];
+    if (flag !== "--file" && flag !== "--profile" && entries.length > 0) {
+      return validateError(`Expected at most one ${flag} selector.`);
+    }
+    const value = equals === -1 ? args[index2 + 1] : arg.slice(equals + 1);
+    if (value === void 0 || equals === -1 && value.startsWith("-")) {
+      return validateError(`Missing value for ${flag}.`);
+    }
+    if (flag === "--format" && value !== "json") {
+      return validateError(`Unsupported validation output format: ${value}.`);
+    }
+    if (flag === "--output" && value !== "full" && value !== "summary") {
+      return validateError(`Unsupported validation output mode: ${value}.`);
+    }
+    entries.push(value);
+    if (equals === -1) index2 += 1;
+  }
+  const files = values["--file"];
+  const profiles = values["--profile"];
+  if (files.length === 0) return validateError("Expected exactly one --file target.");
+  if (files.length > 1) return validateError("Expected one Markdown file target, received multiple.");
+  if (profiles.length === 0) return validateError("Expected exactly one --profile target.");
+  if (profiles.length > 1) return validateError("Expected one profile file target, received multiple.");
+  const filePath = files[0];
+  const profilePath = profiles[0];
+  if (filePath.trim() === "") return validateError("File path cannot be empty.");
+  if (profilePath.trim() === "") return validateError("Profile path cannot be empty.");
+  const output = values["--output"][0] ?? "full";
+  const reportFile = values["--report-file"][0];
+  if (reportFile !== void 0 && reportFile.trim() === "") {
+    return validateError("Report file path cannot be empty.");
+  }
+  if (output === "summary" && reportFile === void 0) {
+    return validateError("--output summary requires --report-file to retain the full result.");
   }
   return {
     kind: "validate",
     filePath,
-    format: format ?? "json",
-    profilePath
-  };
-}
-function readRequiredFlagValue(arg, args, index2) {
-  const value = args[index2 + 1];
-  if (value === void 0 || value.startsWith("-")) {
-    return { kind: "error", message: `Missing value for ${arg}.` };
-  }
-  return { kind: "ok", value };
-}
-function parseDeclarativeOutputFormat(value) {
-  return value === "json" ? { kind: "ok", format: value } : {
-    kind: "error",
-    message: `Unsupported validation output format: ${value}.`
+    profilePath,
+    format: "json",
+    output,
+    ...reportFile !== void 0 ? { reportFile } : {}
   };
 }
 function validateError(message) {
@@ -27473,8 +27614,8 @@ var documentVersionFlag = "--document-version";
 var documentVersionAssignmentPrefix = `${documentVersionFlag}=`;
 var duplicateDocumentVersionMessage = "Expected at most one --document-version selector.";
 var validateCommand = "validate";
-var fileFlag2 = "--file";
-var fileAssignmentPrefix2 = `${fileFlag2}=`;
+var fileFlag = "--file";
+var fileAssignmentPrefix = `${fileFlag}=`;
 var pathFlag = "--path";
 var pathAssignmentPrefix = `${pathFlag}=`;
 var normalizeCliUsage = `Usage: markdown-engine [--document-version <version>] (--file <markdown-file> | --path <markdown-file>)
@@ -27504,7 +27645,7 @@ function parseNormalizeCliArgs(args) {
     if (arg === "-h" || arg === "--help") {
       return { kind: "help", usage: cliUsage };
     }
-    if (arg === fileFlag2 || arg === pathFlag) {
+    if (arg === fileFlag || arg === pathFlag) {
       const value = args[index2 + 1];
       if (value === void 0 || value.startsWith("-")) {
         return normalizeError(`Missing value for ${arg}.`);
@@ -27531,8 +27672,8 @@ function parseNormalizeCliArgs(args) {
       }
       continue;
     }
-    if (arg?.startsWith(fileAssignmentPrefix2) === true) {
-      targets.push(arg.slice(fileAssignmentPrefix2.length));
+    if (arg?.startsWith(fileAssignmentPrefix) === true) {
+      targets.push(arg.slice(fileAssignmentPrefix.length));
       continue;
     }
     if (arg?.startsWith(pathAssignmentPrefix) === true) {
@@ -27619,6 +27760,99 @@ function normalizeMarkdown(input) {
   });
 }
 
+// src/cli/validation-report.ts
+import { createHash as createHash2 } from "node:crypto";
+import { link as link2, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve as resolve2 } from "node:path";
+async function saveValidationReport(cwd, reportFile, content3) {
+  const path2 = resolve2(cwd, reportFile);
+  const temporaryDirectory = await mkdtemp(join(dirname(path2), ".markdown-engine-report-"));
+  try {
+    const temporaryFile = join(temporaryDirectory, "report.json");
+    await writeFile(temporaryFile, content3, { encoding: "utf8", mode: 384, flag: "wx" });
+    await link2(temporaryFile, path2);
+  } finally {
+    await rm(temporaryDirectory, { recursive: true, force: true });
+  }
+  return {
+    path: path2,
+    sha256: createHash2("sha256").update(content3, "utf8").digest("hex"),
+    bytes: Buffer.byteLength(content3, "utf8")
+  };
+}
+
+// src/cli/validation-summary.ts
+var diagnosticLimit = 10;
+var severityOrder = { error: 0, warning: 1, info: 2 };
+function createValidationSummary(result, exitCode, report) {
+  const diagnostics = [...result.diagnostics].sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]).slice(0, diagnosticLimit).map(compactDiagnostic);
+  const counts = { total: result.diagnostics.length, error: 0, warning: 0, info: 0 };
+  for (const diagnostic of result.diagnostics) counts[diagnostic.severity] += 1;
+  const evidence = result.evidence;
+  return {
+    schemaVersion: "markdown-engine.validation-summary.v1",
+    valid: result.valid,
+    stage: "stage" in result ? result.stage : "validation",
+    exitCode,
+    engineVersion: MARKDOWN_ENGINE_PACKAGE_VERSION,
+    runtimeVersion: process.version,
+    ...result.profile !== void 0 ? { profile: result.profile } : {},
+    ...evidence !== void 0 ? {
+      evidence: {
+        inputHash: evidence.inputHash,
+        profileHash: evidence.profileHash,
+        engineVersion: evidence.engineVersion,
+        runtimeVersion: evidence.runtimeVersion,
+        ...evidence.sourceLength !== void 0 ? { sourceLength: evidence.sourceLength } : {}
+      }
+    } : {},
+    diagnosticCounts: counts,
+    diagnostics,
+    diagnosticsOmitted: counts.total - diagnostics.length,
+    diagnosticsTruncated: diagnostics.filter((d) => d.truncatedFields.length > 0).length,
+    report
+  };
+}
+function compactDiagnostic(diagnostic) {
+  const truncatedFields = [];
+  const bound = (field, value, max) => {
+    if (value.length <= max) return value;
+    truncatedFields.push(field);
+    return `${value.slice(0, max - 1)}\u2026`;
+  };
+  return {
+    code: bound("code", diagnostic.code, 128),
+    message: bound("message", diagnostic.message, 512),
+    severity: diagnostic.severity,
+    ...diagnostic.ruleId !== void 0 ? { ruleId: bound("ruleId", diagnostic.ruleId, 128) } : {},
+    ...diagnostic.sourceRange !== void 0 ? { sourceRange: diagnostic.sourceRange } : {},
+    truncatedFields
+  };
+}
+
+// src/cli/validation-output.ts
+async function outputValidationResult(result, exitCode, options) {
+  const output = JSON.stringify(normalizeStableJsonValue(result), null, 2) ?? "null";
+  try {
+    const report = options.reportFile === void 0 ? void 0 : await saveValidationReport(options.cwd, options.reportFile, `${output}
+`);
+    if (options.output === "summary") {
+      if (report === void 0) throw new Error("--output summary requires --report-file.");
+      return {
+        kind: "output",
+        exitCode,
+        output: JSON.stringify(normalizeStableJsonValue(createValidationSummary(result, exitCode, report)))
+      };
+    }
+    return { kind: "output", exitCode, output };
+  } catch (error) {
+    return {
+      kind: "fileError",
+      message: `Unable to save validation report "${options.reportFile ?? ""}": ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
 // src/cli/declarative-validation.ts
 async function runDeclarativeValidationCli(input) {
   const profileText = await readValidationFile(input.profilePath, input.cwd);
@@ -27629,13 +27863,14 @@ async function runDeclarativeValidationCli(input) {
     path: input.profilePath
   });
   if (profileResult.profile === void 0 || hasErrorDiagnostic(profileResult.diagnostics)) {
-    return outputResult(profileStageResult(profileResult.diagnostics), 1);
+    return outputValidationResult(profileStageResult(profileResult.diagnostics), 1, input);
   }
   const compileDiagnostics = compileProfileForCli(profileResult.profile);
   if (hasErrorDiagnostic(compileDiagnostics)) {
-    return outputResult(
+    return outputValidationResult(
       profileStageResult([...profileResult.diagnostics, ...compileDiagnostics]),
-      1
+      1,
+      input
     );
   }
   const markdown = await readValidationFile(input.filePath, input.cwd);
@@ -27652,7 +27887,7 @@ async function runDeclarativeValidationCli(input) {
     ...normalizeResult.diagnostics
   ];
   if (hasErrorDiagnostic(normalizeResult.diagnostics)) {
-    return outputResult(
+    return outputValidationResult(
       documentDiagnosticsResult(
         normalizeResult.document,
         profileResult.profile,
@@ -27665,7 +27900,8 @@ async function runDeclarativeValidationCli(input) {
           )
         ]
       ),
-      1
+      1,
+      input
     );
   }
   const validationResult = validateWithProfile(
@@ -27677,9 +27913,10 @@ async function runDeclarativeValidationCli(input) {
     validationResult,
     documentDiagnostics
   );
-  return outputResult(
+  return outputValidationResult(
     result,
-    hasErrorDiagnostic(result.diagnostics) ? 1 : 0
+    hasErrorDiagnostic(result.diagnostics) ? 1 : 0,
+    input
   );
 }
 function compileProfileForCli(profile) {
@@ -27732,16 +27969,6 @@ function mergeDocumentDiagnostics(validationResult, documentDiagnostics) {
     } : {}
   };
 }
-function outputResult(result, exitCode) {
-  return {
-    kind: "output",
-    exitCode,
-    output: serializeDeclarativeValidationCliJsonResult(result)
-  };
-}
-function serializeDeclarativeValidationCliJsonResult(result) {
-  return JSON.stringify(normalizeStableJsonValue(result), null, 2) ?? "null";
-}
 async function readValidationFile(path2, cwd) {
   try {
     return {
@@ -27774,7 +28001,9 @@ ${argsResult.usage}`);
       cwd: input.cwd,
       filePath: argsResult.filePath,
       format: argsResult.format,
-      profilePath: argsResult.profilePath
+      profilePath: argsResult.profilePath,
+      output: argsResult.output,
+      ...argsResult.reportFile !== void 0 ? { reportFile: argsResult.reportFile } : {}
     });
     if (validationResult.kind === "fileError") {
       input.stderr.write(`${validationResult.message}