@jasonbelmonti/markdown-engine 3.1.1 → 3.3.0

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

@@ -7622,6 +7622,7 @@ function sourceSliceProperty(sourceSlice2) {
 }
 
 // src/declarative-validation/assertions/diagnostics.ts
+var SOURCE_UNAVAILABLE_DIAGNOSTIC_CODE = "profile.validation.sourceUnavailable";
 function noAlternativeMatchedDiagnostic(rule) {
   return {
     code: "profile.validation.noAlternativeMatched",
@@ -7650,6 +7651,23 @@ function emptySelectionDiagnostic(rule, assertionIndex) {
     }
   );
 }
+function sourceUnavailableDiagnostic(rule, assertionIndex) {
+  return {
+    diagnostic: {
+      code: SOURCE_UNAVAILABLE_DIAGNOSTIC_CODE,
+      ruleId: rule.ruleId,
+      message: "Complete Markdown source is required to evaluate sourceLength.",
+      severity: "error"
+    },
+    assertionIndex,
+    targetOrder: 0,
+    targetKey: "document:source",
+    diagnosticOrder: 0
+  };
+}
+function isSourceUnavailableDiagnostic(diagnostic) {
+  return diagnostic.code === SOURCE_UNAVAILABLE_DIAGNOSTIC_CODE;
+}
 function validationDiagnostic(code3, message, rule, options) {
   const sourceRange = options.sourceRange ?? targetSourceRange(options.target);
   return {
@@ -9460,6 +9478,79 @@ function sectionHeadingSourceRange(document3, section) {
   return section === void 0 ? void 0 : documentQueries.sourceSlice(document3, section.headingTarget)?.range;
 }
 
+// src/declarative-validation/assertions/selection-count.ts
+function evaluateSelectionCount(assertion, context) {
+  const actualCount = context.selection.targets.length;
+  if (isCountWithinBounds(actualCount, assertion)) {
+    return [];
+  }
+  const firstExcessTargetOrder = assertion.max;
+  const firstExcessTarget = firstExcessTargetOrder === void 0 ? void 0 : context.selection.targets[firstExcessTargetOrder];
+  return [
+    validationDiagnostic(
+      "profile.validation.assertionFailed",
+      `Rule selector target count must be ${selectionCountRequirement(assertion)}; found ${actualCount}.`,
+      context.rule,
+      {
+        assertionIndex: context.assertionIndex,
+        ...firstExcessTarget !== void 0 && firstExcessTargetOrder !== void 0 ? { target: firstExcessTarget, targetOrder: firstExcessTargetOrder } : { targetKey: "selection:count" }
+      }
+    )
+  ];
+}
+function isCountWithinBounds(actualCount, assertion) {
+  return (assertion.min === void 0 || actualCount >= assertion.min) && (assertion.max === void 0 || actualCount <= assertion.max);
+}
+function selectionCountRequirement(assertion) {
+  if (assertion.min !== void 0 && assertion.max !== void 0) {
+    return `between ${assertion.min} and ${assertion.max}`;
+  }
+  if (assertion.min !== void 0) {
+    return `at least ${assertion.min}`;
+  }
+  if (assertion.max !== void 0) {
+    return `at most ${assertion.max}`;
+  }
+  return "within configured bounds";
+}
+
+// src/declarative-validation/assertions/source-length.ts
+function evaluateSourceLength(assertion, context) {
+  if (context.sourceText === void 0) {
+    return [sourceUnavailableDiagnostic(context.rule, context.assertionIndex)];
+  }
+  const actualLength = context.sourceText.length;
+  if (isLengthWithinBounds(actualLength, assertion)) {
+    return [];
+  }
+  return [
+    validationDiagnostic(
+      "profile.validation.assertionFailed",
+      `Document source length must be ${sourceLengthRequirement(assertion)}; found ${actualLength}.`,
+      context.rule,
+      {
+        assertionIndex: context.assertionIndex,
+        targetKey: "document:source"
+      }
+    )
+  ];
+}
+function isLengthWithinBounds(actualLength, assertion) {
+  return (assertion.min === void 0 || actualLength >= assertion.min) && (assertion.max === void 0 || actualLength <= assertion.max);
+}
+function sourceLengthRequirement(assertion) {
+  if (assertion.min !== void 0 && assertion.max !== void 0) {
+    return `between ${assertion.min} and ${assertion.max}`;
+  }
+  if (assertion.min !== void 0) {
+    return `at least ${assertion.min}`;
+  }
+  if (assertion.max !== void 0) {
+    return `at most ${assertion.max}`;
+  }
+  return "within configured bounds";
+}
+
 // src/declarative-validation/assertions/table-column-coverage.ts
 function evaluateTableColumnCoverage(assertion, context) {
   const options = idTokenOptions(assertion);
@@ -9791,7 +9882,7 @@ function evaluateTextLength(assertion, context) {
 }
 function evaluateTextLengthTarget(assertion, context, target, targetOrder) {
   const actualLength = target.text.length;
-  if (isLengthWithinBounds(actualLength, assertion)) {
+  if (isLengthWithinBounds2(actualLength, assertion)) {
     return [];
   }
   return [
@@ -9807,7 +9898,7 @@ function evaluateTextLengthTarget(assertion, context, target, targetOrder) {
     )
   ];
 }
-function isLengthWithinBounds(actualLength, assertion) {
+function isLengthWithinBounds2(actualLength, assertion) {
   return (assertion.min === void 0 || actualLength >= assertion.min) && (assertion.max === void 0 || actualLength <= assertion.max);
 }
 function textLengthMessage(targetKind, actualLength, assertion) {
@@ -9858,12 +9949,13 @@ function evaluateTextOccurrenceCountTarget(assertion, context, target, targetOrd
 }
 
 // src/declarative-validation/assertions/evaluator.ts
-function evaluateCompiledDeclarativeRule(rule, selection) {
+function evaluateCompiledDeclarativeRule(rule, selection, runtimeContext = {}) {
   const evaluatedDiagnostics = rule.assertions.flatMap(
     (assertion, assertionIndex) => evaluateAssertion(assertion, {
       rule,
       selection,
-      assertionIndex
+      assertionIndex,
+      ...runtimeContext.sourceText !== void 0 ? { sourceText: runtimeContext.sourceText } : {}
     })
   );
   const diagnostics = sortAssertionDiagnostics(evaluatedDiagnostics);
@@ -9879,12 +9971,16 @@ function evaluateAssertion(assertion, context) {
       return evaluateExists(context);
     case "sectionsRequired":
       return evaluateSectionsRequired(assertion, context);
+    case "selectionCount":
+      return evaluateSelectionCount(assertion, context);
     case "text":
       return evaluateText(assertion, context);
     case "textOccurrenceCount":
       return evaluateTextOccurrenceCount(assertion, context);
     case "textLength":
       return evaluateTextLength(assertion, context);
+    case "sourceLength":
+      return evaluateSourceLength(assertion, context);
     case "textFormat":
       return evaluateTextFormat(assertion, context);
     case "frontmatterRequired":
@@ -9903,14 +9999,15 @@ function evaluateAssertion(assertion, context) {
 }
 
 // src/declarative-validation/applicability/classifier.ts
-function classifyCompiledDeclarativeRuleApplicability(rule, document3) {
+function classifyCompiledDeclarativeRuleApplicability(rule, document3, runtimeContext = {}) {
   const applicability = compiledApplicabilityFromRule(rule);
   if (applicability === void 0) {
     return { status: "notConfigured" };
   }
   const result = evaluateCompiledDeclarativeRule(
     applicabilityRuleFromPlan(rule, applicability),
-    resolveDeclarativeSelector(document3, applicability.selector)
+    resolveDeclarativeSelector(document3, applicability.selector),
+    runtimeContext
   );
   if (result.diagnostics.length === 0) {
     return {
@@ -9942,11 +10039,21 @@ function applicabilityRuleFromPlan(rule, applicability) {
 }
 
 // src/declarative-validation/assertions/group-evaluator.ts
-function evaluateCompiledDeclarativeAnyOfRule(rule, document3) {
-  const branches = evaluateCompiledDeclarativeBranches(rule.branches, document3);
+function evaluateCompiledDeclarativeAnyOfRule(rule, document3, runtimeContext = {}) {
+  const branches = evaluateCompiledDeclarativeBranches(
+    rule.branches,
+    document3,
+    runtimeContext
+  );
+  const sourceUnavailable = sourceUnavailableDiagnostics(branches);
   const selectedBranch = branches.find((branch) => branch.status === "passed");
-  const passed = selectedBranch !== void 0;
-  const diagnostics = passed ? [] : [noAlternativeMatchedDiagnostic(rule)];
+  const passed = selectedBranch !== void 0 && sourceUnavailable.length === 0;
+  let diagnostics = [];
+  if (sourceUnavailable.length > 0) {
+    diagnostics = sourceUnavailable;
+  } else if (!passed) {
+    diagnostics = [noAlternativeMatchedDiagnostic(rule)];
+  }
   return {
     ruleId: rule.ruleId,
     status: passed ? "passed" : "failed",
@@ -9954,15 +10061,25 @@ function evaluateCompiledDeclarativeAnyOfRule(rule, document3) {
     diagnostics,
     evaluation: {
       kind: "anyOf",
-      ...selectedBranch !== void 0 ? { selectedBranch: branchReferenceFromResult(selectedBranch) } : {},
+      ...passed && selectedBranch !== void 0 ? { selectedBranch: branchReferenceFromResult(selectedBranch) } : {},
       branches
     }
   };
 }
-function evaluateCompiledDeclarativeAllOfRule(rule, document3) {
-  const branches = evaluateCompiledDeclarativeBranches(rule.branches, document3);
-  const failed = branches.some((branch) => branch.status === "failed");
-  const diagnostics = failed ? [groupRequirementFailedDiagnostic(rule)] : [];
+function evaluateCompiledDeclarativeAllOfRule(rule, document3, runtimeContext = {}) {
+  const branches = evaluateCompiledDeclarativeBranches(
+    rule.branches,
+    document3,
+    runtimeContext
+  );
+  const sourceUnavailable = sourceUnavailableDiagnostics(branches);
+  const failed = sourceUnavailable.length > 0 || branches.some((branch) => branch.status === "failed");
+  let diagnostics = [];
+  if (sourceUnavailable.length > 0) {
+    diagnostics = sourceUnavailable;
+  } else if (failed) {
+    diagnostics = [groupRequirementFailedDiagnostic(rule)];
+  }
   const status = failed ? "failed" : "passed";
   return {
     ruleId: rule.ruleId,
@@ -9975,15 +10092,16 @@ function evaluateCompiledDeclarativeAllOfRule(rule, document3) {
     }
   };
 }
-function evaluateCompiledDeclarativeBranches(branches, document3) {
+function evaluateCompiledDeclarativeBranches(branches, document3, runtimeContext) {
   return branches.map(
-    (branch) => evaluateCompiledDeclarativeBranch(branch, document3)
+    (branch) => evaluateCompiledDeclarativeBranch(branch, document3, runtimeContext)
   );
 }
-function evaluateCompiledDeclarativeBranch(branch, document3) {
+function evaluateCompiledDeclarativeBranch(branch, document3, runtimeContext) {
   const result = evaluateCompiledDeclarativeRule(
     branch,
-    resolveDeclarativeSelector(document3, branch.selector)
+    resolveDeclarativeSelector(document3, branch.selector),
+    runtimeContext
   );
   return {
     branchIndex: branch.branchIndex,
@@ -9992,6 +10110,11 @@ function evaluateCompiledDeclarativeBranch(branch, document3) {
     diagnostics: result.diagnostics
   };
 }
+function sourceUnavailableDiagnostics(branches) {
+  return branches.flatMap(
+    (branch) => branch.diagnostics.filter(isSourceUnavailableDiagnostic)
+  );
+}
 function branchReferenceFromResult(branch) {
   return {
     branchIndex: branch.branchIndex,
@@ -9999,6 +10122,77 @@ function branchReferenceFromResult(branch) {
   };
 }
 
+// src/declarative-validation/profile/syntax-version.ts
+var PROFILE_SYNTAX_VERSION_V1 = "markdown-engine.validation@v1";
+var PROFILE_SYNTAX_VERSION_V2 = "markdown-engine.validation@v2";
+var PROFILE_SYNTAX_VERSION = PROFILE_SYNTAX_VERSION_V1;
+var SUPPORTED_PROFILE_SYNTAX_VERSIONS = [
+  PROFILE_SYNTAX_VERSION_V1,
+  PROFILE_SYNTAX_VERSION_V2
+];
+function isValidationProfileSyntaxVersion(value) {
+  return SUPPORTED_PROFILE_SYNTAX_VERSIONS.some(
+    (syntaxVersion) => value === syntaxVersion
+  );
+}
+
+// src/declarative-validation/diagnostics/profile-config-diagnostics.ts
+var REGEX_LIKE_PROFILE_KEYS = [
+  "matches",
+  "pattern",
+  "regex",
+  "regexp"
+];
+var UNSAFE_PROFILE_KEYS = [
+  "callback",
+  "eval",
+  "execute",
+  "expression",
+  "function",
+  "import",
+  "imports",
+  "plugin",
+  "script"
+];
+var CONFIG_UNSUPPORTED_KEY_PRECEDENCE = /* @__PURE__ */ new Set([
+  ...REGEX_LIKE_PROFILE_KEYS,
+  ...UNSAFE_PROFILE_KEYS
+]);
+function profileDiagnostic(code3, message) {
+  return { code: code3, message, severity: "error" };
+}
+function invalidProfileShape(message) {
+  return profileDiagnostic("profile.config.invalidShape", message);
+}
+function unsupportedProfileKey(key) {
+  return profileDiagnostic(
+    "profile.config.unsupportedKey",
+    `Unsupported validation profile key "${key}".`
+  );
+}
+function unsupportedSyntaxVersion() {
+  return profileDiagnostic(
+    "profile.config.unsupportedSyntaxVersion",
+    `Profile syntaxVersion must be ${quotedList(SUPPORTED_PROFILE_SYNTAX_VERSIONS)}`
+  );
+}
+function unsupportedProfileKeys(record, allowedKeys, diagnostics) {
+  for (const key of Object.keys(record)) {
+    if (!allowedKeys.includes(key)) {
+      diagnostics.push(unsupportedProfileKey(key));
+    }
+  }
+}
+function hasConfigUnsupportedKeyPrecedence(key) {
+  return CONFIG_UNSUPPORTED_KEY_PRECEDENCE.has(key);
+}
+function quotedList(values) {
+  const quotedValues = values.map((value) => `"${value}"`);
+  const finalValue = quotedValues.at(-1) ?? "";
+  const prefix = quotedValues.slice(0, -1).join(", ");
+  return prefix.length === 0 ? `${finalValue}.` : `${prefix} or ${finalValue}.`;
+}
+
 // src/declarative-validation/profile/data-closure.ts
 import { types as nodeTypes } from "node:util";
 var DATA_CLOSURE_FAILED = /* @__PURE__ */ Symbol("data-closure-failed");
@@ -10190,79 +10384,6 @@ function safePropertyDescriptor(value, key, fieldName, diagnostics, ruleId) {
 
 // src/declarative-validation/profile/direct-profile-diagnostics.ts
 import { types as nodeTypes2 } from "node:util";
-
-// src/declarative-validation/profile/syntax-version.ts
-var PROFILE_SYNTAX_VERSION_V1 = "markdown-engine.validation@v1";
-var PROFILE_SYNTAX_VERSION_V2 = "markdown-engine.validation@v2";
-var PROFILE_SYNTAX_VERSION = PROFILE_SYNTAX_VERSION_V1;
-var SUPPORTED_PROFILE_SYNTAX_VERSIONS = [
-  PROFILE_SYNTAX_VERSION_V1,
-  PROFILE_SYNTAX_VERSION_V2
-];
-function isValidationProfileSyntaxVersion(value) {
-  return SUPPORTED_PROFILE_SYNTAX_VERSIONS.some(
-    (syntaxVersion) => value === syntaxVersion
-  );
-}
-
-// src/declarative-validation/diagnostics/profile-config-diagnostics.ts
-var REGEX_LIKE_PROFILE_KEYS = [
-  "matches",
-  "pattern",
-  "regex",
-  "regexp"
-];
-var UNSAFE_PROFILE_KEYS = [
-  "callback",
-  "eval",
-  "execute",
-  "expression",
-  "function",
-  "import",
-  "imports",
-  "plugin",
-  "script"
-];
-var CONFIG_UNSUPPORTED_KEY_PRECEDENCE = /* @__PURE__ */ new Set([
-  ...REGEX_LIKE_PROFILE_KEYS,
-  ...UNSAFE_PROFILE_KEYS
-]);
-function profileDiagnostic(code3, message) {
-  return { code: code3, message, severity: "error" };
-}
-function invalidProfileShape(message) {
-  return profileDiagnostic("profile.config.invalidShape", message);
-}
-function unsupportedProfileKey(key) {
-  return profileDiagnostic(
-    "profile.config.unsupportedKey",
-    `Unsupported validation profile key "${key}".`
-  );
-}
-function unsupportedSyntaxVersion() {
-  return profileDiagnostic(
-    "profile.config.unsupportedSyntaxVersion",
-    `Profile syntaxVersion must be ${quotedList(SUPPORTED_PROFILE_SYNTAX_VERSIONS)}`
-  );
-}
-function unsupportedProfileKeys(record, allowedKeys, diagnostics) {
-  for (const key of Object.keys(record)) {
-    if (!allowedKeys.includes(key)) {
-      diagnostics.push(unsupportedProfileKey(key));
-    }
-  }
-}
-function hasConfigUnsupportedKeyPrecedence(key) {
-  return CONFIG_UNSUPPORTED_KEY_PRECEDENCE.has(key);
-}
-function quotedList(values) {
-  const quotedValues = values.map((value) => `"${value}"`);
-  const finalValue = quotedValues.at(-1) ?? "";
-  const prefix = quotedValues.slice(0, -1).join(", ");
-  return prefix.length === 0 ? `${finalValue}.` : `${prefix} or ${finalValue}.`;
-}
-
-// src/declarative-validation/profile/direct-profile-diagnostics.ts
 var PROFILE_KEYS = ["syntaxVersion", "documentVersion", "rules"];
 var RULE_KEYS_V1 = ["id", "severity", "select", "assert"];
 var RULE_KEYS_V2 = [...RULE_KEYS_V1, "when", "anyOf", "allOf"];
@@ -10873,38 +10994,6 @@ function pushTextOccurrenceCountDiagnostic(value, ruleId, diagnostics) {
     "textOccurrenceCount.count must be a number."
   );
 }
-function pushTextLengthShapeDiagnostics(assertion, ruleId, diagnostics) {
-  let valid = true;
-  const min = assertion?.min;
-  const max = assertion?.max;
-  if (min !== void 0 && !pushTextLengthNumberDiagnostic(
-    "textLength.min",
-    min,
-    ruleId,
-    diagnostics
-  )) {
-    valid = false;
-  }
-  if (max !== void 0 && !pushTextLengthNumberDiagnostic(
-    "textLength.max",
-    max,
-    ruleId,
-    diagnostics
-  )) {
-    valid = false;
-  }
-  if (valid && min !== void 0 && max !== void 0 && min > max) {
-    diagnostics.push(
-      compileDiagnostic(
-        "profile.config.invalidShape",
-        "textLength.min must be less than or equal to textLength.max.",
-        ruleId
-      )
-    );
-    valid = false;
-  }
-  return valid;
-}
 function pushIdsCountShapeDiagnostics(assertion, ruleId, diagnostics) {
   let valid = true;
   const minCount = assertion?.minCount;
@@ -11125,9 +11214,6 @@ function pushNonEmptyStringDiagnostic(fieldName, value, ruleId, diagnostics) {
   );
   return false;
 }
-function pushTextLengthNumberDiagnostic(fieldName, value, ruleId, diagnostics) {
-  return pushNonNegativeIntegerDiagnostic(fieldName, value, ruleId, diagnostics);
-}
 function pushNonNegativeIntegerDiagnostic(fieldName, value, ruleId, diagnostics) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     diagnostics.push(
@@ -11190,9 +11276,6 @@ function optionalNumber2(key, value) {
 function hasTextPredicate(assertion) {
   return assertion?.contains !== void 0 || assertion?.excludes !== void 0 && assertion.excludes.length > 0;
 }
-function hasTextLengthBound(assertion) {
-  return assertion?.min !== void 0 || assertion?.max !== void 0;
-}
 
 // src/declarative-validation/profile/ids-assertion-contract.ts
 var IDS_COUNT_BOUND_KEYS = ["minCount", "maxCount"];
@@ -11225,11 +11308,13 @@ function hasValidIdsCountRange(ids) {
 function selectorAssertionCompatibilityError(assertionName, selector) {
   switch (assertionName) {
     case "exists":
+    case "selectionCount":
       return void 0;
     case "sectionsRequired":
     case "references":
     case "tableColumnCoverage":
     case "frontmatterShape":
+    case "sourceLength":
       return selector.target === "document" ? void 0 : selectorCompatibilityMessage(assertionName, "document");
     case "tableColumnsRequired":
       return selector.target === "table" ? void 0 : selectorCompatibilityMessage(assertionName, "table");
@@ -11243,10 +11328,116 @@ function selectorAssertionCompatibilityError(assertionName, selector) {
       return selector.target === "document" ? void 0 : selectorCompatibilityMessage(assertionName, "document");
   }
 }
+function pushCompatibilityDiagnostic(assertionName, selector, ruleId, diagnostics) {
+  const message = selectorAssertionCompatibilityError(assertionName, selector);
+  if (message === void 0) {
+    return true;
+  }
+  diagnostics.push(
+    compileDiagnostic(
+      "profile.compile.incompatibleSelectorAssertion",
+      message,
+      ruleId
+    )
+  );
+  return false;
+}
 function selectorCompatibilityMessage(assertionName, selectorName) {
   return `Assertion "${assertionName}" is compatible only with ${selectorName} selectors.`;
 }
 
+// src/declarative-validation/compiler/length-assertion-builders.ts
+function buildSelectionCountAssertion(assertion, selector, ruleId, syntaxVersion, diagnostics) {
+  const bounds = assertion.selectionCount;
+  return bounds === void 0 || syntaxVersion !== PROFILE_SYNTAX_VERSION_V2 ? void 0 : buildLengthAssertion(
+    "selectionCount",
+    bounds,
+    selector,
+    ruleId,
+    diagnostics
+  );
+}
+function buildTextLengthAssertion(assertion, selector, ruleId, _syntaxVersion, diagnostics) {
+  const bounds = assertion.textLength;
+  return bounds === void 0 ? void 0 : buildLengthAssertion("textLength", bounds, selector, ruleId, diagnostics);
+}
+function buildSourceLengthAssertion(assertion, selector, ruleId, syntaxVersion, diagnostics) {
+  const bounds = assertion.sourceLength;
+  return bounds === void 0 || syntaxVersion !== PROFILE_SYNTAX_VERSION_V2 ? void 0 : buildLengthAssertion(
+    "sourceLength",
+    bounds,
+    selector,
+    ruleId,
+    diagnostics
+  );
+}
+function buildLengthAssertion(assertionName, bounds, selector, ruleId, diagnostics) {
+  if (!pushObjectDiagnostic(assertionName, bounds, ruleId, diagnostics) || !pushUnsupportedKeyDiagnostics(bounds, ["min", "max"], diagnostics) || !pushLengthBoundShapeDiagnostics(
+    assertionName,
+    bounds,
+    ruleId,
+    diagnostics
+  )) {
+    return void 0;
+  }
+  if (!hasLengthBound(bounds)) {
+    diagnostics.push(
+      compileDiagnostic(
+        "profile.config.invalidShape",
+        `${assertionName} must include min, max, or both.`,
+        ruleId
+      )
+    );
+    return void 0;
+  }
+  if (!pushCompatibilityDiagnostic(
+    assertionName,
+    selector,
+    ruleId,
+    diagnostics
+  )) {
+    return void 0;
+  }
+  return {
+    kind: assertionName,
+    ...optionalNumber2("min", bounds.min),
+    ...optionalNumber2("max", bounds.max)
+  };
+}
+function pushLengthBoundShapeDiagnostics(assertionName, bounds, ruleId, diagnostics) {
+  let valid = true;
+  if (bounds.min !== void 0 && !pushNonNegativeIntegerDiagnostic(
+    `${assertionName}.min`,
+    bounds.min,
+    ruleId,
+    diagnostics
+  )) {
+    valid = false;
+  }
+  if (bounds.max !== void 0 && !pushNonNegativeIntegerDiagnostic(
+    `${assertionName}.max`,
+    bounds.max,
+    ruleId,
+    diagnostics
+  )) {
+    valid = false;
+  }
+  if (valid && bounds.min !== void 0 && bounds.max !== void 0 && bounds.min > bounds.max) {
+    diagnostics.push(
+      compileDiagnostic(
+        "profile.config.invalidShape",
+        `${assertionName}.min must be less than or equal to ${assertionName}.max.`,
+        ruleId
+      )
+    );
+    valid = false;
+  }
+  return valid;
+}
+function hasLengthBound(bounds) {
+  return bounds.min !== void 0 || bounds.max !== void 0;
+}
+
 // src/declarative-validation/compiler/assertion-builders.ts
 var ASSERTION_BUILDERS = [
   buildExistsAssertion,
@@ -11258,7 +11449,9 @@ var ASSERTION_BUILDERS = [
   buildFrontmatterShapeAssertion,
   buildTextAssertion,
   buildTextOccurrenceCountAssertion,
+  buildSelectionCountAssertion,
   buildTextLengthAssertion,
+  buildSourceLengthAssertion,
   buildTextFormatAssertion,
   buildFrontmatterRequiredAssertion
 ];
@@ -11577,32 +11770,6 @@ function buildTextOccurrenceCountAssertion(assertion, selector, ruleId, _syntaxV
   }
   return void 0;
 }
-function buildTextLengthAssertion(assertion, selector, ruleId, _syntaxVersion, diagnostics) {
-  if (assertion.textLength === void 0) {
-    return void 0;
-  }
-  if (!pushObjectDiagnostic("textLength", assertion.textLength, ruleId, diagnostics) || !pushUnsupportedKeyDiagnostics(assertion.textLength, ["min", "max"], diagnostics) || !pushTextLengthShapeDiagnostics(assertion.textLength, ruleId, diagnostics)) {
-    return void 0;
-  }
-  if (!hasTextLengthBound(assertion.textLength)) {
-    diagnostics.push(
-      compileDiagnostic(
-        "profile.config.invalidShape",
-        "textLength must include min, max, or both.",
-        ruleId
-      )
-    );
-    return void 0;
-  }
-  if (pushCompatibilityDiagnostic("textLength", selector, ruleId, diagnostics)) {
-    return {
-      kind: "textLength",
-      ...optionalNumber2("min", assertion.textLength.min),
-      ...optionalNumber2("max", assertion.textLength.max)
-    };
-  }
-  return void 0;
-}
 function buildTextFormatAssertion(assertion, selector, ruleId, syntaxVersion, diagnostics) {
   if (assertion.textFormat === void 0 || syntaxVersion !== PROFILE_SYNTAX_VERSION_V2) {
     return void 0;
@@ -11650,20 +11817,6 @@ function buildFrontmatterRequiredAssertion(assertion, selector, ruleId, _syntaxV
   }
   return void 0;
 }
-function pushCompatibilityDiagnostic(assertionName, selector, ruleId, diagnostics) {
-  const message = selectorAssertionCompatibilityError(assertionName, selector);
-  if (message !== void 0) {
-    diagnostics.push(
-      compileDiagnostic(
-        "profile.compile.incompatibleSelectorAssertion",
-        message,
-        ruleId
-      )
-    );
-    return false;
-  }
-  return true;
-}
 
 // src/declarative-validation/compiler/assertions.ts
 var ASSERTION_KEYS_V1 = [
@@ -11679,6 +11832,8 @@ var ASSERTION_KEYS_V1 = [
 ];
 var ASSERTION_KEYS_V2 = [
   ...ASSERTION_KEYS_V1,
+  "selectionCount",
+  "sourceLength",
   "tableColumnCoverage",
   "frontmatterShape",
   "textFormat"
@@ -11941,6 +12096,12 @@ function compileValidationProfile(profile) {
       ]
     };
   }
+  const syntaxVersion = closedProfile.syntaxVersion;
+  if (!isValidationProfileSyntaxVersion(syntaxVersion)) {
+    return {
+      diagnostics: [...diagnostics, unsupportedSyntaxVersion()]
+    };
+  }
   const profileRules = profileRulesFromValue(closedProfile.rules, diagnostics);
   if (profileRules === void 0) {
     return { diagnostics };
@@ -11975,7 +12136,7 @@ function compileValidationProfile(profile) {
       index2,
       ruleId,
       severity ?? "error",
-      profile.syntaxVersion,
+      syntaxVersion,
       diagnostics
     );
     if (compiledRule !== void 0) {
@@ -11983,7 +12144,7 @@ function compileValidationProfile(profile) {
     }
   }
   return diagnostics.length > 0 ? { diagnostics } : {
-    plan: compiledPlanFromRules(profile.syntaxVersion, rules),
+    plan: compiledPlanFromRules(syntaxVersion, rules),
     diagnostics
   };
 }
@@ -12363,6 +12524,70 @@ var YAML_MATERIALIZE_OPTIONS = {
   maxAliasCount: 50
 };
 
+// src/declarative-validation/profile/length-bound-schema.ts
+function lengthBoundsFromValue(value, assertionName, diagnostics) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isPlainRecord(value)) {
+    diagnostics.push(invalidShape(`${assertionName} must be an object.`));
+    return void 0;
+  }
+  unsupportedKeys(value, ["min", "max"], diagnostics);
+  const diagnosticCountBeforeBounds = diagnostics.length;
+  const bounds = {
+    ...optionalLengthBound(value, assertionName, "min", diagnostics),
+    ...optionalLengthBound(value, assertionName, "max", diagnostics)
+  };
+  if (!hasLengthBound2(bounds)) {
+    if (diagnostics.length === diagnosticCountBeforeBounds) {
+      diagnostics.push(
+        invalidShape(`${assertionName} must include min, max, or both.`)
+      );
+    }
+    return void 0;
+  }
+  if (!hasValidLengthRange(bounds)) {
+    diagnostics.push(
+      invalidShape(
+        `${assertionName}.min must be less than or equal to ${assertionName}.max.`
+      )
+    );
+    return void 0;
+  }
+  return bounds;
+}
+function optionalLengthBound(record, assertionName, key, diagnostics) {
+  const value = record[key];
+  if (value === void 0) {
+    return {};
+  }
+  if (!isFiniteNumber(value)) {
+    diagnostics.push(
+      invalidShape(`${assertionName}.${key} must be a number when provided.`)
+    );
+    return {};
+  }
+  if (!isNonNegativeInteger(value)) {
+    diagnostics.push(
+      invalidShape(
+        `${assertionName}.${key} must be a non-negative integer when provided.`
+      )
+    );
+    return {};
+  }
+  return { [key]: value };
+}
+function hasLengthBound2(bounds) {
+  return bounds.min !== void 0 || bounds.max !== void 0;
+}
+function hasValidLengthRange(bounds) {
+  return bounds.min === void 0 || bounds.max === void 0 || bounds.min <= bounds.max;
+}
+function isNonNegativeInteger(value) {
+  return Number.isInteger(value) && value >= 0;
+}
+
 // src/declarative-validation/profile/assertion-schema.ts
 var SUPPORTED_ASSERTION_KEYS_V1 = [
   "exists",
@@ -12377,6 +12602,8 @@ var SUPPORTED_ASSERTION_KEYS_V1 = [
 ];
 var SUPPORTED_ASSERTION_KEYS_V2 = [
   ...SUPPORTED_ASSERTION_KEYS_V1,
+  "selectionCount",
+  "sourceLength",
   "tableColumnCoverage",
   "frontmatterShape",
   "textFormat"
@@ -12400,6 +12627,8 @@ function assertionFromValue(value, syntaxVersion, diagnostics) {
     ...textAssertionFromValue(value.text, diagnostics),
     ...textOccurrenceCountFromValue(value.textOccurrenceCount, diagnostics),
     ...textLengthFromValue(value.textLength, diagnostics),
+    ...supportsV2AssertionSurface(syntaxVersion) ? selectionCountFromValue(value.selectionCount, diagnostics) : {},
+    ...supportsV2AssertionSurface(syntaxVersion) ? sourceLengthFromValue(value.sourceLength, diagnostics) : {},
     ...frontmatterRequiredFromValue(value.frontmatterRequired, diagnostics),
     ...supportsV2AssertionSurface(syntaxVersion) ? tableColumnCoverageFromValue(value.tableColumnCoverage, diagnostics) : {},
     ...supportsV2AssertionSurface(syntaxVersion) ? frontmatterShapeFromValue2(value.frontmatterShape, diagnostics) : {},
@@ -12743,34 +12972,16 @@ function textOccurrenceCountFromValue(value, diagnostics) {
   };
 }
 function textLengthFromValue(value, diagnostics) {
-  if (value === void 0) {
-    return {};
-  }
-  if (!isPlainRecord(value)) {
-    diagnostics.push(invalidShape("textLength must be an object."));
-    return {};
-  }
-  unsupportedKeys(value, ["min", "max"], diagnostics);
-  const diagnosticCountBeforeBounds = diagnostics.length;
-  const textLength = {
-    ...optionalTextLengthBound(value, "min", diagnostics),
-    ...optionalTextLengthBound(value, "max", diagnostics)
-  };
-  if (!hasTextLengthBound2(textLength)) {
-    if (diagnostics.length === diagnosticCountBeforeBounds) {
-      diagnostics.push(
-        invalidShape("textLength must include min, max, or both.")
-      );
-    }
-    return {};
-  }
-  if (!hasValidTextLengthRange(textLength)) {
-    diagnostics.push(
-      invalidShape("textLength.min must be less than or equal to textLength.max.")
-    );
-    return {};
-  }
-  return { textLength };
+  const bounds = lengthBoundsFromValue(value, "textLength", diagnostics);
+  return bounds === void 0 ? {} : { textLength: bounds };
+}
+function selectionCountFromValue(value, diagnostics) {
+  const bounds = lengthBoundsFromValue(value, "selectionCount", diagnostics);
+  return bounds === void 0 ? {} : { selectionCount: bounds };
+}
+function sourceLengthFromValue(value, diagnostics) {
+  const bounds = lengthBoundsFromValue(value, "sourceLength", diagnostics);
+  return bounds === void 0 ? {} : { sourceLength: bounds };
 }
 function textFormatFromValue(value, diagnostics) {
   if (value === void 0) {
@@ -12848,27 +13059,6 @@ function optionalBoolean2(record, key, diagnostics) {
     (field) => `${field} must be a boolean when provided.`
   );
 }
-function optionalTextLengthBound(record, key, diagnostics) {
-  const value = record[key];
-  if (value === void 0) {
-    return {};
-  }
-  if (!isFiniteNumber(value)) {
-    diagnostics.push(
-      invalidShape(`textLength.${key} must be a number when provided.`)
-    );
-    return {};
-  }
-  if (!isTextLengthBound(value)) {
-    diagnostics.push(
-      invalidShape(
-        `textLength.${key} must be a non-negative integer when provided.`
-      )
-    );
-    return {};
-  }
-  return { [key]: value };
-}
 function optionalIdCountBound(record, key, diagnostics) {
   const value = record[key];
   if (value === void 0) {
@@ -12878,7 +13068,7 @@ function optionalIdCountBound(record, key, diagnostics) {
     diagnostics.push(invalidShape(`ids.${key} must be a number when provided.`));
     return {};
   }
-  if (!isNonNegativeInteger(value)) {
+  if (!isNonNegativeInteger2(value)) {
     diagnostics.push(
       invalidShape(`ids.${key} must be a non-negative integer when provided.`)
     );
@@ -12897,16 +13087,7 @@ function requiredAssertionString(value, field, diagnostics) {
 function hasTextPredicate2(text5) {
   return text5?.contains !== void 0 || text5?.excludes !== void 0;
 }
-function hasTextLengthBound2(textLength) {
-  return textLength?.min !== void 0 || textLength?.max !== void 0;
-}
-function hasValidTextLengthRange(textLength) {
-  return textLength?.min === void 0 || textLength.max === void 0 || textLength.min <= textLength.max;
-}
-function isTextLengthBound(value) {
-  return isNonNegativeInteger(value);
-}
-function isNonNegativeInteger(value) {
+function isNonNegativeInteger2(value) {
   return Number.isInteger(value) && value >= 0;
 }
 
@@ -13419,7 +13600,7 @@ function cloneSourceRange2(sourceRange) {
 import { createHash } from "node:crypto";
 
 // src/internal/package-version.ts
-var MARKDOWN_ENGINE_PACKAGE_VERSION = "3.1.1";
+var MARKDOWN_ENGINE_PACKAGE_VERSION = "3.3.0";
 
 // src/internal/stable-json.ts
 function normalizeStableJsonValue(value) {
@@ -13555,16 +13736,37 @@ function passedFromStatus(status) {
 }
 
 // src/declarative-validation/evidence/index.ts
-function createDeclarativeValidationEvidence(document3, profile, ruleResults, diagnostics) {
+function createDeclarativeValidationEvidence(document3, profile, ruleResults, diagnostics, sourceText) {
+  const sourceLength = sourceText !== void 0 && profileUsesSourceLength(profile) ? sourceText.length : void 0;
   return {
-    inputHash: sha256(stringifyStableJson(documentWithoutPath(document3))),
+    inputHash: sha256(
+      stringifyStableJson(canonicalInput(document3, sourceLength))
+    ),
     profileHash: sha256(stringifyStableJson(resolvedProfile(profile, document3))),
     engineVersion: MARKDOWN_ENGINE_PACKAGE_VERSION,
     runtimeVersion: process.version,
+    ...sourceLength !== void 0 ? { sourceLength } : {},
     ruleResults: cloneRuleResults(ruleResults),
     diagnostics: cloneDiagnostics(diagnostics)
   };
 }
+function canonicalInput(document3, sourceLength) {
+  const normalizedDocument = documentWithoutPath(document3);
+  return sourceLength === void 0 ? normalizedDocument : { document: normalizedDocument, sourceLength };
+}
+function profileUsesSourceLength(profile) {
+  return profile.rules.some(ruleUsesSourceLength);
+}
+function ruleUsesSourceLength(rule) {
+  if (rule.when?.assert.sourceLength !== void 0) {
+    return true;
+  }
+  if ("assert" in rule) {
+    return rule.assert.sourceLength !== void 0;
+  }
+  const branches = "anyOf" in rule ? rule.anyOf : rule.allOf;
+  return branches.some((branch) => branch.assert.sourceLength !== void 0);
+}
 function resolvedProfile(profile, document3) {
   return {
     syntaxVersion: profile.syntaxVersion,
@@ -13646,7 +13848,8 @@ function withEvidence(result, document3, profile, options) {
       document3,
       profile,
       result.ruleResults,
-      result.diagnostics
+      result.diagnostics,
+      options.sourceText
     )
   };
 }
@@ -13712,8 +13915,11 @@ function validateWithProfile(document3, profile, options = {}) {
   }
   const compileResult = compileValidationProfile(materializedProfile.profile);
   const compiledRules = compileResult.plan?.rules ?? [];
+  const runtimeContext = options.sourceText === void 0 ? {} : { sourceText: options.sourceText };
   const ruleResults = sortValidationRuleResults(
-    compiledRules.flatMap((rule) => evaluateApplicableCompiledRule(document3, rule))
+    compiledRules.flatMap(
+      (rule) => evaluateApplicableCompiledRule(document3, rule, runtimeContext)
+    )
   );
   const diagnostics = [
     ...compileResult.diagnostics,
@@ -13727,32 +13933,56 @@ function validateWithProfile(document3, profile, options = {}) {
     options
   });
 }
-function evaluateApplicableCompiledRule(document3, rule) {
+function evaluateApplicableCompiledRule(document3, rule, runtimeContext) {
   const applicability = classifyCompiledDeclarativeRuleApplicability(
     rule,
-    document3
+    document3,
+    runtimeContext
   );
-  return applicability.status === "notMatched" ? [
-    createSkippedDeclarativeValidationRuleResult({
-      ruleId: rule.ruleId,
-      when: applicability.result
-    })
-  ] : evaluateCompiledRule(document3, rule);
+  if (applicability.status === "notMatched") {
+    if (applicability.result.diagnostics.some(isSourceUnavailableDiagnostic)) {
+      return [sourceUnavailableApplicabilityResult(rule, applicability.result)];
+    }
+    return [
+      createSkippedDeclarativeValidationRuleResult({
+        ruleId: rule.ruleId,
+        when: applicability.result
+      })
+    ];
+  }
+  return evaluateCompiledRule(document3, rule, runtimeContext);
 }
-function evaluateCompiledRule(document3, rule) {
+function evaluateCompiledRule(document3, rule, runtimeContext) {
   if (isCompiledAnyOfRule(rule)) {
-    return [evaluateCompiledDeclarativeAnyOfRule(rule, document3)];
+    return [evaluateCompiledDeclarativeAnyOfRule(rule, document3, runtimeContext)];
   }
   if (isCompiledAllOfRule(rule)) {
-    return [evaluateCompiledDeclarativeAllOfRule(rule, document3)];
+    return [evaluateCompiledDeclarativeAllOfRule(rule, document3, runtimeContext)];
   }
   return [
     evaluateCompiledDeclarativeRule(
       rule,
-      resolveDeclarativeSelector(document3, rule.selector)
+      resolveDeclarativeSelector(document3, rule.selector),
+      runtimeContext
     )
   ];
 }
+function sourceUnavailableApplicabilityResult(rule, when) {
+  const diagnostics = when.diagnostics.filter(
+    isSourceUnavailableDiagnostic
+  );
+  return {
+    ruleId: rule.ruleId,
+    status: "failed",
+    passed: false,
+    diagnostics,
+    when,
+    evaluation: {
+      kind: "assertions",
+      diagnostics
+    }
+  };
+}
 function isCompiledAnyOfRule(rule) {
   return "kind" in rule && rule.kind === "anyOf";
 }
@@ -27212,6 +27442,7 @@ async function runDeclarativeValidationCli(input) {
       documentDiagnosticsResult(
         normalizeResult.document,
         profileResult.profile,
+        markdown.content,
         [
           ...documentDiagnostics,
           ...documentVersionDiagnostics(
@@ -27226,7 +27457,7 @@ async function runDeclarativeValidationCli(input) {
   const validationResult = validateWithProfile(
     normalizeResult.document,
     profileResult.profile,
-    { includeEvidence: true }
+    { includeEvidence: true, sourceText: markdown.content }
   );
   const result = mergeDocumentDiagnostics(
     validationResult,
@@ -27258,13 +27489,13 @@ function profileStageResult(diagnostics) {
     ruleResults: []
   };
 }
-function documentDiagnosticsResult(document3, profile, diagnostics) {
+function documentDiagnosticsResult(document3, profile, sourceText, diagnostics) {
   return createDeclarativeValidationResult({
     document: document3,
     profile,
     ruleResults: [],
     diagnostics,
-    options: { includeEvidence: true }
+    options: { includeEvidence: true, sourceText }
   });
 }
 function mergeDocumentDiagnostics(validationResult, documentDiagnostics) {