@jasonbelmonti/markdown-engine 3.6.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 = {}) {
@@ -9003,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) {
@@ -9751,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) {
@@ -10137,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":
@@ -11568,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":
@@ -11689,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,
@@ -12122,6 +12185,7 @@ var ASSERTION_KEYS_V2 = [
   "selectionCount",
   "sourceLength",
   "tableColumnsExact",
+  "tableRowsComplete",
   "tableColumnCoverage",
   "frontmatterShape",
   "textFormat"
@@ -12893,6 +12957,7 @@ var SUPPORTED_ASSERTION_KEYS_V2 = [
   "selectionCount",
   "sourceLength",
   "tableColumnsExact",
+  "tableRowsComplete",
   "tableColumnCoverage",
   "frontmatterShape",
   "textFormat"
@@ -12919,6 +12984,7 @@ function assertionFromValue(value, syntaxVersion, 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) : {},
@@ -12974,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 {};
@@ -13926,7 +14002,7 @@ function cloneSourceRange2(sourceRange) {
 import { createHash } from "node:crypto";
 
 // src/internal/package-version.ts
-var MARKDOWN_ENGINE_PACKAGE_VERSION = "3.6.0";
+var MARKDOWN_ENGINE_PACKAGE_VERSION = "3.8.0";
 
 // src/internal/stable-json.ts
 function normalizeStableJsonValue(value) {
@@ -19740,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;
@@ -24607,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),
@@ -24635,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),
@@ -25187,7 +25263,7 @@ function compiler(options) {
       alt: null
     };
   }
-  function link2() {
+  function link3() {
     return {
       type: "link",
       title: null,
@@ -25688,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'`).
@@ -26289,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} */
@@ -26320,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);
@@ -26423,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"
@@ -26437,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);
@@ -27449,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.
 
@@ -27463,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) {
@@ -27585,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>)
@@ -27616,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}.`);
@@ -27643,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) {
@@ -27731,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);
@@ -27741,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);
@@ -27764,7 +27887,7 @@ async function runDeclarativeValidationCli(input) {
     ...normalizeResult.diagnostics
   ];
   if (hasErrorDiagnostic(normalizeResult.diagnostics)) {
-    return outputResult(
+    return outputValidationResult(
       documentDiagnosticsResult(
         normalizeResult.document,
         profileResult.profile,
@@ -27777,7 +27900,8 @@ async function runDeclarativeValidationCli(input) {
           )
         ]
       ),
-      1
+      1,
+      input
     );
   }
   const validationResult = validateWithProfile(
@@ -27789,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) {
@@ -27844,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 {
@@ -27886,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}