@jasonbelmonti/markdown-engine 3.0.0 → 3.1.1

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

@@ -7715,6 +7715,134 @@ function hasOwnProperty(object, property) {
   return Object.prototype.hasOwnProperty.call(object, property);
 }
 
+// src/declarative-validation/assertions/frontmatter-shape.ts
+function evaluateFrontmatterShape(assertion, context) {
+  const frontmatter = context.selection.document.frontmatter;
+  const diagnostics = [];
+  if (assertion.presence === "required" && frontmatter === void 0) {
+    diagnostics.push(requiredFrontmatterDiagnostic(context));
+  }
+  if (assertion.presence === "forbidden" && frontmatter !== void 0) {
+    diagnostics.push(forbiddenFrontmatterDiagnostic(context));
+  }
+  if (assertion.fields === void 0) {
+    return diagnostics;
+  }
+  if (!isPlainRecord(frontmatter)) {
+    for (const [fieldOrder, field] of assertion.fields.entries()) {
+      if (field.required === true) {
+        diagnostics.push(missingFieldDiagnostic(field, context, fieldOrder));
+      }
+    }
+    return diagnostics;
+  }
+  for (const [fieldOrder, field] of assertion.fields.entries()) {
+    diagnostics.push(
+      ...evaluateFrontmatterField(frontmatter, field, context, fieldOrder)
+    );
+  }
+  return diagnostics;
+}
+function evaluateFrontmatterField(frontmatter, field, context, fieldOrder) {
+  if (!hasOwnProperty(frontmatter, field.field)) {
+    return field.required === true ? [missingFieldDiagnostic(field, context, fieldOrder)] : [];
+  }
+  const value = frontmatter[field.field];
+  const diagnostics = [];
+  if (field.valueType !== void 0 && !matchesFrontmatterValueType(value, field.valueType)) {
+    diagnostics.push(typeMismatchDiagnostic(field, context, fieldOrder));
+  }
+  if (field.nonEmpty === true && failsNonEmptyStringPredicate(value, field)) {
+    diagnostics.push(emptyFieldDiagnostic(field, context, fieldOrder));
+  }
+  return diagnostics;
+}
+function requiredFrontmatterDiagnostic(context) {
+  return validationDiagnostic(
+    "profile.validation.frontmatterMissing",
+    "Frontmatter is required.",
+    context.rule,
+    {
+      assertionIndex: context.assertionIndex,
+      targetKey: "frontmatter:presence:required",
+      diagnosticOrder: 0
+    }
+  );
+}
+function forbiddenFrontmatterDiagnostic(context) {
+  return validationDiagnostic(
+    "profile.validation.frontmatterForbidden",
+    "Frontmatter is forbidden.",
+    context.rule,
+    {
+      assertionIndex: context.assertionIndex,
+      targetKey: "frontmatter:presence:forbidden",
+      diagnosticOrder: 0
+    }
+  );
+}
+function missingFieldDiagnostic(field, context, fieldOrder) {
+  return validationDiagnostic(
+    "profile.validation.frontmatterFieldMissing",
+    `Required frontmatter field "${field.field}" is missing.`,
+    context.rule,
+    {
+      assertionIndex: context.assertionIndex,
+      targetKey: frontmatterFieldTargetKey(field, "missing"),
+      diagnosticOrder: fieldOrder
+    }
+  );
+}
+function typeMismatchDiagnostic(field, context, fieldOrder) {
+  return validationDiagnostic(
+    "profile.validation.frontmatterFieldTypeMismatch",
+    `Frontmatter field "${field.field}" must be ${field.valueType}.`,
+    context.rule,
+    {
+      assertionIndex: context.assertionIndex,
+      targetKey: frontmatterFieldTargetKey(field, "type"),
+      diagnosticOrder: fieldOrder
+    }
+  );
+}
+function emptyFieldDiagnostic(field, context, fieldOrder) {
+  return validationDiagnostic(
+    "profile.validation.frontmatterFieldEmpty",
+    `Frontmatter field "${field.field}" must be a non-empty string.`,
+    context.rule,
+    {
+      assertionIndex: context.assertionIndex,
+      targetKey: frontmatterFieldTargetKey(field, "nonEmpty"),
+      diagnosticOrder: fieldOrder
+    }
+  );
+}
+function frontmatterFieldTargetKey(field, predicate) {
+  return `frontmatter:${field.field}:${predicate}`;
+}
+function matchesFrontmatterValueType(value, valueType) {
+  switch (valueType) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isPlainRecord(value);
+    case "null":
+      return value === null;
+  }
+}
+function failsNonEmptyStringPredicate(value, field) {
+  if (field.valueType === "string" && typeof value !== "string") {
+    return false;
+  }
+  return typeof value !== "string" || value.length === 0;
+}
+
 // src/declarative-validation/assertions/frontmatter-required.ts
 function evaluateFrontmatterRequired(assertion, context) {
   return assertion.fields.filter(
@@ -9572,6 +9700,86 @@ function excludedTextDiagnostics(assertion, context, target, targetOrder) {
   );
 }
 
+// src/declarative-validation/assertions/text-format.ts
+function evaluateTextFormat(assertion, context) {
+  if (context.selection.targets.length === 0) {
+    return [emptySelectionDiagnostic(context.rule, context.assertionIndex)];
+  }
+  switch (assertion.format) {
+    case "isoDate":
+      return context.selection.targets.flatMap(
+        (target, targetOrder) => evaluateIsoDateTarget(context, target, targetOrder)
+      );
+  }
+}
+function evaluateIsoDateTarget(context, target, targetOrder) {
+  if (isIsoDateText(target.text)) {
+    return [];
+  }
+  return [
+    validationDiagnostic(
+      "profile.validation.assertionFailed",
+      `Selected ${target.kind} text must be an exact ISO date in YYYY-MM-DD form.`,
+      context.rule,
+      {
+        assertionIndex: context.assertionIndex,
+        target,
+        targetOrder
+      }
+    )
+  ];
+}
+function isIsoDateText(text5) {
+  if (text5.length !== 10 || text5[4] !== "-" || text5[7] !== "-") {
+    return false;
+  }
+  const year = decimalValue(text5, 0, 4);
+  const month = decimalValue(text5, 5, 7);
+  const day = decimalValue(text5, 8, 10);
+  if (year === void 0 || month === void 0 || day === void 0) {
+    return false;
+  }
+  const maximumDay = daysInMonth(year, month);
+  return maximumDay !== void 0 && day >= 1 && day <= maximumDay;
+}
+function decimalValue(text5, start, end) {
+  const zeroCode = 48;
+  const nineCode = 57;
+  let value = 0;
+  for (let index2 = start; index2 < end; index2 += 1) {
+    const charCode = text5.charCodeAt(index2);
+    if (charCode < zeroCode || charCode > nineCode) {
+      return void 0;
+    }
+    value = value * 10 + (charCode - zeroCode);
+  }
+  return value;
+}
+function daysInMonth(year, month) {
+  switch (month) {
+    case 1:
+    case 3:
+    case 5:
+    case 7:
+    case 8:
+    case 10:
+    case 12:
+      return 31;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+      return 30;
+    case 2:
+      return isLeapYear(year) ? 29 : 28;
+    default:
+      return void 0;
+  }
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+
 // src/declarative-validation/assertions/text-length.ts
 function evaluateTextLength(assertion, context) {
   if (context.selection.targets.length === 0) {
@@ -9677,6 +9885,8 @@ function evaluateAssertion(assertion, context) {
       return evaluateTextOccurrenceCount(assertion, context);
     case "textLength":
       return evaluateTextLength(assertion, context);
+    case "textFormat":
+      return evaluateTextFormat(assertion, context);
     case "frontmatterRequired":
       return evaluateFrontmatterRequired(assertion, context);
     case "tableColumnsRequired":
@@ -9687,6 +9897,8 @@ function evaluateAssertion(assertion, context) {
       return evaluateReferences(assertion, context);
     case "tableColumnCoverage":
       return evaluateTableColumnCoverage(assertion, context);
+    case "frontmatterShape":
+      return evaluateFrontmatterShape(assertion, context);
   }
 }
 
@@ -10383,6 +10595,220 @@ function requiredSelectorString(value, field, diagnostics) {
   );
 }
 
+// src/declarative-validation/profile/text-format-contract.ts
+var TEXT_FORMAT_ASSERTION_KEYS = ["format"];
+var TEXT_FORMAT_ISO_DATE = "isoDate";
+function isTextFormatAssertionFormat(value) {
+  return value === TEXT_FORMAT_ISO_DATE;
+}
+
+// src/declarative-validation/profile/frontmatter-shape-schema.ts
+var FRONTMATTER_PRESENCE_VALUES = /* @__PURE__ */ new Set([
+  "required",
+  "forbidden"
+]);
+var FRONTMATTER_VALUE_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "array",
+  "object",
+  "null"
+]);
+function frontmatterShapeFromValue(value) {
+  const invalidShapes = [];
+  const unsupportedKeys2 = [];
+  const shape = frontmatterShape(value, invalidShapes, unsupportedKeys2);
+  return {
+    ...shape !== void 0 ? { shape } : {},
+    invalidShapes,
+    unsupportedKeys: unsupportedKeys2
+  };
+}
+function frontmatterShape(value, invalidShapes, unsupportedKeys2) {
+  if (!isPlainRecord(value)) {
+    invalidShapes.push("frontmatterShape must be an object.");
+    return void 0;
+  }
+  collectUnsupportedKeys(value, ["presence", "fields"], unsupportedKeys2);
+  let valid = true;
+  const presence = frontmatterPresence(value.presence, invalidShapes);
+  if (value.presence !== void 0 && presence === void 0) {
+    valid = false;
+  }
+  const fields = frontmatterFields(value.fields, invalidShapes, unsupportedKeys2);
+  if (value.fields !== void 0 && fields === void 0) {
+    valid = false;
+  }
+  if (value.presence === void 0 && value.fields === void 0) {
+    invalidShapes.push("frontmatterShape must include presence or fields.");
+    valid = false;
+  }
+  if (presence === "forbidden" && fields !== void 0) {
+    invalidShapes.push(
+      "frontmatterShape.fields cannot be provided when presence is forbidden."
+    );
+    valid = false;
+  }
+  return valid ? {
+    ...presence !== void 0 ? { presence } : {},
+    ...fields !== void 0 ? { fields } : {}
+  } : void 0;
+}
+function frontmatterPresence(value, invalidShapes) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && FRONTMATTER_PRESENCE_VALUES.has(value)) {
+    return value;
+  }
+  invalidShapes.push(
+    'frontmatterShape.presence must be "required" or "forbidden" when provided.'
+  );
+  return void 0;
+}
+function frontmatterFields(value, invalidShapes, unsupportedKeys2) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value) || value.length === 0) {
+    invalidShapes.push(
+      "frontmatterShape.fields must be a non-empty array when provided."
+    );
+    return void 0;
+  }
+  const fields = [];
+  const seenFields = /* @__PURE__ */ new Set();
+  let valid = true;
+  for (let index2 = 0; index2 < value.length; index2 += 1) {
+    const fieldShape = frontmatterField(
+      value[index2],
+      index2,
+      invalidShapes,
+      unsupportedKeys2
+    );
+    if (fieldShape === void 0) {
+      valid = false;
+      continue;
+    }
+    if (seenFields.has(fieldShape.field)) {
+      invalidShapes.push(
+        `frontmatterShape.fields[${index2}].field duplicates field "${fieldShape.field}".`
+      );
+      valid = false;
+      continue;
+    }
+    seenFields.add(fieldShape.field);
+    fields.push(fieldShape);
+  }
+  return valid ? fields : void 0;
+}
+function frontmatterField(value, index2, invalidShapes, unsupportedKeys2) {
+  const fieldName = `frontmatterShape.fields[${index2}]`;
+  if (!isPlainRecord(value)) {
+    invalidShapes.push(`${fieldName} must be an object.`);
+    return void 0;
+  }
+  collectUnsupportedKeys(
+    value,
+    ["field", "required", "valueType", "nonEmpty"],
+    unsupportedKeys2
+  );
+  let valid = true;
+  const field = nonEmptyString2(value.field);
+  if (field === void 0) {
+    invalidShapes.push(`${fieldName}.field must be a non-empty string.`);
+    valid = false;
+  }
+  const required = trueConstraint(
+    value.required,
+    `${fieldName}.required`,
+    invalidShapes
+  );
+  if (value.required !== void 0 && required === void 0) {
+    valid = false;
+  }
+  const valueType = frontmatterValueType(
+    value.valueType,
+    `${fieldName}.valueType`,
+    invalidShapes
+  );
+  if (value.valueType !== void 0 && valueType === void 0) {
+    valid = false;
+  }
+  const nonEmpty = trueConstraint(
+    value.nonEmpty,
+    `${fieldName}.nonEmpty`,
+    invalidShapes
+  );
+  if (value.nonEmpty !== void 0 && nonEmpty === void 0) {
+    valid = false;
+  }
+  if (nonEmpty === true && valueType !== void 0 && valueType !== "string") {
+    invalidShapes.push(
+      `${fieldName}.nonEmpty can be combined only with valueType "string".`
+    );
+    valid = false;
+  }
+  const hasPredicateInput = value.required !== void 0 || value.valueType !== void 0 || value.nonEmpty !== void 0;
+  if (!hasPredicateInput) {
+    invalidShapes.push(
+      `${fieldName} must include required, valueType, or nonEmpty.`
+    );
+    valid = false;
+  }
+  if (!valid || field === void 0) {
+    return void 0;
+  }
+  const baseField = {
+    field,
+    ...required === true ? { required: true } : {}
+  };
+  if (nonEmpty === true) {
+    return {
+      ...baseField,
+      ...valueType === "string" ? { valueType } : {},
+      nonEmpty: true
+    };
+  }
+  return {
+    ...baseField,
+    ...valueType !== void 0 ? { valueType } : {}
+  };
+}
+function trueConstraint(value, fieldName, invalidShapes) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === true) {
+    return true;
+  }
+  invalidShapes.push(`${fieldName} must be true when provided.`);
+  return void 0;
+}
+function frontmatterValueType(value, fieldName, invalidShapes) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && FRONTMATTER_VALUE_TYPES.has(value)) {
+    return value;
+  }
+  invalidShapes.push(
+    `${fieldName} must be "string", "number", "boolean", "array", "object", or "null" when provided.`
+  );
+  return void 0;
+}
+function nonEmptyString2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function collectUnsupportedKeys(record, allowedKeys, unsupportedKeys2) {
+  for (const key of Object.keys(record)) {
+    if (!allowedKeys.includes(key)) {
+      unsupportedKeys2.push(key);
+    }
+  }
+}
+
 // src/declarative-validation/compiler/diagnostics.ts
 function compileDiagnostic(code3, message, ruleId) {
   return {
@@ -10630,6 +11056,46 @@ function closedTableColumnCoverageTarget(value, ruleId, diagnostics) {
     column: target.column
   } : void 0;
 }
+function closedFrontmatterShape(value, ruleId, diagnostics) {
+  const result = frontmatterShapeFromValue(value);
+  for (const key of result.unsupportedKeys) {
+    diagnostics.push(unsupportedProfileKey(key));
+  }
+  for (const message of result.invalidShapes) {
+    diagnostics.push(
+      compileDiagnostic(
+        "profile.config.invalidShape",
+        message,
+        ruleId
+      )
+    );
+  }
+  return result.shape;
+}
+function closedTextFormat(value, ruleId, diagnostics) {
+  const diagnosticCountBefore = diagnostics.length;
+  if (!pushObjectDiagnostic("textFormat", value, ruleId, diagnostics)) {
+    return void 0;
+  }
+  const record = value;
+  const hasSupportedKeys = pushUnsupportedKeyDiagnostics(
+    record,
+    TEXT_FORMAT_ASSERTION_KEYS,
+    diagnostics
+  );
+  const format = record.format;
+  const hasSupportedFormat = isTextFormatAssertionFormat(format);
+  if (!hasSupportedFormat) {
+    diagnostics.push(
+      compileDiagnostic(
+        "profile.config.invalidShape",
+        'textFormat.format must be "isoDate".',
+        ruleId
+      )
+    );
+  }
+  return hasSupportedKeys && diagnostics.length === diagnosticCountBefore && hasSupportedFormat ? { format } : void 0;
+}
 function pushOptionalNonEmptyStringDiagnostic(fieldName, value, ruleId, diagnostics) {
   return value === void 0 ? true : pushNonEmptyStringDiagnostic(fieldName, value, ruleId, diagnostics);
 }
@@ -10763,6 +11229,7 @@ function selectorAssertionCompatibilityError(assertionName, selector) {
     case "sectionsRequired":
     case "references":
     case "tableColumnCoverage":
+    case "frontmatterShape":
       return selector.target === "document" ? void 0 : selectorCompatibilityMessage(assertionName, "document");
     case "tableColumnsRequired":
       return selector.target === "table" ? void 0 : selectorCompatibilityMessage(assertionName, "table");
@@ -10770,6 +11237,7 @@ function selectorAssertionCompatibilityError(assertionName, selector) {
     case "text":
     case "textOccurrenceCount":
     case "textLength":
+    case "textFormat":
       return void 0;
     case "frontmatterRequired":
       return selector.target === "document" ? void 0 : selectorCompatibilityMessage(assertionName, "document");
@@ -10787,9 +11255,11 @@ var ASSERTION_BUILDERS = [
   buildIdsAssertion,
   buildReferencesAssertion,
   buildTableColumnCoverageAssertion,
+  buildFrontmatterShapeAssertion,
   buildTextAssertion,
   buildTextOccurrenceCountAssertion,
   buildTextLengthAssertion,
+  buildTextFormatAssertion,
   buildFrontmatterRequiredAssertion
 ];
 function buildExistsAssertion(assertion, selector, ruleId, _syntaxVersion, diagnostics) {
@@ -11018,6 +11488,29 @@ function buildTableColumnCoverageAssertion(assertion, selector, ruleId, syntaxVe
   }
   return void 0;
 }
+function buildFrontmatterShapeAssertion(assertion, selector, ruleId, syntaxVersion, diagnostics) {
+  if (assertion.frontmatterShape === void 0 || syntaxVersion !== PROFILE_SYNTAX_VERSION_V2) {
+    return void 0;
+  }
+  const frontmatterShape2 = closedFrontmatterShape(
+    assertion.frontmatterShape,
+    ruleId,
+    diagnostics
+  );
+  if (frontmatterShape2 !== void 0 && pushCompatibilityDiagnostic(
+    "frontmatterShape",
+    selector,
+    ruleId,
+    diagnostics
+  )) {
+    return {
+      kind: "frontmatterShape",
+      ...frontmatterShape2.presence !== void 0 ? { presence: frontmatterShape2.presence } : {},
+      ...frontmatterShape2.fields !== void 0 ? { fields: frontmatterShape2.fields } : {}
+    };
+  }
+  return void 0;
+}
 function buildTextAssertion(assertion, selector, ruleId, _syntaxVersion, diagnostics) {
   if (assertion.text === void 0) {
     return void 0;
@@ -11110,6 +11603,19 @@ function buildTextLengthAssertion(assertion, selector, ruleId, _syntaxVersion, d
   }
   return void 0;
 }
+function buildTextFormatAssertion(assertion, selector, ruleId, syntaxVersion, diagnostics) {
+  if (assertion.textFormat === void 0 || syntaxVersion !== PROFILE_SYNTAX_VERSION_V2) {
+    return void 0;
+  }
+  const textFormat = closedTextFormat(assertion.textFormat, ruleId, diagnostics);
+  if (textFormat !== void 0 && pushCompatibilityDiagnostic("textFormat", selector, ruleId, diagnostics)) {
+    return {
+      kind: "textFormat",
+      format: textFormat.format
+    };
+  }
+  return void 0;
+}
 function buildFrontmatterRequiredAssertion(assertion, selector, ruleId, _syntaxVersion, diagnostics) {
   if (assertion.frontmatterRequired === void 0) {
     return void 0;
@@ -11173,7 +11679,9 @@ var ASSERTION_KEYS_V1 = [
 ];
 var ASSERTION_KEYS_V2 = [
   ...ASSERTION_KEYS_V1,
-  "tableColumnCoverage"
+  "tableColumnCoverage",
+  "frontmatterShape",
+  "textFormat"
 ];
 function compiledAssertionsFromValue(assertion, selector, ruleId, syntaxVersion, diagnostics) {
   const compiled = [];
@@ -11869,7 +12377,9 @@ var SUPPORTED_ASSERTION_KEYS_V1 = [
 ];
 var SUPPORTED_ASSERTION_KEYS_V2 = [
   ...SUPPORTED_ASSERTION_KEYS_V1,
-  "tableColumnCoverage"
+  "tableColumnCoverage",
+  "frontmatterShape",
+  "textFormat"
 ];
 function assertionFromValue(value, syntaxVersion, diagnostics) {
   if (!isPlainRecord(value)) {
@@ -11891,7 +12401,9 @@ function assertionFromValue(value, syntaxVersion, diagnostics) {
     ...textOccurrenceCountFromValue(value.textOccurrenceCount, diagnostics),
     ...textLengthFromValue(value.textLength, diagnostics),
     ...frontmatterRequiredFromValue(value.frontmatterRequired, diagnostics),
-    ...supportsTableColumnCoverage(syntaxVersion) ? tableColumnCoverageFromValue(value.tableColumnCoverage, diagnostics) : {}
+    ...supportsV2AssertionSurface(syntaxVersion) ? tableColumnCoverageFromValue(value.tableColumnCoverage, diagnostics) : {},
+    ...supportsV2AssertionSurface(syntaxVersion) ? frontmatterShapeFromValue2(value.frontmatterShape, diagnostics) : {},
+    ...supportsV2AssertionSurface(syntaxVersion) ? textFormatFromValue(value.textFormat, diagnostics) : {}
   };
   if (Object.keys(assertion).length === 0) {
     if (hasUnsupportedVocabulary) {
@@ -11926,9 +12438,9 @@ function unsupportedAssertionKeys(value, syntaxVersion, diagnostics) {
   return hasUnsupportedVocabulary;
 }
 function assertionKeysForSyntaxVersion2(syntaxVersion) {
-  return supportsTableColumnCoverage(syntaxVersion) ? SUPPORTED_ASSERTION_KEYS_V2 : SUPPORTED_ASSERTION_KEYS_V1;
+  return supportsV2AssertionSurface(syntaxVersion) ? SUPPORTED_ASSERTION_KEYS_V2 : SUPPORTED_ASSERTION_KEYS_V1;
 }
-function supportsTableColumnCoverage(syntaxVersion) {
+function supportsV2AssertionSurface(syntaxVersion) {
   return syntaxVersion === PROFILE_SYNTAX_VERSION_V2;
 }
 function existsFromValue(value, diagnostics) {
@@ -12169,6 +12681,19 @@ function optionalTableColumnCoverageTargetStringArray(record, key, diagnostics)
     (field) => `tableColumnCoverage.target.${field} must be an array of non-empty strings when provided.`
   );
 }
+function frontmatterShapeFromValue2(value, diagnostics) {
+  if (value === void 0) {
+    return {};
+  }
+  const result = frontmatterShapeFromValue(value);
+  for (const key of result.unsupportedKeys) {
+    diagnostics.push(unsupportedProfileKey(key));
+  }
+  for (const message of result.invalidShapes) {
+    diagnostics.push(invalidShape(message));
+  }
+  return result.shape === void 0 ? {} : { frontmatterShape: result.shape };
+}
 function textAssertionFromValue(value, diagnostics) {
   if (value === void 0) {
     return {};
@@ -12247,6 +12772,28 @@ function textLengthFromValue(value, diagnostics) {
   }
   return { textLength };
 }
+function textFormatFromValue(value, diagnostics) {
+  if (value === void 0) {
+    return {};
+  }
+  if (!isPlainRecord(value)) {
+    diagnostics.push(invalidShape("textFormat must be an object."));
+    return {};
+  }
+  const diagnosticCountBeforeShape = diagnostics.length;
+  unsupportedKeys(value, TEXT_FORMAT_ASSERTION_KEYS, diagnostics);
+  const format = value.format;
+  const hasSupportedFormat = isTextFormatAssertionFormat(format);
+  if (!hasSupportedFormat) {
+    diagnostics.push(
+      invalidShape('textFormat.format must be "isoDate".')
+    );
+  }
+  if (diagnostics.length > diagnosticCountBeforeShape || !hasSupportedFormat) {
+    return {};
+  }
+  return { textFormat: { format } };
+}
 function frontmatterRequiredFromValue(value, diagnostics) {
   if (value === void 0) {
     return {};
@@ -12871,6 +13418,9 @@ function cloneSourceRange2(sourceRange) {
 // src/declarative-validation/evidence/index.ts
 import { createHash } from "node:crypto";
 
+// src/internal/package-version.ts
+var MARKDOWN_ENGINE_PACKAGE_VERSION = "3.1.1";
+
 // src/internal/stable-json.ts
 function normalizeStableJsonValue(value) {
   if (Array.isArray(value)) {
@@ -13009,7 +13559,7 @@ function createDeclarativeValidationEvidence(document3, profile, ruleResults, di
   return {
     inputHash: sha256(stringifyStableJson(documentWithoutPath(document3))),
     profileHash: sha256(stringifyStableJson(resolvedProfile(profile, document3))),
-    engineVersion: "3.0.0",
+    engineVersion: MARKDOWN_ENGINE_PACKAGE_VERSION,
     runtimeVersion: process.version,
     ruleResults: cloneRuleResults(ruleResults),
     diagnostics: cloneDiagnostics(diagnostics)